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.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040301
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) && defined(SWIG_HEAPTYPES)
207/* SWIG_HEAPTYPES is not ready for use with SWIGPYTHON_BUILTIN, but if turned on manually requires the following */
208#if PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030c0000
209#include <structmember.h>
210#define Py_READONLY READONLY
211#define Py_T_PYSSIZET T_PYSSIZET
212#endif
213#endif
214
215#if __GNUC__ >= 7
216#pragma GCC diagnostic pop
217#endif
218
219#include <stdio.h>
220#include <stdlib.h>
221
222/* -----------------------------------------------------------------------------
223 * swigrun.swg
224 *
225 * This file contains generic C API SWIG runtime support for pointer
226 * type checking.
227 * ----------------------------------------------------------------------------- */
228
229/* This should only be incremented when either the layout of swig_type_info changes,
230 or for whatever reason, the runtime changes incompatibly */
231#define SWIG_RUNTIME_VERSION "4"
232
233/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
234#ifdef SWIG_TYPE_TABLE
235# define SWIG_QUOTE_STRING(x) #x
236# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
237# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
238#else
239# define SWIG_TYPE_TABLE_NAME
240#endif
241
242/*
243 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
244 creating a static or dynamic library from the SWIG runtime code.
245 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
246
247 But only do this if strictly necessary, ie, if you have problems
248 with your compiler or suchlike.
249*/
250
251#ifndef SWIGRUNTIME
252# define SWIGRUNTIME SWIGINTERN
253#endif
254
255#ifndef SWIGRUNTIMEINLINE
256# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
257#endif
258
259/* Generic buffer size */
260#ifndef SWIG_BUFFER_SIZE
261# define SWIG_BUFFER_SIZE 1024
262#endif
263
264/* Flags for pointer conversions */
265#define SWIG_POINTER_DISOWN 0x1
266#define SWIG_CAST_NEW_MEMORY 0x2
267#define SWIG_POINTER_NO_NULL 0x4
268#define SWIG_POINTER_CLEAR 0x8
269#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
270
271/* Flags for new pointer objects */
272#define SWIG_POINTER_OWN 0x1
273
274
275/*
276 Flags/methods for returning states.
277
278 The SWIG conversion methods, as ConvertPtr, return an integer
279 that tells if the conversion was successful or not. And if not,
280 an error code can be returned (see swigerrors.swg for the codes).
281
282 Use the following macros/flags to set or process the returning
283 states.
284
285 In old versions of SWIG, code such as the following was usually written:
286
287 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
288 // success code
289 } else {
290 //fail code
291 }
292
293 Now you can be more explicit:
294
295 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
296 if (SWIG_IsOK(res)) {
297 // success code
298 } else {
299 // fail code
300 }
301
302 which is the same really, but now you can also do
303
304 Type *ptr;
305 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
306 if (SWIG_IsOK(res)) {
307 // success code
308 if (SWIG_IsNewObj(res) {
309 ...
310 delete *ptr;
311 } else {
312 ...
313 }
314 } else {
315 // fail code
316 }
317
318 I.e., now SWIG_ConvertPtr can return new objects and you can
319 identify the case and take care of the deallocation. Of course that
320 also requires SWIG_ConvertPtr to return new result values, such as
321
322 int SWIG_ConvertPtr(obj, ptr,...) {
323 if (<obj is ok>) {
324 if (<need new object>) {
325 *ptr = <ptr to new allocated object>;
326 return SWIG_NEWOBJ;
327 } else {
328 *ptr = <ptr to old object>;
329 return SWIG_OLDOBJ;
330 }
331 } else {
332 return SWIG_BADOBJ;
333 }
334 }
335
336 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
337 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
338 SWIG errors code.
339
340 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
341 allows returning the 'cast rank', for example, if you have this
342
343 int food(double)
344 int fooi(int);
345
346 and you call
347
348 food(1) // cast rank '1' (1 -> 1.0)
349 fooi(1) // cast rank '0'
350
351 just use the SWIG_AddCast()/SWIG_CheckState()
352*/
353
354#define SWIG_OK (0)
355/* Runtime errors are < 0 */
356#define SWIG_ERROR (-1)
357/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
358/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
359/* Errors < -200 are generic runtime specific errors */
360#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
361
362#define SWIG_IsOK(r) (r >= 0)
363#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
364
365/* The CastRankLimit says how many bits are used for the cast rank */
366#define SWIG_CASTRANKLIMIT (1 << 8)
367/* The NewMask denotes the object was created (using new/malloc) */
368#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
369/* The TmpMask is for in/out typemaps that use temporary objects */
370#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
371/* Simple returning values */
372#define SWIG_BADOBJ (SWIG_ERROR)
373#define SWIG_OLDOBJ (SWIG_OK)
374#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
375#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
376/* Check, add and del object mask methods */
377#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
378#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
379#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
380#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
381#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
382#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
383
384/* Cast-Rank Mode */
385#if defined(SWIG_CASTRANK_MODE)
386# ifndef SWIG_TypeRank
387# define SWIG_TypeRank unsigned long
388# endif
389# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
390# define SWIG_MAXCASTRANK (2)
391# endif
392# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
393# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
395 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
396}
398 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
399}
400#else /* no cast-rank mode */
401# define SWIG_AddCast(r) (r)
402# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
403#endif
404
405
406#include <string.h>
407
408#ifdef __cplusplus
409extern "C" {
410#endif
411
412typedef void *(*swig_converter_func)(void *, int *);
413typedef struct swig_type_info *(*swig_dycast_func)(void **);
414
415/* Structure to store information on one type */
416typedef struct swig_type_info {
417 const char *name; /* mangled name of this type */
418 const char *str; /* human readable name of this type */
419 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
420 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
421 void *clientdata; /* language specific type data */
422 int owndata; /* flag if the structure owns the clientdata */
424
425/* Structure to store a type and conversion function used for casting */
426typedef struct swig_cast_info {
427 swig_type_info *type; /* pointer to type that is equivalent to this type */
428 swig_converter_func converter; /* function to cast the void pointers */
429 struct swig_cast_info *next; /* pointer to next cast in linked list */
430 struct swig_cast_info *prev; /* pointer to the previous cast */
432
433/* Structure used to store module information
434 * Each module generates one structure like this, and the runtime collects
435 * all of these structures and stores them in a circularly linked list.*/
436typedef struct swig_module_info {
437 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
438 size_t size; /* Number of types in this module */
439 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
440 swig_type_info **type_initial; /* Array of initially generated type structures */
441 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
442 void *clientdata; /* Language specific module data */
444
445/*
446 Compare two type names skipping the space characters, therefore
447 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
448
449 Return 0 when the two name types are equivalent, as in
450 strncmp, but skipping ' '.
451*/
452SWIGRUNTIME int
453SWIG_TypeNameComp(const char *f1, const char *l1,
454 const char *f2, const char *l2) {
455 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
456 while ((*f1 == ' ') && (f1 != l1)) ++f1;
457 while ((*f2 == ' ') && (f2 != l2)) ++f2;
458 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
459 }
460 return (int)((l1 - f1) - (l2 - f2));
461}
462
463/*
464 Check type equivalence in a name list like <name1>|<name2>|...
465 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
466*/
467SWIGRUNTIME int
468SWIG_TypeCmp(const char *nb, const char *tb) {
469 int equiv = 1;
470 const char* te = tb + strlen(tb);
471 const char* ne = nb;
472 while (equiv != 0 && *ne) {
473 for (nb = ne; *ne; ++ne) {
474 if (*ne == '|') break;
475 }
476 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
477 if (*ne) ++ne;
478 }
479 return equiv;
480}
481
482/*
483 Check type equivalence in a name list like <name1>|<name2>|...
484 Return 0 if not equal, 1 if equal
485*/
486SWIGRUNTIME int
487SWIG_TypeEquiv(const char *nb, const char *tb) {
488 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
489}
490
491/*
492 Check the typename
493*/
495SWIG_TypeCheck(const char *c, swig_type_info *ty) {
496 if (ty) {
497 swig_cast_info *iter = ty->cast;
498 while (iter) {
499 if (strcmp(iter->type->name, c) == 0) {
500 if (iter == ty->cast)
501 return iter;
502 /* Move iter to the top of the linked list */
503 iter->prev->next = iter->next;
504 if (iter->next)
505 iter->next->prev = iter->prev;
506 iter->next = ty->cast;
507 iter->prev = 0;
508 if (ty->cast) ty->cast->prev = iter;
509 ty->cast = iter;
510 return iter;
511 }
512 iter = iter->next;
513 }
514 }
515 return 0;
516}
517
518/*
519 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
520*/
523 if (ty) {
524 swig_cast_info *iter = ty->cast;
525 while (iter) {
526 if (iter->type == from) {
527 if (iter == ty->cast)
528 return iter;
529 /* Move iter to the top of the linked list */
530 iter->prev->next = iter->next;
531 if (iter->next)
532 iter->next->prev = iter->prev;
533 iter->next = ty->cast;
534 iter->prev = 0;
535 if (ty->cast) ty->cast->prev = iter;
536 ty->cast = iter;
537 return iter;
538 }
539 iter = iter->next;
540 }
541 }
542 return 0;
543}
544
545/*
546 Cast a pointer up an inheritance hierarchy
547*/
549SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
550 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
551}
552
553/*
554 Dynamic pointer casting. Down an inheritance hierarchy
555*/
558 swig_type_info *lastty = ty;
559 if (!ty || !ty->dcast) return ty;
560 while (ty && (ty->dcast)) {
561 ty = (*ty->dcast)(ptr);
562 if (ty) lastty = ty;
563 }
564 return lastty;
565}
566
567/*
568 Return the name associated with this type
569*/
570SWIGRUNTIMEINLINE const char *
572 return ty->name;
573}
574
575/*
576 Return the pretty name associated with this type,
577 that is an unmangled type name in a form presentable to the user.
578*/
579SWIGRUNTIME const char *
581 /* The "str" field contains the equivalent pretty names of the
582 type, separated by vertical-bar characters. Choose the last
583 name. It should be the most specific; a fully resolved name
584 but not necessarily with default template parameters expanded. */
585 if (!type) return NULL;
586 if (type->str != NULL) {
587 const char *last_name = type->str;
588 const char *s;
589 for (s = type->str; *s; s++)
590 if (*s == '|') last_name = s+1;
591 return last_name;
592 }
593 else
594 return type->name;
595}
596
597/*
598 Set the clientdata field for a type
599*/
600SWIGRUNTIME void
602 swig_cast_info *cast = ti->cast;
603 /* if (ti->clientdata == clientdata) return; */
605
606 while (cast) {
607 if (!cast->converter) {
608 swig_type_info *tc = cast->type;
609 if (!tc->clientdata) {
611 }
612 }
613 cast = cast->next;
614 }
615}
616SWIGRUNTIME void
621
622/*
623 Search for a swig_type_info structure only by mangled name
624 Search is a O(log #types)
625
626 We start searching at module start, and finish searching when start == end.
627 Note: if start == end at the beginning of the function, we go all the way around
628 the circular list.
629*/
632 swig_module_info *end,
633 const char *name) {
634 swig_module_info *iter = start;
635 do {
636 if (iter->size) {
637 size_t l = 0;
638 size_t r = iter->size - 1;
639 do {
640 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
641 size_t i = (l + r) >> 1;
642 const char *iname = iter->types[i]->name;
643 if (iname) {
644 int compare = strcmp(name, iname);
645 if (compare == 0) {
646 return iter->types[i];
647 } else if (compare < 0) {
648 if (i) {
649 r = i - 1;
650 } else {
651 break;
652 }
653 } else if (compare > 0) {
654 l = i + 1;
655 }
656 } else {
657 break; /* should never happen */
658 }
659 } while (l <= r);
660 }
661 iter = iter->next;
662 } while (iter != end);
663 return 0;
664}
665
666/*
667 Search for a swig_type_info structure for either a mangled name or a human readable name.
668 It first searches the mangled names of the types, which is a O(log #types)
669 If a type is not found it then searches the human readable names, which is O(#types).
670
671 We start searching at module start, and finish searching when start == end.
672 Note: if start == end at the beginning of the function, we go all the way around
673 the circular list.
674*/
677 swig_module_info *end,
678 const char *name) {
679 /* STEP 1: Search the name field using binary search */
681 if (ret) {
682 return ret;
683 } else {
684 /* STEP 2: If the type hasn't been found, do a complete search
685 of the str field (the human readable name) */
686 swig_module_info *iter = start;
687 do {
688 size_t i = 0;
689 for (; i < iter->size; ++i) {
690 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
691 return iter->types[i];
692 }
693 iter = iter->next;
694 } while (iter != end);
695 }
696
697 /* neither found a match */
698 return 0;
699}
700
701/*
702 Pack binary data into a string
703*/
704SWIGRUNTIME char *
705SWIG_PackData(char *c, void *ptr, size_t sz) {
706 static const char hex[17] = "0123456789abcdef";
707 const unsigned char *u = (unsigned char *) ptr;
708 const unsigned char *eu = u + sz;
709 for (; u != eu; ++u) {
710 unsigned char uu = *u;
711 *(c++) = hex[(uu & 0xf0) >> 4];
712 *(c++) = hex[uu & 0xf];
713 }
714 return c;
715}
716
717/*
718 Unpack binary data from a string
719*/
720SWIGRUNTIME const char *
721SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
722 unsigned char *u = (unsigned char *) ptr;
723 const unsigned char *eu = u + sz;
724 for (; u != eu; ++u) {
725 char d = *(c++);
726 unsigned char uu;
727 if ((d >= '0') && (d <= '9'))
728 uu = (unsigned char)((d - '0') << 4);
729 else if ((d >= 'a') && (d <= 'f'))
730 uu = (unsigned char)((d - ('a'-10)) << 4);
731 else
732 return (char *) 0;
733 d = *(c++);
734 if ((d >= '0') && (d <= '9'))
735 uu |= (unsigned char)(d - '0');
736 else if ((d >= 'a') && (d <= 'f'))
737 uu |= (unsigned char)(d - ('a'-10));
738 else
739 return (char *) 0;
740 *u = uu;
741 }
742 return c;
743}
744
745/*
746 Pack 'void *' into a string buffer.
747*/
748SWIGRUNTIME char *
749SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
750 char *r = buff;
751 if ((2*sizeof(void *) + 2) > bsz) return 0;
752 *(r++) = '_';
753 r = SWIG_PackData(r,&ptr,sizeof(void *));
754 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
755 strcpy(r,name);
756 return buff;
757}
758
759SWIGRUNTIME const char *
760SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
761 if (*c != '_') {
762 if (strcmp(c,"NULL") == 0) {
763 *ptr = (void *) 0;
764 return name;
765 } else {
766 return 0;
767 }
768 }
769 return SWIG_UnpackData(++c,ptr,sizeof(void *));
770}
771
772SWIGRUNTIME char *
773SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
774 char *r = buff;
775 size_t lname = (name ? strlen(name) : 0);
776 if ((2*sz + 2 + lname) > bsz) return 0;
777 *(r++) = '_';
778 r = SWIG_PackData(r,ptr,sz);
779 if (lname) {
780 strncpy(r,name,lname+1);
781 } else {
782 *r = 0;
783 }
784 return buff;
785}
786
787SWIGRUNTIME const char *
788SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
789 if (*c != '_') {
790 if (strcmp(c,"NULL") == 0) {
791 memset(ptr,0,sz);
792 return name;
793 } else {
794 return 0;
795 }
796 }
797 return SWIG_UnpackData(++c,ptr,sz);
798}
799
800#ifdef __cplusplus
801}
802#endif
803
804/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
805#define SWIG_UnknownError -1
806#define SWIG_IOError -2
807#define SWIG_RuntimeError -3
808#define SWIG_IndexError -4
809#define SWIG_TypeError -5
810#define SWIG_DivisionByZero -6
811#define SWIG_OverflowError -7
812#define SWIG_SyntaxError -8
813#define SWIG_ValueError -9
814#define SWIG_SystemError -10
815#define SWIG_AttributeError -11
816#define SWIG_MemoryError -12
817#define SWIG_NullReferenceError -13
818
819
820/* Compatibility macros for Python 3 */
821#if PY_VERSION_HEX >= 0x03000000
822
823#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
824#define PyInt_Check(x) PyLong_Check(x)
825#define PyInt_AsLong(x) PyLong_AsLong(x)
826#define PyInt_FromLong(x) PyLong_FromLong(x)
827#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
828#define PyString_Check(name) PyBytes_Check(name)
829#define PyString_FromString(x) PyUnicode_FromString(x)
830#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
831#define PyString_AsString(str) PyBytes_AsString(str)
832#define PyString_Size(str) PyBytes_Size(str)
833#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
834#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
835#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
836
837#endif
838
839/* SWIG APIs for compatibility of both Python 2 & 3 */
840
841#if PY_VERSION_HEX >= 0x03000000
842# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
843#else
844# define SWIG_Python_str_FromFormat PyString_FromFormat
845#endif
846
847
848/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
849SWIGINTERN const char *
850SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
851{
852#if PY_VERSION_HEX >= 0x03030000
853# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
854 *pbytes = NULL;
855 return PyUnicode_AsUTF8AndSize(str, psize);
856# else
857 const char *chars;
858 *pbytes = PyUnicode_AsUTF8String(str);
859 chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
860 if (chars && psize)
861 *psize = PyBytes_Size(*pbytes);
862 return chars;
863# endif
864#else
865 char *chars = NULL;
866 *pbytes = NULL;
867 PyString_AsStringAndSize(str, &chars, psize);
868 return chars;
869#endif
870}
871
872SWIGINTERN PyObject*
874{
875#if PY_VERSION_HEX >= 0x03000000
876 return PyUnicode_FromString(c);
877#else
878 return PyString_FromString(c);
879#endif
880}
881
882/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
883# define SWIGPY_USE_CAPSULE
884#ifdef SWIGPYTHON_BUILTIN
885# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
886#else
887# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
888#endif
889# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
890
891#if PY_VERSION_HEX < 0x03020000
892#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
893#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
894#define Py_hash_t long
895#endif
896
897#ifdef Py_LIMITED_API
898# define PyTuple_GET_ITEM PyTuple_GetItem
899/* 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
900 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. */
901# define PyTuple_SET_ITEM PyTuple_SetItem
902# define PyTuple_GET_SIZE PyTuple_Size
903# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
904# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
905# define PyCFunction_GET_SELF PyCFunction_GetSelf
906# define PyList_GET_ITEM PyList_GetItem
907# define PyList_SET_ITEM PyList_SetItem
908# define PySliceObject PyObject
909#endif
910
911/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
912#ifdef Py_LIMITED_API
913# define SWIG_Py_INCREF Py_IncRef
914# define SWIG_Py_XINCREF Py_IncRef
915# define SWIG_Py_DECREF Py_DecRef
916# define SWIG_Py_XDECREF Py_DecRef
917#else
918# define SWIG_Py_INCREF Py_INCREF
919# define SWIG_Py_XINCREF Py_XINCREF
920# define SWIG_Py_DECREF Py_DECREF
921# define SWIG_Py_XDECREF Py_XDECREF
922#endif
923
924/* -----------------------------------------------------------------------------
925 * error manipulation
926 * ----------------------------------------------------------------------------- */
927
928SWIGRUNTIME PyObject*
930 PyObject* type = 0;
931 switch(code) {
932 case SWIG_MemoryError:
933 type = PyExc_MemoryError;
934 break;
935 case SWIG_IOError:
936 type = PyExc_IOError;
937 break;
939 type = PyExc_RuntimeError;
940 break;
941 case SWIG_IndexError:
942 type = PyExc_IndexError;
943 break;
944 case SWIG_TypeError:
945 type = PyExc_TypeError;
946 break;
948 type = PyExc_ZeroDivisionError;
949 break;
951 type = PyExc_OverflowError;
952 break;
953 case SWIG_SyntaxError:
954 type = PyExc_SyntaxError;
955 break;
956 case SWIG_ValueError:
957 type = PyExc_ValueError;
958 break;
959 case SWIG_SystemError:
960 type = PyExc_SystemError;
961 break;
963 type = PyExc_AttributeError;
964 break;
966 type = PyExc_TypeError;
967 break;
968 default:
969 type = PyExc_RuntimeError;
970 }
971 return type;
972}
973
974
975SWIGRUNTIME void
976SWIG_Python_AddErrorMsg(const char* mesg)
977{
978 PyObject *type = 0;
979 PyObject *value = 0;
980 PyObject *traceback = 0;
981
982 if (PyErr_Occurred())
983 PyErr_Fetch(&type, &value, &traceback);
984 if (value) {
985 PyObject *old_str = PyObject_Str(value);
986 PyObject *bytes = NULL;
987 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
988 PyErr_Clear();
989 SWIG_Py_XINCREF(type);
990 if (tmp)
991 PyErr_Format(type, "%s %s", tmp, mesg);
992 else
993 PyErr_Format(type, "%s", mesg);
994 SWIG_Py_XDECREF(bytes);
995 SWIG_Py_DECREF(old_str);
997 } else {
998 PyErr_SetString(PyExc_RuntimeError, mesg);
999 }
1000}
1001
1002SWIGRUNTIME int
1004{
1005 PyObject *error;
1006 if (obj)
1007 return 0;
1008 error = PyErr_Occurred();
1009 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
1010}
1011
1012SWIGRUNTIME void
1014{
1016 /* Use existing TypeError to preserve stacktrace and enhance with given message */
1017 PyObject *newvalue;
1018 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1019 PyErr_Fetch(&type, &value, &traceback);
1020#if PY_VERSION_HEX >= 0x03000000
1021 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
1022#else
1023 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
1024#endif
1025 if (newvalue) {
1027 PyErr_Restore(type, newvalue, traceback);
1028 } else {
1029 PyErr_Restore(type, value, traceback);
1030 }
1031 } else {
1032 /* Raise TypeError using given message */
1033 PyErr_SetString(PyExc_TypeError, message);
1034 }
1035}
1036
1037#if defined(SWIG_PYTHON_NO_THREADS)
1038# if defined(SWIG_PYTHON_THREADS)
1039# undef SWIG_PYTHON_THREADS
1040# endif
1041#endif
1042#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1043# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1044# define SWIG_PYTHON_USE_GIL
1045# endif
1046# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1047# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1048# if PY_VERSION_HEX < 0x03070000
1049# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1050# else
1051# define SWIG_PYTHON_INITIALIZE_THREADS
1052# endif
1053# endif
1054# ifdef __cplusplus /* C++ code */
1055 class SWIG_Python_Thread_Block {
1056 bool status;
1057 PyGILState_STATE state;
1058 public:
1059 void end() { if (status) { PyGILState_Release(state); status = false;} }
1060 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1061 ~SWIG_Python_Thread_Block() { end(); }
1062 };
1063 class SWIG_Python_Thread_Allow {
1064 bool status;
1065 PyThreadState *save;
1066 public:
1067 void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
1068 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1069 ~SWIG_Python_Thread_Allow() { end(); }
1070 };
1071# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1072# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1073# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1074# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1075# else /* C code */
1076# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1077# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1078# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1079# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1080# endif
1081# else /* Old thread way, not implemented, user must provide it */
1082# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1083# define SWIG_PYTHON_INITIALIZE_THREADS
1084# endif
1085# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1086# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1087# endif
1088# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1089# define SWIG_PYTHON_THREAD_END_BLOCK
1090# endif
1091# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1092# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1093# endif
1094# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1095# define SWIG_PYTHON_THREAD_END_ALLOW
1096# endif
1097# endif
1098#else /* No thread support */
1099# define SWIG_PYTHON_INITIALIZE_THREADS
1100# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1101# define SWIG_PYTHON_THREAD_END_BLOCK
1102# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1103# define SWIG_PYTHON_THREAD_END_ALLOW
1104#endif
1105
1106/* -----------------------------------------------------------------------------
1107 * Python API portion that goes into the runtime
1108 * ----------------------------------------------------------------------------- */
1109
1110#ifdef __cplusplus
1111extern "C" {
1112#endif
1113
1114/* -----------------------------------------------------------------------------
1115 * Constant declarations
1116 * ----------------------------------------------------------------------------- */
1117
1118/* Constant Types */
1119#define SWIG_PY_POINTER 4
1120#define SWIG_PY_BINARY 5
1121
1122/* Constant information structure */
1131
1132#ifdef __cplusplus
1133}
1134#endif
1135
1136
1137/* -----------------------------------------------------------------------------
1138 * pyrun.swg
1139 *
1140 * This file contains the runtime support for Python modules
1141 * and includes code for managing global variables and pointer
1142 * type checking.
1143 *
1144 * ----------------------------------------------------------------------------- */
1145
1146#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1147# error "This version of SWIG only supports Python >= 2.7"
1148#endif
1149
1150#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1151# error "This version of SWIG only supports Python 3 >= 3.3"
1152#endif
1153
1154/* Common SWIG API */
1155
1156/* for raw pointers */
1157#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1158#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1159#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1160
1161#ifdef SWIGPYTHON_BUILTIN
1162#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1163#else
1164#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1165#endif
1166
1167#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1168
1169#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1170#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1171#define swig_owntype int
1172
1173/* for raw packed data */
1174#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1175#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1176
1177/* for class or struct pointers */
1178#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1179#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1180
1181/* for C or C++ function pointers */
1182#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1183#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1184
1185/* for C++ member pointers, ie, member methods */
1186#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1187#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1188
1189
1190/* Runtime API */
1191
1192#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1193#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1194#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1195
1196#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1197#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1198#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1199#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1200#define SWIG_fail goto fail
1201
1202
1203/* Runtime API implementation */
1204
1205/* Error manipulation */
1206
1207SWIGINTERN void
1208SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1210 PyErr_SetObject(errtype, obj);
1211 SWIG_Py_DECREF(obj);
1213}
1214
1215SWIGINTERN void
1216SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1218 PyErr_SetString(errtype, msg);
1220}
1221
1222#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1223
1224/* Set a constant value */
1225
1226#if defined(SWIGPYTHON_BUILTIN)
1227
1228SWIGINTERN void
1229SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1230 PyObject *s = PyString_InternFromString(key);
1231 PyList_Append(seq, s);
1232 SWIG_Py_DECREF(s);
1233}
1234
1235SWIGINTERN void
1236SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1237 PyDict_SetItemString(d, name, obj);
1238 SWIG_Py_DECREF(obj);
1239 if (public_interface)
1240 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1241}
1242
1243#else
1244
1245SWIGINTERN void
1246SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1247 PyDict_SetItemString(d, name, obj);
1248 SWIG_Py_DECREF(obj);
1249}
1250
1251#endif
1252
1253/* Append a value to the result obj */
1254
1255SWIGINTERN PyObject*
1256SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
1257 if (!result) {
1258 result = obj;
1259 } else if (result == Py_None && is_void) {
1260 SWIG_Py_DECREF(result);
1261 result = obj;
1262 } else {
1263 if (!PyList_Check(result)) {
1264 PyObject *o2 = result;
1265 result = PyList_New(1);
1266 if (result) {
1267 PyList_SET_ITEM(result, 0, o2);
1268 } else {
1269 SWIG_Py_DECREF(obj);
1270 return o2;
1271 }
1272 }
1273 PyList_Append(result,obj);
1274 SWIG_Py_DECREF(obj);
1275 }
1276 return result;
1277}
1278
1279/* Unpack the argument tuple */
1280
1281SWIGINTERN Py_ssize_t
1282SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1283{
1284 if (!args) {
1285 if (!min && !max) {
1286 return 1;
1287 } else {
1288 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1289 name, (min == max ? "" : "at least "), (int)min);
1290 return 0;
1291 }
1292 }
1293 if (!PyTuple_Check(args)) {
1294 if (min <= 1 && max >= 1) {
1295 Py_ssize_t i;
1296 objs[0] = args;
1297 for (i = 1; i < max; ++i) {
1298 objs[i] = 0;
1299 }
1300 return 2;
1301 }
1302 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1303 return 0;
1304 } else {
1305 Py_ssize_t l = PyTuple_GET_SIZE(args);
1306 if (l < min) {
1307 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1308 name, (min == max ? "" : "at least "), (int)min, (int)l);
1309 return 0;
1310 } else if (l > max) {
1311 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1312 name, (min == max ? "" : "at most "), (int)max, (int)l);
1313 return 0;
1314 } else {
1315 Py_ssize_t i;
1316 for (i = 0; i < l; ++i) {
1317 objs[i] = PyTuple_GET_ITEM(args, i);
1318 }
1319 for (; l < max; ++l) {
1320 objs[l] = 0;
1321 }
1322 return i + 1;
1323 }
1324 }
1325}
1326
1327SWIGINTERN int
1328SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1329 int no_kwargs = 1;
1330 if (kwargs) {
1331 assert(PyDict_Check(kwargs));
1332 if (PyDict_Size(kwargs) > 0) {
1333 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1334 no_kwargs = 0;
1335 }
1336 }
1337 return no_kwargs;
1338}
1339
1340/* A functor is a function object with one single object argument */
1341#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1342
1343/*
1344 Helper for static pointer initialization for both C and C++ code, for example
1345 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1346*/
1347#ifdef __cplusplus
1348#define SWIG_STATIC_POINTER(var) var
1349#else
1350#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1351#endif
1352
1353#ifdef __cplusplus
1354extern "C" {
1355#endif
1356
1357/* Python-specific SWIG API */
1358#define SWIG_newvarlink() SWIG_Python_newvarlink()
1359#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1360#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1361
1362/* -----------------------------------------------------------------------------
1363 * global variable support code.
1364 * ----------------------------------------------------------------------------- */
1365
1366typedef struct swig_globalvar {
1367 char *name; /* Name of global variable */
1368 PyObject *(*get_attr)(void); /* Return the current value */
1369 int (*set_attr)(PyObject *); /* Set the value */
1372
1377
1378SWIGINTERN PyObject *
1380#if PY_VERSION_HEX >= 0x03000000
1381 return PyUnicode_InternFromString("<Swig global variables>");
1382#else
1383 return PyString_FromString("<Swig global variables>");
1384#endif
1385}
1386
1387SWIGINTERN PyObject *
1388swig_varlink_str(PyObject *o) {
1390#if PY_VERSION_HEX >= 0x03000000
1391 PyObject *str = PyUnicode_InternFromString("(");
1392 PyObject *tail;
1393 PyObject *joined;
1394 swig_globalvar *var;
1395 for (var = v->vars; var; var=var->next) {
1396 tail = PyUnicode_FromString(var->name);
1397 joined = PyUnicode_Concat(str, tail);
1398 SWIG_Py_DECREF(str);
1400 str = joined;
1401 if (var->next) {
1402 tail = PyUnicode_InternFromString(", ");
1403 joined = PyUnicode_Concat(str, tail);
1404 SWIG_Py_DECREF(str);
1406 str = joined;
1407 }
1408 }
1409 tail = PyUnicode_InternFromString(")");
1410 joined = PyUnicode_Concat(str, tail);
1411 SWIG_Py_DECREF(str);
1413 str = joined;
1414#else
1415 PyObject *str = PyString_FromString("(");
1416 swig_globalvar *var;
1417 for (var = v->vars; var; var=var->next) {
1418 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1419 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1420 }
1421 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1422#endif
1423 return str;
1424}
1425
1426SWIGINTERN void
1429 swig_globalvar *var = v->vars;
1430 while (var) {
1431 swig_globalvar *n = var->next;
1432 free(var->name);
1433 free(var);
1434 var = n;
1435 }
1436}
1437
1438SWIGINTERN PyObject *
1439swig_varlink_getattr(PyObject *o, char *n) {
1441 PyObject *res = NULL;
1442 swig_globalvar *var = v->vars;
1443 while (var) {
1444 if (strcmp(var->name,n) == 0) {
1445 res = (*var->get_attr)();
1446 break;
1447 }
1448 var = var->next;
1449 }
1450 if (res == NULL && !PyErr_Occurred()) {
1451 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1452 }
1453 return res;
1454}
1455
1456SWIGINTERN int
1457swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1459 int res = 1;
1460 swig_globalvar *var = v->vars;
1461 while (var) {
1462 if (strcmp(var->name,n) == 0) {
1463 res = (*var->set_attr)(p);
1464 break;
1465 }
1466 var = var->next;
1467 }
1468 if (res == 1 && !PyErr_Occurred()) {
1469 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1470 }
1471 return res;
1472}
1473
1474#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000
1475#define SWIG_HEAPTYPES
1476#endif
1477
1478SWIGINTERN PyTypeObject*
1480 static char varlink__doc__[] = "Swig var link object";
1481#ifndef SWIG_HEAPTYPES
1482 static PyTypeObject varlink_type;
1483 static int type_init = 0;
1484 if (!type_init) {
1485 const PyTypeObject tmp = {
1486#if PY_VERSION_HEX >= 0x03000000
1487 PyVarObject_HEAD_INIT(NULL, 0)
1488#else
1489 PyObject_HEAD_INIT(NULL)
1490 0, /* ob_size */
1491#endif
1492 "swigvarlink", /* tp_name */
1493 sizeof(swig_varlinkobject), /* tp_basicsize */
1494 0, /* tp_itemsize */
1495 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1496#if PY_VERSION_HEX < 0x030800b4
1497 (printfunc)0, /* tp_print */
1498#else
1499 (Py_ssize_t)0, /* tp_vectorcall_offset */
1500#endif
1501 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1502 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1503 0, /* tp_compare */
1504 (reprfunc) swig_varlink_repr, /* tp_repr */
1505 0, /* tp_as_number */
1506 0, /* tp_as_sequence */
1507 0, /* tp_as_mapping */
1508 0, /* tp_hash */
1509 0, /* tp_call */
1510 (reprfunc) swig_varlink_str, /* tp_str */
1511 0, /* tp_getattro */
1512 0, /* tp_setattro */
1513 0, /* tp_as_buffer */
1514 0, /* tp_flags */
1515 varlink__doc__, /* tp_doc */
1516 0, /* tp_traverse */
1517 0, /* tp_clear */
1518 0, /* tp_richcompare */
1519 0, /* tp_weaklistoffset */
1520 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1521 0, /* tp_del */
1522 0, /* tp_version_tag */
1523#if PY_VERSION_HEX >= 0x03040000
1524 0, /* tp_finalize */
1525#endif
1526#if PY_VERSION_HEX >= 0x03080000
1527 0, /* tp_vectorcall */
1528#endif
1529#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1530 0, /* tp_print */
1531#endif
1532#if PY_VERSION_HEX >= 0x030c0000
1533 0, /* tp_watched */
1534#endif
1535#if PY_VERSION_HEX >= 0x030d00a4
1536 0, /* tp_versions_used */
1537#endif
1538#ifdef COUNT_ALLOCS
1539 0, /* tp_allocs */
1540 0, /* tp_frees */
1541 0, /* tp_maxalloc */
1542 0, /* tp_prev */
1543 0 /* tp_next */
1544#endif
1545 };
1546 varlink_type = tmp;
1547 type_init = 1;
1548 if (PyType_Ready(&varlink_type) < 0)
1549 return NULL;
1550 }
1551 return &varlink_type;
1552#else
1553 PyType_Slot slots[] = {
1554 { Py_tp_dealloc, (void *)swig_varlink_dealloc },
1555 { Py_tp_repr, (void *)swig_varlink_repr },
1556 { Py_tp_getattr, (void *)swig_varlink_getattr },
1557 { Py_tp_setattr, (void *)swig_varlink_setattr },
1558 { Py_tp_str, (void *)swig_varlink_str },
1559 { Py_tp_doc, (void *)varlink__doc__ },
1560 { 0, NULL }
1561 };
1562 PyType_Spec spec = {
1563 "swigvarlink",
1564 sizeof(swig_varlinkobject),
1565 0,
1566 Py_TPFLAGS_DEFAULT,
1567 slots
1568 };
1569 return (PyTypeObject *)PyType_FromSpec(&spec);
1570#endif
1571}
1572
1573/* Create a variable linking object for use later */
1574SWIGINTERN PyObject *
1576 swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
1577 if (result) {
1578 result->vars = 0;
1579 }
1580 return ((PyObject*) result);
1581}
1582
1583SWIGINTERN void
1584SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1586 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1587 if (gv) {
1588 size_t size = strlen(name)+1;
1589 gv->name = (char *)malloc(size);
1590 if (gv->name) {
1591 memcpy(gv->name, name, size);
1592 gv->get_attr = get_attr;
1593 gv->set_attr = set_attr;
1594 gv->next = v->vars;
1595 }
1596 }
1597 v->vars = gv;
1598}
1599
1600
1601static PyObject *Swig_Globals_global = NULL;
1602
1603SWIGINTERN PyObject *
1605 if (Swig_Globals_global == NULL) {
1607 }
1608 return Swig_Globals_global;
1609}
1610
1611#ifdef __cplusplus
1612}
1613#endif
1614
1615/* -----------------------------------------------------------------------------
1616 * Pointer declarations
1617 * ----------------------------------------------------------------------------- */
1618
1619/* Flags for new pointer objects */
1620#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1621#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1622
1623#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1624
1625#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1626#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1627
1628#ifdef __cplusplus
1629extern "C" {
1630#endif
1631
1632/* The python void return value */
1633
1634SWIGRUNTIMEINLINE PyObject *
1636{
1637 PyObject *none = Py_None;
1638 SWIG_Py_INCREF(none);
1639 return none;
1640}
1641
1642/* SwigPyClientData */
1643
1644typedef struct {
1645 PyObject *klass;
1646 PyObject *newraw;
1647 PyObject *newargs;
1648 PyObject *destroy;
1651 PyTypeObject *pytype;
1653
1656{
1658 int fail = data ? data->implicitconv : 0;
1659 if (fail)
1660 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1661 return fail;
1662}
1663
1664SWIGRUNTIMEINLINE PyObject *
1666 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1667 PyObject *klass = data ? data->klass : 0;
1668 return (klass ? klass : PyExc_RuntimeError);
1669}
1670
1671
1674{
1675 if (!obj) {
1676 return 0;
1677 } else {
1678 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1679 /* the klass element */
1680 data->klass = obj;
1681 SWIG_Py_INCREF(data->klass);
1682 /* the newraw method and newargs arguments used to create a new raw instance */
1683 if (PyClass_Check(obj)) {
1684 data->newraw = 0;
1685 SWIG_Py_INCREF(obj);
1686 data->newargs = obj;
1687 } else {
1688 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1689 if (data->newraw) {
1690 data->newargs = PyTuple_New(1);
1691 if (data->newargs) {
1692 SWIG_Py_INCREF(obj);
1693 PyTuple_SET_ITEM(data->newargs, 0, obj);
1694 } else {
1695 SWIG_Py_DECREF(data->newraw);
1696 SWIG_Py_DECREF(data->klass);
1697 free(data);
1698 return 0;
1699 }
1700 } else {
1701 SWIG_Py_INCREF(obj);
1702 data->newargs = obj;
1703 }
1704 }
1705 /* the destroy method, aka as the C++ delete method */
1706 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1707 if (PyErr_Occurred()) {
1708 PyErr_Clear();
1709 data->destroy = 0;
1710 }
1711 if (data->destroy) {
1712 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1713 } else {
1714 data->delargs = 0;
1715 }
1716 data->implicitconv = 0;
1717 data->pytype = 0;
1718 return data;
1719 }
1720}
1721
1722SWIGRUNTIME void
1724{
1725 SWIG_Py_XDECREF(data->klass);
1726 SWIG_Py_XDECREF(data->newraw);
1727 SWIG_Py_XDECREF(data->newargs);
1728 SWIG_Py_XDECREF(data->destroy);
1729 free(data);
1730}
1731
1732/* =============== SwigPyObject =====================*/
1733
1734typedef struct {
1735 PyObject_HEAD
1736 void *ptr;
1738 int own;
1739 PyObject *next;
1740#ifdef SWIGPYTHON_BUILTIN
1741 PyObject *dict;
1742#endif
1743} SwigPyObject;
1744
1745
1746#ifdef SWIGPYTHON_BUILTIN
1747
1748SWIGRUNTIME PyObject *
1749SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1750{
1751 SwigPyObject *sobj = (SwigPyObject *)v;
1752
1753 if (!sobj->dict)
1754 sobj->dict = PyDict_New();
1755
1756 SWIG_Py_XINCREF(sobj->dict);
1757 return sobj->dict;
1758}
1759
1760#endif
1761
1762SWIGRUNTIME PyObject *
1764{
1765 return PyLong_FromVoidPtr(v->ptr);
1766}
1767
1768SWIGRUNTIME PyObject *
1770{
1771 PyObject *res = NULL;
1772 PyObject *args = PyTuple_New(1);
1773 if (args) {
1774 PyObject *val = SwigPyObject_long(v);
1775 if (val) {
1776 PyObject *ofmt;
1777 PyTuple_SET_ITEM(args, 0, val);
1778 ofmt = SWIG_Python_str_FromChar(fmt);
1779 if (ofmt) {
1780#if PY_VERSION_HEX >= 0x03000000
1781 res = PyUnicode_Format(ofmt,args);
1782#else
1783 res = PyString_Format(ofmt,args);
1784#endif
1785 SWIG_Py_DECREF(ofmt);
1786 }
1787 }
1788 SWIG_Py_DECREF(args);
1789 }
1790 return res;
1791}
1792
1793SWIGRUNTIME PyObject *
1795{
1796 return SwigPyObject_format("%o",v);
1797}
1798
1799SWIGRUNTIME PyObject *
1801{
1802 return SwigPyObject_format("%x",v);
1803}
1804
1805SWIGRUNTIME PyObject *
1807{
1808 const char *name = SWIG_TypePrettyName(v->ty);
1809 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1810 if (repr && v->next) {
1811 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1812 if (nrep) {
1813# if PY_VERSION_HEX >= 0x03000000
1814 PyObject *joined = PyUnicode_Concat(repr, nrep);
1815 SWIG_Py_DECREF(repr);
1816 SWIG_Py_DECREF(nrep);
1817 repr = joined;
1818# else
1819 PyString_ConcatAndDel(&repr,nrep);
1820# endif
1821 } else {
1822 SWIG_Py_DECREF(repr);
1823 repr = NULL;
1824 }
1825 }
1826 return repr;
1827}
1828
1829/* We need a version taking two PyObject* parameters so it's a valid
1830 * PyCFunction to use in swigobject_methods[]. */
1831SWIGRUNTIME PyObject *
1832SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1833{
1834 return SwigPyObject_repr((SwigPyObject*)v);
1835}
1836
1837SWIGRUNTIME int
1839{
1840 void *i = v->ptr;
1841 void *j = w->ptr;
1842 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1843}
1844
1845/* Added for Python 3.x, would it also be useful for Python 2.x? */
1846SWIGRUNTIME PyObject*
1848{
1849 PyObject* res = NULL;
1850 if (!PyErr_Occurred()) {
1851 if (op != Py_EQ && op != Py_NE) {
1852 SWIG_Py_INCREF(Py_NotImplemented);
1853 return Py_NotImplemented;
1854 }
1855 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1856 }
1857 return res;
1858}
1859
1860
1861SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1862
1863#ifdef SWIGPYTHON_BUILTIN
1864static swig_type_info *SwigPyObject_stype = 0;
1865SWIGRUNTIME PyTypeObject*
1866SwigPyObject_type(void) {
1867 SwigPyClientData *cd;
1868 assert(SwigPyObject_stype);
1869 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1870 assert(cd);
1871 assert(cd->pytype);
1872 return cd->pytype;
1873}
1874#else
1875SWIGRUNTIME PyTypeObject*
1877 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1878 return type;
1879}
1880#endif
1881
1883SwigPyObject_Check(PyObject *op) {
1884 PyTypeObject *target_tp = SwigPyObject_type();
1885 PyTypeObject *op_type = Py_TYPE(op);
1886#ifdef SWIGPYTHON_BUILTIN
1887 if (PyType_IsSubtype(op_type, target_tp))
1888 return 1;
1889 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1890#else
1891# ifdef Py_LIMITED_API
1892 int cmp;
1893 PyObject *tp_name;
1894#endif
1895 if (op_type == target_tp)
1896 return 1;
1897# ifdef Py_LIMITED_API
1898 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
1899 if (!tp_name)
1900 return 0;
1901 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
1902 SWIG_Py_DECREF(tp_name);
1903 return cmp == 0;
1904# else
1905 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1906# endif
1907#endif
1908}
1909
1910SWIGRUNTIME PyObject *
1911SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1912
1913static PyObject* Swig_Capsule_global = NULL;
1914
1915SWIGRUNTIME void
1917{
1918 SwigPyObject *sobj = (SwigPyObject *) v;
1919 PyObject *next = sobj->next;
1920 if (sobj->own == SWIG_POINTER_OWN) {
1921 swig_type_info *ty = sobj->ty;
1922 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1923 PyObject *destroy = data ? data->destroy : 0;
1924 if (destroy) {
1925 /* destroy is always a VARARGS method */
1926 PyObject *res;
1927
1928 /* PyObject_CallFunction() has the potential to silently drop
1929 the active exception. In cases of unnamed temporary
1930 variable or where we just finished iterating over a generator
1931 StopIteration will be active right now, and this needs to
1932 remain true upon return from SwigPyObject_dealloc. So save
1933 and restore. */
1934
1935 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1936 PyErr_Fetch(&type, &value, &traceback);
1937
1938 if (data->delargs) {
1939 /* we need to create a temporary object to carry the destroy operation */
1940 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1941 if (tmp) {
1942 res = SWIG_Python_CallFunctor(destroy, tmp);
1943 } else {
1944 res = 0;
1945 }
1946 SWIG_Py_XDECREF(tmp);
1947 } else {
1948 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1949 PyObject *mself = PyCFunction_GET_SELF(destroy);
1950 res = ((*meth)(mself, v));
1951 }
1952 if (!res)
1953 PyErr_WriteUnraisable(destroy);
1954
1955 PyErr_Restore(type, value, traceback);
1956
1957 SWIG_Py_XDECREF(res);
1958 }
1959#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1960 else {
1961 const char *name = SWIG_TypePrettyName(ty);
1962 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1963 }
1964#endif
1966 }
1967 SWIG_Py_XDECREF(next);
1968#ifdef SWIGPYTHON_BUILTIN
1969 SWIG_Py_XDECREF(sobj->dict);
1970#endif
1971 PyObject_Free(v);
1972}
1973
1974SWIGRUNTIME PyObject*
1975SwigPyObject_append(PyObject* v, PyObject* next)
1976{
1977 SwigPyObject *sobj = (SwigPyObject *) v;
1978 if (!SwigPyObject_Check(next)) {
1979 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1980 return NULL;
1981 }
1982 ((SwigPyObject *)next)->next = sobj->next;
1983 sobj->next = next;
1984 SWIG_Py_INCREF(next);
1985 return SWIG_Py_Void();
1986}
1987
1988SWIGRUNTIME PyObject*
1989SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1990{
1991 SwigPyObject *sobj = (SwigPyObject *) v;
1992 if (sobj->next) {
1993 SWIG_Py_INCREF(sobj->next);
1994 return sobj->next;
1995 } else {
1996 return SWIG_Py_Void();
1997 }
1998}
1999
2000SWIGINTERN PyObject*
2001SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2002{
2003 SwigPyObject *sobj = (SwigPyObject *)v;
2004 sobj->own = 0;
2005 return SWIG_Py_Void();
2006}
2007
2008SWIGINTERN PyObject*
2009SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2010{
2011 SwigPyObject *sobj = (SwigPyObject *)v;
2012 sobj->own = SWIG_POINTER_OWN;
2013 return SWIG_Py_Void();
2014}
2015
2016SWIGINTERN PyObject*
2017SwigPyObject_own(PyObject *v, PyObject *args)
2018{
2019 PyObject *val = 0;
2020 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
2021 return NULL;
2022 } else {
2023 SwigPyObject *sobj = (SwigPyObject *)v;
2024 PyObject *obj = PyBool_FromLong(sobj->own);
2025 if (val) {
2026 if (PyObject_IsTrue(val)) {
2028 } else {
2030 }
2031 }
2032 return obj;
2033 }
2034}
2035
2036static PyMethodDef
2038 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
2039 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
2040 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
2041 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
2042 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
2043 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
2044 {0, 0, 0, 0}
2045};
2046
2047SWIGRUNTIME PyTypeObject*
2049 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2050#ifndef SWIG_HEAPTYPES
2051 static PyNumberMethods SwigPyObject_as_number = {
2052 (binaryfunc)0, /*nb_add*/
2053 (binaryfunc)0, /*nb_subtract*/
2054 (binaryfunc)0, /*nb_multiply*/
2055 /* nb_divide removed in Python 3 */
2056#if PY_VERSION_HEX < 0x03000000
2057 (binaryfunc)0, /*nb_divide*/
2058#endif
2059 (binaryfunc)0, /*nb_remainder*/
2060 (binaryfunc)0, /*nb_divmod*/
2061 (ternaryfunc)0,/*nb_power*/
2062 (unaryfunc)0, /*nb_negative*/
2063 (unaryfunc)0, /*nb_positive*/
2064 (unaryfunc)0, /*nb_absolute*/
2065 (inquiry)0, /*nb_nonzero*/
2066 0, /*nb_invert*/
2067 0, /*nb_lshift*/
2068 0, /*nb_rshift*/
2069 0, /*nb_and*/
2070 0, /*nb_xor*/
2071 0, /*nb_or*/
2072#if PY_VERSION_HEX < 0x03000000
2073 0, /*nb_coerce*/
2074#endif
2075 (unaryfunc)SwigPyObject_long, /*nb_int*/
2076#if PY_VERSION_HEX < 0x03000000
2077 (unaryfunc)SwigPyObject_long, /*nb_long*/
2078#else
2079 0, /*nb_reserved*/
2080#endif
2081 (unaryfunc)0, /*nb_float*/
2082#if PY_VERSION_HEX < 0x03000000
2083 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
2084 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
2085#endif
2086#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
2087 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
2088#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
2089 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
2090#else
2091 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2092#endif
2093 };
2094
2095 static PyTypeObject swigpyobject_type;
2096 static int type_init = 0;
2097 if (!type_init) {
2098 const PyTypeObject tmp = {
2099#if PY_VERSION_HEX >= 0x03000000
2100 PyVarObject_HEAD_INIT(NULL, 0)
2101#else
2102 PyObject_HEAD_INIT(NULL)
2103 0, /* ob_size */
2104#endif
2105 "SwigPyObject", /* tp_name */
2106 sizeof(SwigPyObject), /* tp_basicsize */
2107 0, /* tp_itemsize */
2108 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
2109#if PY_VERSION_HEX < 0x030800b4
2110 (printfunc)0, /* tp_print */
2111#else
2112 (Py_ssize_t)0, /* tp_vectorcall_offset */
2113#endif
2114 (getattrfunc)0, /* tp_getattr */
2115 (setattrfunc)0, /* tp_setattr */
2116#if PY_VERSION_HEX >= 0x03000000
2117 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
2118#else
2119 (cmpfunc)SwigPyObject_compare, /* tp_compare */
2120#endif
2121 (reprfunc)SwigPyObject_repr, /* tp_repr */
2122 &SwigPyObject_as_number, /* tp_as_number */
2123 0, /* tp_as_sequence */
2124 0, /* tp_as_mapping */
2125 (hashfunc)0, /* tp_hash */
2126 (ternaryfunc)0, /* tp_call */
2127 0, /* tp_str */
2128 PyObject_GenericGetAttr, /* tp_getattro */
2129 0, /* tp_setattro */
2130 0, /* tp_as_buffer */
2131 Py_TPFLAGS_DEFAULT, /* tp_flags */
2132 swigobject_doc, /* tp_doc */
2133 0, /* tp_traverse */
2134 0, /* tp_clear */
2135 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2136 0, /* tp_weaklistoffset */
2137 0, /* tp_iter */
2138 0, /* tp_iternext */
2139 swigobject_methods, /* tp_methods */
2140 0, /* tp_members */
2141 0, /* tp_getset */
2142 0, /* tp_base */
2143 0, /* tp_dict */
2144 0, /* tp_descr_get */
2145 0, /* tp_descr_set */
2146 0, /* tp_dictoffset */
2147 0, /* tp_init */
2148 0, /* tp_alloc */
2149 0, /* tp_new */
2150 0, /* tp_free */
2151 0, /* tp_is_gc */
2152 0, /* tp_bases */
2153 0, /* tp_mro */
2154 0, /* tp_cache */
2155 0, /* tp_subclasses */
2156 0, /* tp_weaklist */
2157 0, /* tp_del */
2158 0, /* tp_version_tag */
2159#if PY_VERSION_HEX >= 0x03040000
2160 0, /* tp_finalize */
2161#endif
2162#if PY_VERSION_HEX >= 0x03080000
2163 0, /* tp_vectorcall */
2164#endif
2165#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2166 0, /* tp_print */
2167#endif
2168#if PY_VERSION_HEX >= 0x030c0000
2169 0, /* tp_watched */
2170#endif
2171#if PY_VERSION_HEX >= 0x030d00a4
2172 0, /* tp_versions_used */
2173#endif
2174#ifdef COUNT_ALLOCS
2175 0, /* tp_allocs */
2176 0, /* tp_frees */
2177 0, /* tp_maxalloc */
2178 0, /* tp_prev */
2179 0 /* tp_next */
2180#endif
2181 };
2182 swigpyobject_type = tmp;
2183 type_init = 1;
2184 if (PyType_Ready(&swigpyobject_type) != 0)
2185 return NULL;
2186 }
2187 return &swigpyobject_type;
2188#else
2189 PyType_Slot slots[] = {
2190 { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
2191 { Py_tp_repr, (void *)SwigPyObject_repr },
2192 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2193 { Py_tp_doc, (void *)swigobject_doc },
2194 { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
2195 { Py_tp_methods, (void *)swigobject_methods },
2196 { Py_nb_int, (void *)SwigPyObject_long },
2197 { 0, NULL }
2198 };
2199 PyType_Spec spec = {
2200 "SwigPyObject",
2201 sizeof(SwigPyObject),
2202 0,
2203 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
2204 slots
2205 };
2206 return (PyTypeObject *)PyType_FromSpec(&spec);
2207#endif
2208}
2209
2210SWIGRUNTIME PyObject *
2211SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2212{
2213 SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
2214 if (sobj) {
2215 sobj->ptr = ptr;
2216 sobj->ty = ty;
2217 sobj->own = own;
2218 sobj->next = 0;
2219#ifdef SWIGPYTHON_BUILTIN
2220 sobj->dict = 0;
2221#endif
2222 if (own == SWIG_POINTER_OWN) {
2223 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2224 * module information is correctly destroyed after all SWIG python objects have been freed
2225 * by the GC (and corresponding destructors invoked) */
2227 }
2228 }
2229 return (PyObject *)sobj;
2230}
2231
2232/* -----------------------------------------------------------------------------
2233 * Implements a simple Swig Packed type, and use it instead of string
2234 * ----------------------------------------------------------------------------- */
2235
2236typedef struct {
2237 PyObject_HEAD
2238 void *pack;
2240 size_t size;
2241} SwigPyPacked;
2242
2243SWIGRUNTIME PyObject *
2245{
2246 char result[SWIG_BUFFER_SIZE];
2247 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2248 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2249 } else {
2250 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2251 }
2252}
2253
2254SWIGRUNTIME PyObject *
2256{
2257 char result[SWIG_BUFFER_SIZE];
2258 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2259 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2260 } else {
2261 return SWIG_Python_str_FromChar(v->ty->name);
2262 }
2263}
2264
2265SWIGRUNTIME int
2267{
2268 size_t i = v->size;
2269 size_t j = w->size;
2270 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2271 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2272}
2273
2274SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2275
2276SWIGRUNTIME PyTypeObject*
2278 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2279 return type;
2280}
2281
2283SwigPyPacked_Check(PyObject *op) {
2284#ifdef Py_LIMITED_API
2285 int cmp;
2286 PyObject *tp_name;
2287#endif
2288 PyTypeObject* op_type = Py_TYPE(op);
2289 if (op_type == SwigPyPacked_TypeOnce())
2290 return 1;
2291#ifdef Py_LIMITED_API
2292 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
2293 if (!tp_name)
2294 return 0;
2295 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
2296 SWIG_Py_DECREF(tp_name);
2297 return cmp == 0;
2298#else
2299 return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
2300#endif
2301}
2302
2303SWIGRUNTIME void
2305{
2306 if (SwigPyPacked_Check(v)) {
2307 SwigPyPacked *sobj = (SwigPyPacked *) v;
2308 free(sobj->pack);
2309 }
2310 PyObject_Free(v);
2311}
2312
2313SWIGRUNTIME PyTypeObject*
2315 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2316#ifndef SWIG_HEAPTYPES
2317 static PyTypeObject swigpypacked_type;
2318 static int type_init = 0;
2319 if (!type_init) {
2320 const PyTypeObject tmp = {
2321#if PY_VERSION_HEX>=0x03000000
2322 PyVarObject_HEAD_INIT(NULL, 0)
2323#else
2324 PyObject_HEAD_INIT(NULL)
2325 0, /* ob_size */
2326#endif
2327 "SwigPyPacked", /* tp_name */
2328 sizeof(SwigPyPacked), /* tp_basicsize */
2329 0, /* tp_itemsize */
2330 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2331#if PY_VERSION_HEX < 0x030800b4
2332 (printfunc)0, /* tp_print */
2333#else
2334 (Py_ssize_t)0, /* tp_vectorcall_offset */
2335#endif
2336 (getattrfunc)0, /* tp_getattr */
2337 (setattrfunc)0, /* tp_setattr */
2338#if PY_VERSION_HEX>=0x03000000
2339 0, /* tp_reserved in 3.0.1 */
2340#else
2341 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2342#endif
2343 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2344 0, /* tp_as_number */
2345 0, /* tp_as_sequence */
2346 0, /* tp_as_mapping */
2347 (hashfunc)0, /* tp_hash */
2348 (ternaryfunc)0, /* tp_call */
2349 (reprfunc)SwigPyPacked_str, /* tp_str */
2350 PyObject_GenericGetAttr, /* tp_getattro */
2351 0, /* tp_setattro */
2352 0, /* tp_as_buffer */
2353 Py_TPFLAGS_DEFAULT, /* tp_flags */
2354 swigpacked_doc, /* tp_doc */
2355 0, /* tp_traverse */
2356 0, /* tp_clear */
2357 0, /* tp_richcompare */
2358 0, /* tp_weaklistoffset */
2359 0, /* tp_iter */
2360 0, /* tp_iternext */
2361 0, /* tp_methods */
2362 0, /* tp_members */
2363 0, /* tp_getset */
2364 0, /* tp_base */
2365 0, /* tp_dict */
2366 0, /* tp_descr_get */
2367 0, /* tp_descr_set */
2368 0, /* tp_dictoffset */
2369 0, /* tp_init */
2370 0, /* tp_alloc */
2371 0, /* tp_new */
2372 0, /* tp_free */
2373 0, /* tp_is_gc */
2374 0, /* tp_bases */
2375 0, /* tp_mro */
2376 0, /* tp_cache */
2377 0, /* tp_subclasses */
2378 0, /* tp_weaklist */
2379 0, /* tp_del */
2380 0, /* tp_version_tag */
2381#if PY_VERSION_HEX >= 0x03040000
2382 0, /* tp_finalize */
2383#endif
2384#if PY_VERSION_HEX >= 0x03080000
2385 0, /* tp_vectorcall */
2386#endif
2387#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2388 0, /* tp_print */
2389#endif
2390#if PY_VERSION_HEX >= 0x030c0000
2391 0, /* tp_watched */
2392#endif
2393#if PY_VERSION_HEX >= 0x030d00a4
2394 0, /* tp_versions_used */
2395#endif
2396#ifdef COUNT_ALLOCS
2397 0, /* tp_allocs */
2398 0, /* tp_frees */
2399 0, /* tp_maxalloc */
2400 0, /* tp_prev */
2401 0 /* tp_next */
2402#endif
2403 };
2404 swigpypacked_type = tmp;
2405 type_init = 1;
2406 if (PyType_Ready(&swigpypacked_type) != 0)
2407 return NULL;
2408 }
2409 return &swigpypacked_type;
2410#else
2411 PyType_Slot slots[] = {
2412 { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
2413 { Py_tp_repr, (void *)SwigPyPacked_repr },
2414 { Py_tp_str, (void *)SwigPyPacked_str },
2415 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2416 { Py_tp_doc, (void *)swigpacked_doc },
2417 { 0, NULL }
2418 };
2419 PyType_Spec spec = {
2420 "SwigPyPacked",
2421 sizeof(SwigPyPacked),
2422 0,
2423 Py_TPFLAGS_DEFAULT,
2424 slots
2425 };
2426 return (PyTypeObject *)PyType_FromSpec(&spec);
2427#endif
2428}
2429
2430SWIGRUNTIME PyObject *
2431SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2432{
2433 SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
2434 if (sobj) {
2435 void *pack = malloc(size);
2436 if (pack) {
2437 memcpy(pack, ptr, size);
2438 sobj->pack = pack;
2439 sobj->ty = ty;
2440 sobj->size = size;
2441 } else {
2442 PyObject_Free((PyObject *)sobj);
2443 sobj = 0;
2444 }
2445 }
2446 return (PyObject *) sobj;
2447}
2448
2450SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2451{
2452 if (SwigPyPacked_Check(obj)) {
2453 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2454 if (sobj->size != size) return 0;
2455 memcpy(ptr, sobj->pack, size);
2456 return sobj->ty;
2457 } else {
2458 return 0;
2459 }
2460}
2461
2462/* -----------------------------------------------------------------------------
2463 * pointers/data manipulation
2464 * ----------------------------------------------------------------------------- */
2465
2466static PyObject *Swig_This_global = NULL;
2467
2468SWIGRUNTIME PyObject *
2470{
2471 if (Swig_This_global == NULL)
2473 return Swig_This_global;
2474}
2475
2476/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2477
2478/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2479#if PY_VERSION_HEX>=0x03000000
2480#define SWIG_PYTHON_SLOW_GETSET_THIS
2481#endif
2482
2485{
2486 PyObject *obj;
2487
2488 if (SwigPyObject_Check(pyobj))
2489 return (SwigPyObject *) pyobj;
2490
2491#ifdef SWIGPYTHON_BUILTIN
2492 (void)obj;
2493# ifdef PyWeakref_CheckProxy
2494 if (PyWeakref_CheckProxy(pyobj)) {
2495#if PY_VERSION_HEX >= 0x030d0000
2496 PyWeakref_GetRef(pyobj, &pyobj);
2497 Py_DECREF(pyobj);
2498#else
2499 pyobj = PyWeakref_GET_OBJECT(pyobj);
2500#endif
2501 if (pyobj && SwigPyObject_Check(pyobj))
2502 return (SwigPyObject*) pyobj;
2503 }
2504# endif
2505 return NULL;
2506#else
2507
2508 obj = 0;
2509
2510#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2511 if (PyInstance_Check(pyobj)) {
2512 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2513 } else {
2514 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2515 if (dictptr != NULL) {
2516 PyObject *dict = *dictptr;
2517 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2518 } else {
2519#ifdef PyWeakref_CheckProxy
2520 if (PyWeakref_CheckProxy(pyobj)) {
2521 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2522 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2523 }
2524#endif
2525 obj = PyObject_GetAttr(pyobj,SWIG_This());
2526 if (obj) {
2527 SWIG_Py_DECREF(obj);
2528 } else {
2529 if (PyErr_Occurred()) PyErr_Clear();
2530 return 0;
2531 }
2532 }
2533 }
2534#else
2535 obj = PyObject_GetAttr(pyobj,SWIG_This());
2536 if (obj) {
2537 SWIG_Py_DECREF(obj);
2538 } else {
2539 if (PyErr_Occurred()) PyErr_Clear();
2540 return 0;
2541 }
2542#endif
2543 if (obj && !SwigPyObject_Check(obj)) {
2544 /* a PyObject is called 'this', try to get the 'real this'
2545 SwigPyObject from it */
2546 return SWIG_Python_GetSwigThis(obj);
2547 }
2548 return (SwigPyObject *)obj;
2549#endif
2550}
2551
2552/* Acquire a pointer value */
2553
2554SWIGRUNTIME int
2555SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2556 if (own == SWIG_POINTER_OWN) {
2558 if (sobj) {
2559 int oldown = sobj->own;
2560 sobj->own = own;
2561 return oldown;
2562 }
2563 }
2564 return 0;
2565}
2566
2567/* Convert a pointer value */
2568
2569SWIGRUNTIME int
2570SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2571 int res;
2572 SwigPyObject *sobj;
2573 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2574
2575 if (!obj)
2576 return SWIG_ERROR;
2577 if (obj == Py_None && !implicit_conv) {
2578 if (ptr)
2579 *ptr = 0;
2581 }
2582
2583 res = SWIG_ERROR;
2584
2585 sobj = SWIG_Python_GetSwigThis(obj);
2586 if (own)
2587 *own = 0;
2588 while (sobj) {
2589 void *vptr = sobj->ptr;
2590 if (ty) {
2591 swig_type_info *to = sobj->ty;
2592 if (to == ty) {
2593 /* no type cast needed */
2594 if (ptr) *ptr = vptr;
2595 break;
2596 } else {
2597 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2598 if (!tc) {
2599 sobj = (SwigPyObject *)sobj->next;
2600 } else {
2601 if (ptr) {
2602 int newmemory = 0;
2603 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2604 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2605 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2606 if (own)
2607 *own = *own | SWIG_CAST_NEW_MEMORY;
2608 }
2609 }
2610 break;
2611 }
2612 }
2613 } else {
2614 if (ptr) *ptr = vptr;
2615 break;
2616 }
2617 }
2618 if (sobj) {
2619 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2621 } else {
2622 if (own)
2623 *own = *own | sobj->own;
2624 if (flags & SWIG_POINTER_DISOWN) {
2625 sobj->own = 0;
2626 }
2627 if (flags & SWIG_POINTER_CLEAR) {
2628 sobj->ptr = 0;
2629 }
2630 res = SWIG_OK;
2631 }
2632 } else {
2633 if (implicit_conv) {
2634 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2635 if (data && !data->implicitconv) {
2636 PyObject *klass = data->klass;
2637 if (klass) {
2638 PyObject *impconv;
2639 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2640 impconv = SWIG_Python_CallFunctor(klass, obj);
2641 data->implicitconv = 0;
2642 if (PyErr_Occurred()) {
2643 PyErr_Clear();
2644 impconv = 0;
2645 }
2646 if (impconv) {
2647 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2648 if (iobj) {
2649 void *vptr;
2650 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2651 if (SWIG_IsOK(res)) {
2652 if (ptr) {
2653 *ptr = vptr;
2654 /* transfer the ownership to 'ptr' */
2655 iobj->own = 0;
2656 res = SWIG_AddCast(res);
2657 res = SWIG_AddNewMask(res);
2658 } else {
2659 res = SWIG_AddCast(res);
2660 }
2661 }
2662 }
2663 SWIG_Py_DECREF(impconv);
2664 }
2665 }
2666 }
2667 if (!SWIG_IsOK(res) && obj == Py_None) {
2668 if (ptr)
2669 *ptr = 0;
2670 if (PyErr_Occurred())
2671 PyErr_Clear();
2672 res = SWIG_OK;
2673 }
2674 }
2675 }
2676 return res;
2677}
2678
2679/* Convert a function ptr value */
2680
2681SWIGRUNTIME int
2682SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2683 if (!PyCFunction_Check(obj)) {
2684 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2685 } else {
2686 void *vptr = 0;
2687 swig_cast_info *tc;
2688
2689 /* here we get the method pointer for callbacks */
2690#ifndef Py_LIMITED_API
2691 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2692#else
2693 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2694 PyObject *bytes = NULL;
2695 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2696#endif
2697 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2698 if (desc)
2699 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2700#ifdef Py_LIMITED_API
2701 SWIG_Py_XDECREF(bytes);
2702 SWIG_Py_XDECREF(pystr_doc);
2703#endif
2704 if (!desc)
2705 return SWIG_ERROR;
2706 tc = SWIG_TypeCheck(desc,ty);
2707 if (tc) {
2708 int newmemory = 0;
2709 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2710 assert(!newmemory); /* newmemory handling not yet implemented */
2711 } else {
2712 return SWIG_ERROR;
2713 }
2714 return SWIG_OK;
2715 }
2716}
2717
2718/* Convert a packed pointer value */
2719
2720SWIGRUNTIME int
2721SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2722 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2723 if (!to) return SWIG_ERROR;
2724 if (ty) {
2725 if (to != ty) {
2726 /* check type cast? */
2727 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2728 if (!tc) return SWIG_ERROR;
2729 }
2730 }
2731 return SWIG_OK;
2732}
2733
2734/* -----------------------------------------------------------------------------
2735 * Create a new pointer object
2736 * ----------------------------------------------------------------------------- */
2737
2738/*
2739 Create a new instance object, without calling __init__, and set the
2740 'this' attribute.
2741*/
2742
2743SWIGRUNTIME PyObject*
2745{
2746 PyObject *inst = 0;
2747 PyObject *newraw = data->newraw;
2748 if (newraw) {
2749 inst = PyObject_Call(newraw, data->newargs, NULL);
2750 if (inst) {
2751#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2752 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2753 if (dictptr != NULL) {
2754 PyObject *dict = *dictptr;
2755 if (dict == NULL) {
2756 dict = PyDict_New();
2757 *dictptr = dict;
2758 }
2759 if (dict) {
2760 PyDict_SetItem(dict, SWIG_This(), swig_this);
2761 } else{
2762 SWIG_Py_DECREF(inst);
2763 inst = 0;
2764 }
2765 }
2766#else
2767 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2768 SWIG_Py_DECREF(inst);
2769 inst = 0;
2770 }
2771#endif
2772 }
2773 } else {
2774#if PY_VERSION_HEX >= 0x03000000
2775 PyObject *empty_args = PyTuple_New(0);
2776 if (empty_args) {
2777 PyObject *empty_kwargs = PyDict_New();
2778 if (empty_kwargs) {
2779#ifndef Py_LIMITED_API
2780 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2781#else
2782 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2783#endif
2784 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2785 SWIG_Py_DECREF(empty_kwargs);
2786 if (inst) {
2787 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2788 SWIG_Py_DECREF(inst);
2789 inst = 0;
2790 } else {
2791 PyType_Modified(Py_TYPE(inst));
2792 }
2793 }
2794 }
2795 SWIG_Py_DECREF(empty_args);
2796 }
2797#else
2798 PyObject *dict = PyDict_New();
2799 if (dict) {
2800 PyDict_SetItem(dict, SWIG_This(), swig_this);
2801 inst = PyInstance_NewRaw(data->newargs, dict);
2802 SWIG_Py_DECREF(dict);
2803 }
2804#endif
2805 }
2806 return inst;
2807}
2808
2809SWIGRUNTIME int
2810SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2811{
2812#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2813 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2814 if (dictptr != NULL) {
2815 PyObject *dict = *dictptr;
2816 if (dict == NULL) {
2817 dict = PyDict_New();
2818 *dictptr = dict;
2819 }
2820 if (dict) {
2821 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2822 } else{
2823 return -1;
2824 }
2825 }
2826#endif
2827 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2828}
2829
2830
2831SWIGINTERN PyObject *
2833 PyObject *obj[2];
2834 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2835 return NULL;
2836 } else {
2837 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2838 if (sthis) {
2839 SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2840 } else {
2841 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2842 return NULL;
2843 }
2844 return SWIG_Py_Void();
2845 }
2846}
2847
2848/* Create a new pointer object */
2849
2850SWIGRUNTIME PyObject *
2851SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2852 SwigPyClientData *clientdata;
2853 PyObject * robj;
2854 int own;
2855
2856 if (!ptr)
2857 return SWIG_Py_Void();
2858
2859 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2860 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2861 if (clientdata && clientdata->pytype) {
2862 SwigPyObject *newobj;
2863 if (flags & SWIG_BUILTIN_TP_INIT) {
2864 newobj = (SwigPyObject*) self;
2865 if (newobj->ptr) {
2866#ifndef Py_LIMITED_API
2867 allocfunc alloc = clientdata->pytype->tp_alloc;
2868#else
2869 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2870#endif
2871 PyObject *next_self = alloc(clientdata->pytype, 0);
2872 while (newobj->next)
2873 newobj = (SwigPyObject *) newobj->next;
2874 newobj->next = next_self;
2875 newobj = (SwigPyObject *)next_self;
2876#ifdef SWIGPYTHON_BUILTIN
2877 newobj->dict = 0;
2878#endif
2879 }
2880 } else {
2881 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2882#ifdef SWIGPYTHON_BUILTIN
2883 if (newobj) {
2884 newobj->dict = 0;
2885 }
2886#endif
2887 }
2888 if (newobj) {
2889 newobj->ptr = ptr;
2890 newobj->ty = type;
2891 newobj->own = own;
2892 newobj->next = 0;
2893 return (PyObject*) newobj;
2894 }
2895 return SWIG_Py_Void();
2896 }
2897
2898 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2899
2900 robj = SwigPyObject_New(ptr, type, own);
2901 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2902 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2903 SWIG_Py_DECREF(robj);
2904 robj = inst;
2905 }
2906 return robj;
2907}
2908
2909/* Create a new packed object */
2910
2911SWIGRUNTIMEINLINE PyObject *
2912SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2913 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2914}
2915
2916/* -----------------------------------------------------------------------------*
2917 * Get type list
2918 * -----------------------------------------------------------------------------*/
2919
2920#ifdef SWIG_LINK_RUNTIME
2921void *SWIG_ReturnGlobalTypeList(void *);
2922#endif
2923
2924static PyObject *Swig_TypeCache_global = NULL;
2925
2926/* The python cached type query */
2927SWIGRUNTIME PyObject *
2929 if (Swig_TypeCache_global == NULL) {
2930 Swig_TypeCache_global = PyDict_New();
2931 }
2932 return Swig_TypeCache_global;
2933}
2934
2937#ifdef SWIG_LINK_RUNTIME
2938 static void *type_pointer = (void *)0;
2939 /* first check if module already created */
2940 if (!type_pointer) {
2941 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2942 }
2943#else
2944 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2945 if (PyErr_Occurred()) {
2946 PyErr_Clear();
2947 type_pointer = (void *)0;
2948 }
2949#endif
2950 return (swig_module_info *) type_pointer;
2951}
2952
2953
2954static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2955
2956SWIGRUNTIME void
2958{
2959 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2960 swig_type_info **types = swig_module->types;
2961 size_t i;
2962 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2963 return;
2964 for (i =0; i < swig_module->size; ++i) {
2965 swig_type_info *ty = types[i];
2966 if (ty->owndata) {
2968 ty->clientdata = 0;
2969 if (data) SwigPyClientData_Del(data);
2970 }
2971 }
2973 Swig_This_global = NULL;
2975 Swig_Globals_global = NULL;
2977 Swig_TypeCache_global = NULL;
2978 Swig_Capsule_global = NULL;
2979}
2980
2981SWIGRUNTIME void
2983#if PY_VERSION_HEX >= 0x03000000
2984 /* Add a dummy module object into sys.modules */
2985 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2986#else
2987 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2988 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2989#endif
2990 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2991 if (pointer && module) {
2992 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2994 Swig_Capsule_global = pointer;
2995 } else {
2996 SWIG_Py_DECREF(pointer);
2997 }
2998 } else {
2999 SWIG_Py_XDECREF(pointer);
3000 }
3001}
3002
3004SWIG_Python_TypeQuery(const char *type)
3005{
3006 PyObject *cache = SWIG_Python_TypeCache();
3007 PyObject *key = SWIG_Python_str_FromChar(type);
3008 PyObject *obj = PyDict_GetItem(cache, key);
3009 swig_type_info *descriptor;
3010 if (obj) {
3011 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
3012 } else {
3014 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
3015 if (descriptor) {
3016 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
3017 if (obj) {
3018 PyDict_SetItem(cache, key, obj);
3019 SWIG_Py_DECREF(obj);
3020 }
3021 }
3022 }
3023 SWIG_Py_DECREF(key);
3024 return descriptor;
3025}
3026
3027/*
3028 For backward compatibility only
3029*/
3030#define SWIG_POINTER_EXCEPTION 0
3031#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
3032#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
3033
3034SWIGRUNTIME int
3035SWIG_Python_AddErrMesg(const char* mesg, int infront)
3036{
3037 if (PyErr_Occurred()) {
3038 PyObject *type = 0;
3039 PyObject *value = 0;
3040 PyObject *traceback = 0;
3041 PyErr_Fetch(&type, &value, &traceback);
3042 if (value) {
3043 PyObject *old_str = PyObject_Str(value);
3044 PyObject *bytes = NULL;
3045 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
3046 const char *errmesg = tmp ? tmp : "Invalid error message";
3047 SWIG_Py_XINCREF(type);
3048 PyErr_Clear();
3049 if (infront) {
3050 PyErr_Format(type, "%s %s", mesg, errmesg);
3051 } else {
3052 PyErr_Format(type, "%s %s", errmesg, mesg);
3053 }
3054 SWIG_Py_XDECREF(bytes);
3055 SWIG_Py_DECREF(old_str);
3056 }
3057 return 1;
3058 } else {
3059 return 0;
3060 }
3061}
3062
3063SWIGRUNTIME int
3065{
3066 if (PyErr_Occurred()) {
3067 /* add information about failing argument */
3068 char mesg[256];
3069 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3070 return SWIG_Python_AddErrMesg(mesg, 1);
3071 } else {
3072 return 0;
3073 }
3074}
3075
3076SWIGRUNTIMEINLINE const char *
3078{
3079 SwigPyObject *v = (SwigPyObject *)self;
3080 swig_type_info *ty = v ? v->ty : 0;
3081 return ty ? ty->str : "";
3082}
3083
3084SWIGRUNTIME void
3085SWIG_Python_TypeError(const char *type, PyObject *obj)
3086{
3087 (void) obj;
3088 if (type) {
3089#if defined(SWIG_COBJECT_TYPES)
3090 if (obj && SwigPyObject_Check(obj)) {
3091 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3092 if (otype) {
3093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3094 type, otype);
3095 return;
3096 }
3097 } else
3098#endif
3099 {
3100#ifndef Py_LIMITED_API
3101 /* tp_name is not accessible */
3102 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3103 if (otype) {
3104 PyObject *str = PyObject_Str(obj);
3105 PyObject *bytes = NULL;
3106 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3107 if (cstr) {
3108 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3109 type, otype, cstr);
3110 } else {
3111 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3112 type, otype);
3113 }
3114 SWIG_Py_XDECREF(bytes);
3115 SWIG_Py_XDECREF(str);
3116 return;
3117 }
3118#endif
3119 }
3120 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3121 } else {
3122 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3123 }
3124}
3125
3126
3127/* Convert a pointer value, signal an exception on a type mismatch */
3128SWIGRUNTIME void *
3129SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3130 void *result;
3131 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3132 PyErr_Clear();
3133 }
3134 return result;
3135}
3136
3137#ifdef SWIGPYTHON_BUILTIN
3138SWIGRUNTIME int
3139SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3140 PyTypeObject *tp = obj->ob_type;
3141 PyObject *descr;
3142 PyObject *encoded_name;
3143 descrsetfunc f;
3144 int res = -1;
3145
3146# ifdef Py_USING_UNICODE
3147 if (PyString_Check(name)) {
3148 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3149 if (!name)
3150 return -1;
3151 } else if (!PyUnicode_Check(name))
3152# else
3153 if (!PyString_Check(name))
3154# endif
3155 {
3156 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3157 return -1;
3158 } else {
3160 }
3161
3162 if (!tp->tp_dict) {
3163 if (PyType_Ready(tp) != 0)
3164 goto done;
3165 }
3166
3167 descr = _PyType_Lookup(tp, name);
3168 f = NULL;
3169 if (descr != NULL)
3170 f = descr->ob_type->tp_descr_set;
3171 if (!f) {
3172 if (PyString_Check(name)) {
3173 encoded_name = name;
3175 } else {
3176 encoded_name = PyUnicode_AsUTF8String(name);
3177 if (!encoded_name)
3178 goto done;
3179 }
3180 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3181 SWIG_Py_DECREF(encoded_name);
3182 } else {
3183 res = f(descr, obj, value);
3184 }
3185
3186 done:
3188 return res;
3189}
3190#endif
3191
3192
3193#ifdef __cplusplus
3194}
3195#endif
3196
3197
3198
3199#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3200
3201#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3202
3203
3204
3205/* -------- TYPES TABLE (BEGIN) -------- */
3206
3207#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3208#define SWIGTYPE_p_PLcGrid swig_types[1]
3209#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3210#define SWIGTYPE_p_char swig_types[3]
3211#define SWIGTYPE_p_double swig_types[4]
3212#define SWIGTYPE_p_f_double_double__int swig_types[5]
3213#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3214#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3215#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3216#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3217#define SWIGTYPE_p_int swig_types[10]
3218#define SWIGTYPE_p_p_char swig_types[11]
3219#define SWIGTYPE_p_p_double swig_types[12]
3220#define SWIGTYPE_p_unsigned_int swig_types[13]
3222static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3223#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3224#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3225
3226/* -------- TYPES TABLE (END) -------- */
3227
3228#ifdef SWIG_TypeQuery
3229# undef SWIG_TypeQuery
3230#endif
3231#define SWIG_TypeQuery SWIG_Python_TypeQuery
3232
3233/*-----------------------------------------------
3234 @(target):= _plplotc.so
3235 ------------------------------------------------*/
3236#if PY_VERSION_HEX >= 0x03000000
3237# define SWIG_init PyInit__plplotc
3238
3239#else
3240# define SWIG_init init_plplotc
3241
3242#endif
3243
3244#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3245#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3246
3247
3248#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3249#include <arrayobject.h>
3250#include "plplot.h"
3251#include "plplotP.h"
3252
3253#define NPY_PLINT NPY_INT32
3254
3255#ifdef PL_DOUBLE
3256#define NPY_PLFLT NPY_FLOAT64
3257#else
3258#define NPY_PLFLT NPY_FLOAT32
3259#endif
3260
3261// python-1.5 compatibility mode?
3262#if !defined ( PySequence_Fast_GET_ITEM )
3263 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3264#endif
3265#define PySequence_Size PySequence_Length
3266
3267
3268 static PLINT Alen = 0;
3269 static PLINT Xlen = 0, Ylen = 0;
3270
3271
3272SWIGINTERN int
3273SWIG_AsVal_double (PyObject *obj, double *val)
3274{
3275 int res = SWIG_TypeError;
3276 if (PyFloat_Check(obj)) {
3277 if (val) *val = PyFloat_AsDouble(obj);
3278 return SWIG_OK;
3279#if PY_VERSION_HEX < 0x03000000
3280 } else if (PyInt_Check(obj)) {
3281 if (val) *val = (double) PyInt_AsLong(obj);
3282 return SWIG_OK;
3283#endif
3284 } else if (PyLong_Check(obj)) {
3285 double v = PyLong_AsDouble(obj);
3286 if (!PyErr_Occurred()) {
3287 if (val) *val = v;
3288 return SWIG_OK;
3289 } else {
3290 PyErr_Clear();
3291 }
3292 }
3293#ifdef SWIG_PYTHON_CAST_MODE
3294 {
3295 int dispatch = 0;
3296 double d = PyFloat_AsDouble(obj);
3297 if (!PyErr_Occurred()) {
3298 if (val) *val = d;
3299 return SWIG_AddCast(SWIG_OK);
3300 } else {
3301 PyErr_Clear();
3302 }
3303 if (!dispatch) {
3304 long v = PyLong_AsLong(obj);
3305 if (!PyErr_Occurred()) {
3306 if (val) *val = v;
3308 } else {
3309 PyErr_Clear();
3310 }
3311 }
3312 }
3313#endif
3314 return res;
3315}
3316
3317
3318 #define SWIG_From_double PyFloat_FromDouble
3319
3320
3321 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3322 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3323 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3324 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3325 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3327 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3328
3329
3330SWIGINTERNINLINE PyObject*
3332{
3333 return PyInt_FromLong((long) value);
3334}
3335
3336
3337#include <limits.h>
3338#if !defined(SWIG_NO_LLONG_MAX)
3339# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3340# define LLONG_MAX __LONG_LONG_MAX__
3341# define LLONG_MIN (-LLONG_MAX - 1LL)
3342# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3343# endif
3344#endif
3345
3346
3347#include <float.h>
3348
3349
3350#include <math.h>
3351
3352
3354SWIG_CanCastAsInteger(double *d, double min, double max) {
3355 double x = *d;
3356 if ((min <= x && x <= max)) {
3357 double fx, cx, rd;
3358 errno = 0;
3359 fx = floor(x);
3360 cx = ceil(x);
3361 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3362 if ((errno == EDOM) || (errno == ERANGE)) {
3363 errno = 0;
3364 } else {
3365 double summ, reps, diff;
3366 if (rd < x) {
3367 diff = x - rd;
3368 } else if (rd > x) {
3369 diff = rd - x;
3370 } else {
3371 return 1;
3372 }
3373 summ = rd + x;
3374 reps = diff/summ;
3375 if (reps < 8*DBL_EPSILON) {
3376 *d = rd;
3377 return 1;
3378 }
3379 }
3380 }
3381 return 0;
3382}
3383
3384
3385SWIGINTERN int
3386SWIG_AsVal_long (PyObject *obj, long* val)
3387{
3388#if PY_VERSION_HEX < 0x03000000
3389 if (PyInt_Check(obj)) {
3390 if (val) *val = PyInt_AsLong(obj);
3391 return SWIG_OK;
3392 } else
3393#endif
3394 if (PyLong_Check(obj)) {
3395 long v = PyLong_AsLong(obj);
3396 if (!PyErr_Occurred()) {
3397 if (val) *val = v;
3398 return SWIG_OK;
3399 } else {
3400 PyErr_Clear();
3401 return SWIG_OverflowError;
3402 }
3403 }
3404#ifdef SWIG_PYTHON_CAST_MODE
3405 {
3406 int dispatch = 0;
3407 long v = PyInt_AsLong(obj);
3408 if (!PyErr_Occurred()) {
3409 if (val) *val = v;
3410 return SWIG_AddCast(SWIG_OK);
3411 } else {
3412 PyErr_Clear();
3413 }
3414 if (!dispatch) {
3415 double d;
3416 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3417 // Largest double not larger than LONG_MAX (not portably calculated easily)
3418 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3419 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3420 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3421 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3422 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3423 if (val) *val = (long)(d);
3424 return res;
3425 }
3426 }
3427 }
3428#endif
3429 return SWIG_TypeError;
3430}
3431
3432
3433SWIGINTERN int
3434SWIG_AsVal_int (PyObject * obj, int *val)
3435{
3436 long v;
3437 int res = SWIG_AsVal_long (obj, &v);
3438 if (SWIG_IsOK(res)) {
3439 if ((v < INT_MIN || v > INT_MAX)) {
3440 return SWIG_OverflowError;
3441 } else {
3442 if (val) *val = (int)(v);
3443 }
3444 }
3445 return res;
3446}
3447
3448
3449SWIGINTERN int
3450SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3451{
3452#if PY_VERSION_HEX < 0x03000000
3453 if (PyInt_Check(obj)) {
3454 long v = PyInt_AsLong(obj);
3455 if (v >= 0) {
3456 if (val) *val = v;
3457 return SWIG_OK;
3458 } else {
3459 return SWIG_OverflowError;
3460 }
3461 } else
3462#endif
3463 if (PyLong_Check(obj)) {
3464 unsigned long v = PyLong_AsUnsignedLong(obj);
3465 if (!PyErr_Occurred()) {
3466 if (val) *val = v;
3467 return SWIG_OK;
3468 } else {
3469 PyErr_Clear();
3470 return SWIG_OverflowError;
3471 }
3472 }
3473#ifdef SWIG_PYTHON_CAST_MODE
3474 {
3475 int dispatch = 0;
3476 unsigned long v = PyLong_AsUnsignedLong(obj);
3477 if (!PyErr_Occurred()) {
3478 if (val) *val = v;
3479 return SWIG_AddCast(SWIG_OK);
3480 } else {
3481 PyErr_Clear();
3482 }
3483 if (!dispatch) {
3484 double d;
3485 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3486 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3487 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3488 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3489 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3490 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3491 if (val) *val = (unsigned long)(d);
3492 return res;
3493 }
3494 }
3495 }
3496#endif
3497 return SWIG_TypeError;
3498}
3499
3500
3501SWIGINTERN int
3502SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3503{
3504 unsigned long v;
3505 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3506 if (SWIG_IsOK(res)) {
3507 if ((v > UINT_MAX)) {
3508 return SWIG_OverflowError;
3509 } else {
3510 if (val) *val = (unsigned int)(v);
3511 }
3512 }
3513 return res;
3514}
3515
3516
3517SWIGINTERNINLINE PyObject*
3519{
3520 return PyInt_FromSize_t((size_t) value);
3521}
3522
3523
3526{
3527 static swig_type_info* info = 0;
3528 if (!info) {
3529 info = SWIG_TypeQuery("_p_char");
3530 }
3531 return info;
3532}
3533
3534
3535/* Return string from Python obj. NOTE: obj must remain in scope in order
3536 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3537SWIGINTERN int
3538SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3539{
3540#if PY_VERSION_HEX>=0x03000000
3541#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3542 if (PyBytes_Check(obj))
3543#else
3544 if (PyUnicode_Check(obj))
3545#endif
3546#else
3547 if (PyString_Check(obj))
3548#endif
3549 {
3550 char *cstr; Py_ssize_t len;
3551 PyObject *bytes = NULL;
3552 int ret = SWIG_OK;
3553 if (alloc)
3554 *alloc = SWIG_OLDOBJ;
3555#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3556 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3557 return SWIG_TypeError;
3558#else
3559 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3560 if (!cstr)
3561 return SWIG_TypeError;
3562 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3563 if (bytes && cptr) {
3564 if (alloc) {
3565 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3566 *alloc = SWIG_NEWOBJ;
3567 } else {
3568 /* alloc must be set in order to clean up allocated memory */
3569 return SWIG_RuntimeError;
3570 }
3571 }
3572#endif
3573 if (cptr) *cptr = cstr;
3574 if (psize) *psize = len + 1;
3575 SWIG_Py_XDECREF(bytes);
3576 return ret;
3577 } else {
3578#if defined(SWIG_PYTHON_2_UNICODE)
3579#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3580#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3581#endif
3582#if PY_VERSION_HEX<0x03000000
3583 if (PyUnicode_Check(obj)) {
3584 char *cstr; Py_ssize_t len;
3585 if (!alloc && cptr) {
3586 return SWIG_RuntimeError;
3587 }
3588 obj = PyUnicode_AsUTF8String(obj);
3589 if (!obj)
3590 return SWIG_TypeError;
3591 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3592 if (cptr) {
3593 if (alloc) *alloc = SWIG_NEWOBJ;
3594 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3595 }
3596 if (psize) *psize = len + 1;
3597
3598 SWIG_Py_XDECREF(obj);
3599 return SWIG_OK;
3600 } else {
3601 SWIG_Py_XDECREF(obj);
3602 }
3603 }
3604#endif
3605#endif
3606
3607 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3608 if (pchar_descriptor) {
3609 void* vptr = 0;
3610 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3611 if (cptr) *cptr = (char *) vptr;
3612 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3613 if (alloc) *alloc = SWIG_OLDOBJ;
3614 return SWIG_OK;
3615 }
3616 }
3617 }
3618 return SWIG_TypeError;
3619}
3620
3621
3622SWIGINTERN int
3623SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3624{
3625 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3626 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3627 if (SWIG_IsOK(res)) {
3628 /* special case of single char conversion when we don't need space for NUL */
3629 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3630 if (csize <= size) {
3631 if (val) {
3632 if (csize) memcpy(val, cptr, csize*sizeof(char));
3633 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3634 }
3635 if (alloc == SWIG_NEWOBJ) {
3636 free((char*)cptr);
3637 res = SWIG_DelNewMask(res);
3638 }
3639 return res;
3640 }
3641 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3642 }
3643 return SWIG_TypeError;
3644}
3645
3646
3647SWIGINTERNINLINE PyObject *
3648SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3649{
3650 if (carray) {
3651 if (size > INT_MAX) {
3652 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3653 return pchar_descriptor ?
3654 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3655 } else {
3656#if PY_VERSION_HEX >= 0x03000000
3657#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3658 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3659#else
3660 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3661#endif
3662#else
3663 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3664#endif
3665 }
3666 } else {
3667 return SWIG_Py_Void();
3668 }
3669}
3670
3671
3672SWIGINTERN size_t
3673SWIG_strnlen(const char* s, size_t maxlen)
3674{
3675 const char *p;
3676 for (p = s; maxlen-- && *p; p++)
3677 ;
3678 return p - s;
3679}
3680
3681
3682
3683
3684
3685SWIGINTERN int
3686SWIG_AsVal_char (PyObject * obj, char *val)
3687{
3688 int res = SWIG_AsCharArray(obj, val, 1);
3689 if (!SWIG_IsOK(res)) {
3690 long v;
3691 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3692 if (SWIG_IsOK(res)) {
3693 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3694 if (val) *val = (char)(v);
3695 } else {
3696 res = SWIG_OverflowError;
3697 }
3698 }
3699 }
3700 return res;
3701}
3702
3703#ifdef __cplusplus
3704extern "C" {
3705#endif
3706
3707 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3708
3709// some really twisted stuff to allow calling a single precision library from python
3710 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3711 {
3712 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3713 mindims, maxdims );
3714 if ( !tmp )
3715 {
3716 // could be an incoming long array which can't be "safely" converted, do it anyway
3717 if ( PyArray_Check( in ) )
3718 {
3719 PyErr_Clear();
3720 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3721 }
3722 }
3723 return tmp;
3724 }
3725
3726
3727#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3728
3729SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3730 PyObject *resultobj = 0;
3731 PLFLT arg1 ;
3732 PLFLT arg2 ;
3733 PLFLT *arg3 = (PLFLT *) 0 ;
3734 PLFLT *arg4 = (PLFLT *) 0 ;
3735 PLPointer arg5 = (PLPointer) 0 ;
3736 double val1 ;
3737 int ecode1 = 0 ;
3738 double val2 ;
3739 int ecode2 = 0 ;
3740 PLFLT temp3 ;
3741 int res3 = SWIG_TMPOBJ ;
3742 PLFLT temp4 ;
3743 int res4 = SWIG_TMPOBJ ;
3744 PyObject *swig_obj[2] ;
3745
3746 arg3 = &temp3;
3747 arg4 = &temp4;
3748 {
3749 arg5 = NULL;
3750 }
3751 (void)self;
3752 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3753 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3754 if (!SWIG_IsOK(ecode1)) {
3755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3756 }
3757 arg1 = (PLFLT)(val1);
3758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3759 if (!SWIG_IsOK(ecode2)) {
3760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3761 }
3762 arg2 = (PLFLT)(val2);
3763 pltr0(arg1,arg2,arg3,arg4,arg5);
3764 resultobj = SWIG_Py_Void();
3765 if (SWIG_IsTmpObj(res3)) {
3766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3767 } else {
3768 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3770 }
3771 if (SWIG_IsTmpObj(res4)) {
3772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3773 } else {
3774 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3776 }
3777 return resultobj;
3778fail:
3779 return NULL;
3780}
3781
3782
3783
3784 PyArrayObject *pltr_xg, *pltr_yg;
3787
3788 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3789 void cleanup_PLcGrid1( void );
3790 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3791 void cleanup_PLcGrid2( void );
3792
3793 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3794 {
3795 // fprintf(stderr, "marshal PLcGrid1\n");
3796 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3797 {
3798 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3799 return NULL;
3800 }
3801 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3802 NPY_PLFLT, 1, 1 );
3803 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3804 NPY_PLFLT, 1, 1 );
3805 if ( pltr_xg == 0 || pltr_yg == 0 )
3806 {
3807 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3808 return NULL;
3809 }
3810 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3811 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3812 if ( isimg == 0 )
3813 {
3814 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3815 {
3816 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3817 return NULL;
3818 }
3819 }
3820 else
3821 {
3822 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3823 {
3824 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3825 return NULL;
3826 }
3827 }
3828 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3829 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3830 return &tmpGrid1;
3831 }
3832
3833 void cleanup_PLcGrid1( void )
3834 {
3835 // fprintf(stderr, "cleanup PLcGrid1\n");
3836 Py_CLEAR( pltr_xg );
3837 Py_CLEAR( pltr_yg );
3838 }
3839
3840 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3841 {
3842 int i, size;
3843 // fprintf(stderr, "marshal PLcGrid2\n");
3844 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3845 {
3846 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3847 return NULL;
3848 }
3849 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3850 NPY_PLFLT, 2, 2 );
3851 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3852 NPY_PLFLT, 2, 2 );
3853 if ( pltr_xg == 0 || pltr_yg == 0 )
3854 {
3855 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3856 return NULL;
3857 }
3858 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3859 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3860 {
3861 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3862 return NULL;
3863 }
3864 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3865 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3866 if ( isimg == 0 )
3867 {
3868 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3869 {
3870 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3871 return NULL;
3872 }
3873 }
3874 else
3875 {
3876 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3877 {
3878 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3879 return NULL;
3880 }
3881 }
3882 size = tmpGrid2.ny;
3883 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3884 for ( i = 0; i < tmpGrid2.nx; i++ )
3885 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3886 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3887 for ( i = 0; i < tmpGrid2.nx; i++ )
3888 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3889 return &tmpGrid2;
3890 }
3891
3892 void cleanup_PLcGrid2( void )
3893 {
3894 // fprintf(stderr, "cleanup PLcGrid2\n");
3895 free( tmpGrid2.xg );
3896 free( tmpGrid2.yg );
3897 Py_CLEAR( pltr_xg );
3898 Py_CLEAR( pltr_yg );
3899 }
3900
3901SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3902 PyObject *resultobj = 0;
3903 PLFLT arg1 ;
3904 PLFLT arg2 ;
3905 PLFLT *arg3 = (PLFLT *) 0 ;
3906 PLFLT *arg4 = (PLFLT *) 0 ;
3907 PLcGrid *arg5 = (PLcGrid *) 0 ;
3908 double val1 ;
3909 int ecode1 = 0 ;
3910 double val2 ;
3911 int ecode2 = 0 ;
3912 PLFLT temp3 ;
3913 int res3 = SWIG_TMPOBJ ;
3914 PLFLT temp4 ;
3915 int res4 = SWIG_TMPOBJ ;
3916 PyObject *swig_obj[3] ;
3917
3918 arg3 = &temp3;
3919 arg4 = &temp4;
3920 (void)self;
3921 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3922 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3923 if (!SWIG_IsOK(ecode1)) {
3924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3925 }
3926 arg1 = (PLFLT)(val1);
3927 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3928 if (!SWIG_IsOK(ecode2)) {
3929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3930 }
3931 arg2 = (PLFLT)(val2);
3932 {
3933 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3934 if ( !arg5 )
3935 return NULL;
3936 }
3937 pltr1(arg1,arg2,arg3,arg4,arg5);
3938 resultobj = SWIG_Py_Void();
3939 if (SWIG_IsTmpObj(res3)) {
3940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3941 } else {
3942 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3944 }
3945 if (SWIG_IsTmpObj(res4)) {
3946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3947 } else {
3948 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3950 }
3951 {
3953 }
3954 return resultobj;
3955fail:
3956 {
3958 }
3959 return NULL;
3960}
3961
3962
3963SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3964 PyObject *resultobj = 0;
3965 PLFLT arg1 ;
3966 PLFLT arg2 ;
3967 PLFLT *arg3 = (PLFLT *) 0 ;
3968 PLFLT *arg4 = (PLFLT *) 0 ;
3969 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3970 double val1 ;
3971 int ecode1 = 0 ;
3972 double val2 ;
3973 int ecode2 = 0 ;
3974 PLFLT temp3 ;
3975 int res3 = SWIG_TMPOBJ ;
3976 PLFLT temp4 ;
3977 int res4 = SWIG_TMPOBJ ;
3978 PyObject *swig_obj[3] ;
3979
3980 arg3 = &temp3;
3981 arg4 = &temp4;
3982 (void)self;
3983 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3984 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3985 if (!SWIG_IsOK(ecode1)) {
3986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3987 }
3988 arg1 = (PLFLT)(val1);
3989 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3990 if (!SWIG_IsOK(ecode2)) {
3991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3992 }
3993 arg2 = (PLFLT)(val2);
3994 {
3995 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3996 if ( !arg5 )
3997 return NULL;
3998 }
3999 pltr2(arg1,arg2,arg3,arg4,arg5);
4000 resultobj = SWIG_Py_Void();
4001 if (SWIG_IsTmpObj(res3)) {
4002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
4003 } else {
4004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
4006 }
4007 if (SWIG_IsTmpObj(res4)) {
4008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
4009 } else {
4010 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
4012 }
4013 {
4015 }
4016 return resultobj;
4017fail:
4018 {
4020 }
4021 return NULL;
4022}
4023
4024
4025
4026 // helper code for handling the callback
4027#if 0
4028 static PyInterpreterState *save_interp = NULL;
4029#endif
4031 PyObject* python_pltr = NULL;
4032 PyObject* python_f2eval = NULL;
4033 PyObject* python_ct = NULL;
4034 PyObject* python_mapform = NULL;
4035 PyObject* python_label = NULL;
4036
4037#if 0
4038#define MY_BLOCK_THREADS { \
4039 PyThreadState *prev_state, *new_state; \
4040 /* need to have started a thread at some stage */ \
4041 /* for the following to work */ \
4042 PyEval_AcquireLock(); \
4043 new_state = PyThreadState_New( save_interp ); \
4044 prev_state = PyThreadState_Swap( new_state );
4045#define MY_UNBLOCK_THREADS \
4046 new_state = PyThreadState_Swap( prev_state ); \
4047 PyThreadState_Clear( new_state ); \
4048 PyEval_ReleaseLock(); \
4049 PyThreadState_Delete( new_state ); \
4050 }
4051#else
4052#define MY_BLOCK_THREADS
4053#define MY_UNBLOCK_THREADS
4054#endif
4055
4056// Function prototypes
4057 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4059 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4060 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4061 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4062 pltr_func marshal_pltr( PyObject* input );
4063 void cleanup_pltr( void );
4064 ct_func marshal_ct( PyObject* input );
4065 void cleanup_ct( void );
4066 mapform_func marshal_mapform( PyObject* input );
4067 void cleanup_mapform( void );
4068 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4069 void cleanup_PLPointer( void );
4070
4071
4072// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4073
4074 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4075 {
4076 PyObject *pdata, *arglist, *result;
4077 PyArrayObject *tmp;
4078
4079 // the data argument is acutally a pointer to a python object
4080 pdata = (PyObject *) data;
4081 if ( data == NULL )
4082 {
4083 pdata = Py_None;
4084 }
4085 if ( python_pltr ) // if not something is terribly wrong
4086 { // hold a reference to the data object
4087 Py_XINCREF( pdata );
4088 // grab the Global Interpreter Lock to be sure threads don't mess us up
4090 // build the argument list
4091#ifdef PL_DOUBLE
4092 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4093#else
4094 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4095#endif
4096 if ( arglist == NULL )
4097 {
4098 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4099 *tx = *ty = 0;
4100 return;
4101 }
4102 // call the python function
4103 result = PyObject_CallObject( python_pltr, arglist );
4104 // release the argument list
4105 Py_CLEAR( arglist );
4106 // check and unpack the result
4107 if ( result == NULL )
4108 {
4109 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4110 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4111 *tx = *ty = 0;
4112 }
4113 else
4114 {
4115 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4116 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4117 {
4118 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4119 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4120 *tx = *ty = 0;
4121 }
4122 else
4123 {
4124 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4125 *tx = t[0];
4126 *ty = t[1];
4127 Py_CLEAR( tmp );
4128 }
4129 }
4130 // release the result
4131 Py_CLEAR( result );
4132 // release the global interpreter lock
4134 }
4135 }
4136
4138 {
4139 PyObject *pdata, *arglist, *result;
4140 PLFLT fresult = 0.0;
4141
4142 // the data argument is acutally a pointer to a python object
4143 pdata = (PyObject *) data;
4144 if ( python_f2eval ) // if not something is terribly wrong
4145 { // hold a reference to the data object
4146 Py_XINCREF( pdata );
4147 // grab the Global Interpreter Lock to be sure threads don't mess us up
4149 // build the argument list
4150 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4151 // call the python function
4152 result = PyObject_CallObject( python_f2eval, arglist );
4153 // release the argument list
4154 Py_CLEAR( arglist );
4155 // check and unpack the result
4156 if ( !PyFloat_Check( result ) )
4157 {
4158 fprintf( stderr, "f2eval callback must return a float\n" );
4159 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4160 }
4161 else
4162 {
4163 // should I test the type here?
4164 fresult = (PLFLT) PyFloat_AsDouble( result );
4165 }
4166 // release the result
4167 Py_CLEAR( result );
4168 // release the global interpreter lock
4170 }
4171 return fresult;
4172 }
4173
4174 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4175 {
4176 PyObject *pdata, *arglist, *result, *unicode_string;
4177 char *pystring;
4178
4179 // the data argument is acutally a pointer to a python object
4180 if ( data )
4181 pdata = (PyObject *) data;
4182 else
4183 pdata = Py_None;
4184 if ( python_label ) // if not something is terribly wrong
4185 { // hold a reference to the data object
4186 Py_XINCREF( pdata );
4187 // grab the Global Interpreter Lock to be sure threads don't mess us up
4189 // build the argument list
4190#ifdef PL_DOUBLE
4191 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4192#else
4193 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4194#endif
4195 // call the python function
4196 result = PyObject_CallObject( python_label, arglist );
4197 // release the argument list
4198 //Py_CLEAR(arglist);
4199 // check and unpack the result
4200 if ( result == NULL )
4201 {
4202 fprintf( stderr, "label callback failed with 3 arguments\n" );
4203 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4204 }
4205 else if ( PyString_Check( result ) )
4206 {
4207 // should I test the type here?
4208 pystring = PyString_AsString( result );
4209 strncpy( string, pystring, len );
4210 }
4211 else if ( PyUnicode_Check( result ) )
4212 {
4213 // unicode_string is never freed? memory leak here?
4214 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4215 pystring = PyBytes_AS_STRING( unicode_string );
4216 // len may be different then the byte string length w/ unicode?
4217 strncpy( string, pystring, len );
4218 }
4219 else
4220 {
4221 fprintf( stderr, "label callback must return a string\n" );
4222 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4223 }
4224 // release the result
4225 Py_CLEAR( result );
4226 // release the global interpreter lock
4228 }
4229 }
4230
4231 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4232 {
4233 PyObject *px, *py, *pdata, *arglist, *result;
4234 npy_intp n;
4235 n = 1;
4236
4237 // the data argument is acutally a pointer to a python object
4238 pdata = (PyObject *) data;
4239 if ( data == NULL )
4240 {
4241 pdata = Py_None;
4242 }
4243 if ( python_ct ) // if not something is terribly wrong
4244 { // hold a reference to the data object
4245 Py_XINCREF( pdata );
4246 // grab the Global Interpreter Lock to be sure threads don't mess us up
4248 // build the argument list
4249 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4250 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4251 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4252 // call the python function
4253 result = PyObject_CallObject( python_ct, arglist );
4254 // release the argument list
4255 Py_CLEAR( arglist );
4256 Py_CLEAR( px );
4257 Py_CLEAR( py );
4258 Py_CLEAR( pdata );
4259 // check and unpack the result
4260 if ( result == NULL )
4261 {
4262 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4263 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4264 }
4265 // release the result
4266 Py_CLEAR( result );
4267 // release the global interpreter lock
4269 }
4270 }
4271
4273 {
4274 PyObject *px, *py, *arglist, *result;
4275 // PyArrayObject *tmpx, *tmpy;
4276// PLFLT *xx, *yy;
4277// PLINT i;
4278 npy_intp nn;
4279 nn = n;
4280
4281 if ( python_mapform ) // if not something is terribly wrong
4282 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4284 // build the argument list
4285#ifdef PL_HAVE_PTHREAD
4286 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4287 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4288#else
4289 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4290 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4291#endif
4292 arglist = Py_BuildValue( "(iOO)", n, px, py );
4293 // call the python function
4294 result = PyObject_CallObject( python_mapform, arglist );
4295 // release the argument list
4296 Py_CLEAR( arglist );
4297 Py_CLEAR( px );
4298 Py_CLEAR( py );
4299 // check and unpack the result
4300 if ( result == NULL )
4301 {
4302 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4303 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4304 }
4305 // release the result
4306 Py_CLEAR( result );
4307 // release the global interpreter lock
4309 }
4310 }
4311
4312// marshal the pltr function pointer argument
4313 pltr_func marshal_pltr( PyObject* input )
4314 {
4315 pltr_func result = do_pltr_callback;
4316 PyObject * rep = PyObject_Repr( input );
4317 if ( rep )
4318 {
4319 // Memory leaks here? str and uni_str are not freed?
4320 char* str;
4321 if ( PyUnicode_Check( rep ) )
4322 {
4323 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4324 str = PyBytes_AS_STRING( uni_str );
4325 }
4326 else
4327 {
4328 str = PyString_AsString( rep );
4329 }
4330 if ( strstr( str, "function pltr0" ) != 0 )
4331 {
4332 result = pltr0;
4333 pltr_type = CB_0;
4334 python_pltr = NULL;
4335 }
4336 else if ( strstr( str, "function pltr1" ) != 0 )
4337 {
4338 result = pltr1;
4339 pltr_type = CB_1;
4340 python_pltr = NULL;
4341 }
4342 else if ( strstr( str, "function pltr2" ) != 0 )
4343 {
4344 result = pltr2;
4345 pltr_type = CB_2;
4346 python_pltr = NULL;
4347 }
4348 else
4349 {
4350 python_pltr = input;
4352 Py_XINCREF( input );
4353 }
4354 Py_CLEAR( rep );
4355 }
4356 else
4357 {
4358 python_pltr = input;
4360 Py_XINCREF( input );
4361 }
4362 return result;
4363 }
4364
4365 void cleanup_pltr( void )
4366 {
4367 Py_CLEAR( python_pltr );
4368 python_pltr = 0;
4369 }
4370
4371// marshal the ct function pointer argument
4372 ct_func marshal_ct( PyObject* input )
4373 {
4374 ct_func result = do_ct_callback;
4375 python_ct = input;
4376 Py_XINCREF( input );
4377 return result;
4378 }
4379
4380 void cleanup_ct( void )
4381 {
4382 Py_CLEAR( python_ct );
4383 python_ct = 0;
4384 }
4385
4386// marshal the mapform function pointer argument
4388 {
4390 python_mapform = input;
4391 Py_XINCREF( input );
4392 return result;
4393 }
4394
4395 void cleanup_mapform( void )
4396 {
4397 Py_CLEAR( python_mapform );
4398 python_mapform = 0;
4399 }
4400
4401 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4402 {
4403 PLPointer result = NULL;
4404 switch ( pltr_type )
4405 {
4406 case CB_0:
4407 break;
4408 case CB_1:
4409 if ( input != Py_None )
4410 result = marshal_PLcGrid1( input, isimg );
4411 break;
4412 case CB_2:
4413 if ( input != Py_None )
4414 result = marshal_PLcGrid2( input, isimg );
4415 break;
4416 case CB_Python:
4417 Py_XINCREF( input );
4418 result = (PLPointer *) input;
4419 break;
4420 default:
4421 fprintf( stderr, "pltr_type is invalid\n" );
4422 }
4423 return result;
4424 }
4425
4427 {
4428 switch ( pltr_type )
4429 {
4430 case CB_0:
4431 break;
4432 case CB_1:
4434 break;
4435 case CB_2:
4437 break;
4438 case CB_Python:
4439 Py_CLEAR( python_pltr );
4440 break;
4441 default:
4442 fprintf( stderr, "pltr_type is invalid\n" );
4443 }
4444 python_pltr = 0;
4445 pltr_type = CB_0;
4446 }
4447
4448
4449
4450SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4451 PyObject *resultobj = 0;
4452 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4453 int arg2 ;
4454 void *argp1 = 0 ;
4455 int res1 = 0 ;
4456 int val2 ;
4457 int ecode2 = 0 ;
4458 PyObject *swig_obj[2] ;
4459
4460 (void)self;
4461 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4463 if (!SWIG_IsOK(res1)) {
4464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4465 }
4466 arg1 = (PLGraphicsIn *)(argp1);
4467 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4468 if (!SWIG_IsOK(ecode2)) {
4469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4470 }
4471 arg2 = (int)(val2);
4472 if (arg1) (arg1)->type = arg2;
4473 resultobj = SWIG_Py_Void();
4474 return resultobj;
4475fail:
4476 return NULL;
4477}
4478
4479
4480SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4481 PyObject *resultobj = 0;
4482 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4483 void *argp1 = 0 ;
4484 int res1 = 0 ;
4485 PyObject *swig_obj[1] ;
4486 int result;
4487
4488 (void)self;
4489 if (!args) SWIG_fail;
4490 swig_obj[0] = args;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4494 }
4495 arg1 = (PLGraphicsIn *)(argp1);
4496 result = (int) ((arg1)->type);
4497 resultobj = SWIG_From_int((int)(result));
4498 return resultobj;
4499fail:
4500 return NULL;
4501}
4502
4503
4504SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4505 PyObject *resultobj = 0;
4506 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4507 unsigned int arg2 ;
4508 void *argp1 = 0 ;
4509 int res1 = 0 ;
4510 unsigned int val2 ;
4511 int ecode2 = 0 ;
4512 PyObject *swig_obj[2] ;
4513
4514 (void)self;
4515 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4517 if (!SWIG_IsOK(res1)) {
4518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4519 }
4520 arg1 = (PLGraphicsIn *)(argp1);
4521 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4522 if (!SWIG_IsOK(ecode2)) {
4523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4524 }
4525 arg2 = (unsigned int)(val2);
4526 if (arg1) (arg1)->state = arg2;
4527 resultobj = SWIG_Py_Void();
4528 return resultobj;
4529fail:
4530 return NULL;
4531}
4532
4533
4534SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4535 PyObject *resultobj = 0;
4536 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 PyObject *swig_obj[1] ;
4540 unsigned int result;
4541
4542 (void)self;
4543 if (!args) SWIG_fail;
4544 swig_obj[0] = args;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4548 }
4549 arg1 = (PLGraphicsIn *)(argp1);
4550 result = (unsigned int) ((arg1)->state);
4551 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4552 return resultobj;
4553fail:
4554 return NULL;
4555}
4556
4557
4558SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4559 PyObject *resultobj = 0;
4560 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4561 unsigned int arg2 ;
4562 void *argp1 = 0 ;
4563 int res1 = 0 ;
4564 unsigned int val2 ;
4565 int ecode2 = 0 ;
4566 PyObject *swig_obj[2] ;
4567
4568 (void)self;
4569 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4571 if (!SWIG_IsOK(res1)) {
4572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4573 }
4574 arg1 = (PLGraphicsIn *)(argp1);
4575 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4576 if (!SWIG_IsOK(ecode2)) {
4577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4578 }
4579 arg2 = (unsigned int)(val2);
4580 if (arg1) (arg1)->keysym = arg2;
4581 resultobj = SWIG_Py_Void();
4582 return resultobj;
4583fail:
4584 return NULL;
4585}
4586
4587
4588SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4589 PyObject *resultobj = 0;
4590 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4591 void *argp1 = 0 ;
4592 int res1 = 0 ;
4593 PyObject *swig_obj[1] ;
4594 unsigned int result;
4595
4596 (void)self;
4597 if (!args) SWIG_fail;
4598 swig_obj[0] = args;
4599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4600 if (!SWIG_IsOK(res1)) {
4601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4602 }
4603 arg1 = (PLGraphicsIn *)(argp1);
4604 result = (unsigned int) ((arg1)->keysym);
4605 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4606 return resultobj;
4607fail:
4608 return NULL;
4609}
4610
4611
4612SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4613 PyObject *resultobj = 0;
4614 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4615 unsigned int arg2 ;
4616 void *argp1 = 0 ;
4617 int res1 = 0 ;
4618 unsigned int val2 ;
4619 int ecode2 = 0 ;
4620 PyObject *swig_obj[2] ;
4621
4622 (void)self;
4623 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4625 if (!SWIG_IsOK(res1)) {
4626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4627 }
4628 arg1 = (PLGraphicsIn *)(argp1);
4629 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4630 if (!SWIG_IsOK(ecode2)) {
4631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4632 }
4633 arg2 = (unsigned int)(val2);
4634 if (arg1) (arg1)->button = arg2;
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637fail:
4638 return NULL;
4639}
4640
4641
4642SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4643 PyObject *resultobj = 0;
4644 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4645 void *argp1 = 0 ;
4646 int res1 = 0 ;
4647 PyObject *swig_obj[1] ;
4648 unsigned int result;
4649
4650 (void)self;
4651 if (!args) SWIG_fail;
4652 swig_obj[0] = args;
4653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4656 }
4657 arg1 = (PLGraphicsIn *)(argp1);
4658 result = (unsigned int) ((arg1)->button);
4659 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4660 return resultobj;
4661fail:
4662 return NULL;
4663}
4664
4665
4666SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4667 PyObject *resultobj = 0;
4668 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4669 PLINT arg2 ;
4670 void *argp1 = 0 ;
4671 int res1 = 0 ;
4672 int val2 ;
4673 int ecode2 = 0 ;
4674 PyObject *swig_obj[2] ;
4675
4676 (void)self;
4677 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4679 if (!SWIG_IsOK(res1)) {
4680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4681 }
4682 arg1 = (PLGraphicsIn *)(argp1);
4683 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4684 if (!SWIG_IsOK(ecode2)) {
4685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4686 }
4687 arg2 = (PLINT)(val2);
4688 if (arg1) (arg1)->subwindow = arg2;
4689 resultobj = SWIG_Py_Void();
4690 return resultobj;
4691fail:
4692 return NULL;
4693}
4694
4695
4696SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4697 PyObject *resultobj = 0;
4698 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 PyObject *swig_obj[1] ;
4702 PLINT result;
4703
4704 (void)self;
4705 if (!args) SWIG_fail;
4706 swig_obj[0] = args;
4707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4710 }
4711 arg1 = (PLGraphicsIn *)(argp1);
4712 result = (PLINT) ((arg1)->subwindow);
4713 resultobj = SWIG_From_int((int)(result));
4714 return resultobj;
4715fail:
4716 return NULL;
4717}
4718
4719
4720SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4721 PyObject *resultobj = 0;
4722 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4723 char *arg2 = (char *) (char *)0 ;
4724 void *argp1 = 0 ;
4725 int res1 = 0 ;
4726 char temp2[16] ;
4727 int res2 ;
4728 PyObject *swig_obj[2] ;
4729
4730 (void)self;
4731 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4733 if (!SWIG_IsOK(res1)) {
4734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4735 }
4736 arg1 = (PLGraphicsIn *)(argp1);
4737 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4738 if (!SWIG_IsOK(res2)) {
4739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4740 }
4741 arg2 = (char *)(temp2);
4742 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4743 else memset(arg1->string,0,16*sizeof(char));
4744 resultobj = SWIG_Py_Void();
4745 return resultobj;
4746fail:
4747 return NULL;
4748}
4749
4750
4751SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4752 PyObject *resultobj = 0;
4753 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4754 void *argp1 = 0 ;
4755 int res1 = 0 ;
4756 PyObject *swig_obj[1] ;
4757 char *result = 0 ;
4758
4759 (void)self;
4760 if (!args) SWIG_fail;
4761 swig_obj[0] = args;
4762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4765 }
4766 arg1 = (PLGraphicsIn *)(argp1);
4767 result = (char *)(char *) ((arg1)->string);
4768 {
4769 size_t size = SWIG_strnlen(result, 16);
4770
4771
4772
4773 resultobj = SWIG_FromCharPtrAndSize(result, size);
4774 }
4775 return resultobj;
4776fail:
4777 return NULL;
4778}
4779
4780
4781SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4782 PyObject *resultobj = 0;
4783 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4784 int arg2 ;
4785 void *argp1 = 0 ;
4786 int res1 = 0 ;
4787 int val2 ;
4788 int ecode2 = 0 ;
4789 PyObject *swig_obj[2] ;
4790
4791 (void)self;
4792 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4796 }
4797 arg1 = (PLGraphicsIn *)(argp1);
4798 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4799 if (!SWIG_IsOK(ecode2)) {
4800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4801 }
4802 arg2 = (int)(val2);
4803 if (arg1) (arg1)->pX = arg2;
4804 resultobj = SWIG_Py_Void();
4805 return resultobj;
4806fail:
4807 return NULL;
4808}
4809
4810
4811SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4812 PyObject *resultobj = 0;
4813 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 PyObject *swig_obj[1] ;
4817 int result;
4818
4819 (void)self;
4820 if (!args) SWIG_fail;
4821 swig_obj[0] = args;
4822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4825 }
4826 arg1 = (PLGraphicsIn *)(argp1);
4827 result = (int) ((arg1)->pX);
4828 resultobj = SWIG_From_int((int)(result));
4829 return resultobj;
4830fail:
4831 return NULL;
4832}
4833
4834
4835SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4836 PyObject *resultobj = 0;
4837 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4838 int arg2 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 int val2 ;
4842 int ecode2 = 0 ;
4843 PyObject *swig_obj[2] ;
4844
4845 (void)self;
4846 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4850 }
4851 arg1 = (PLGraphicsIn *)(argp1);
4852 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4853 if (!SWIG_IsOK(ecode2)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4855 }
4856 arg2 = (int)(val2);
4857 if (arg1) (arg1)->pY = arg2;
4858 resultobj = SWIG_Py_Void();
4859 return resultobj;
4860fail:
4861 return NULL;
4862}
4863
4864
4865SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4866 PyObject *resultobj = 0;
4867 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4868 void *argp1 = 0 ;
4869 int res1 = 0 ;
4870 PyObject *swig_obj[1] ;
4871 int result;
4872
4873 (void)self;
4874 if (!args) SWIG_fail;
4875 swig_obj[0] = args;
4876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4877 if (!SWIG_IsOK(res1)) {
4878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4879 }
4880 arg1 = (PLGraphicsIn *)(argp1);
4881 result = (int) ((arg1)->pY);
4882 resultobj = SWIG_From_int((int)(result));
4883 return resultobj;
4884fail:
4885 return NULL;
4886}
4887
4888
4889SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4890 PyObject *resultobj = 0;
4891 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4892 PLFLT arg2 ;
4893 void *argp1 = 0 ;
4894 int res1 = 0 ;
4895 double val2 ;
4896 int ecode2 = 0 ;
4897 PyObject *swig_obj[2] ;
4898
4899 (void)self;
4900 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4904 }
4905 arg1 = (PLGraphicsIn *)(argp1);
4906 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4907 if (!SWIG_IsOK(ecode2)) {
4908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4909 }
4910 arg2 = (PLFLT)(val2);
4911 if (arg1) (arg1)->dX = arg2;
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914fail:
4915 return NULL;
4916}
4917
4918
4919SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4920 PyObject *resultobj = 0;
4921 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 PyObject *swig_obj[1] ;
4925 PLFLT result;
4926
4927 (void)self;
4928 if (!args) SWIG_fail;
4929 swig_obj[0] = args;
4930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4931 if (!SWIG_IsOK(res1)) {
4932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4933 }
4934 arg1 = (PLGraphicsIn *)(argp1);
4935 result = (PLFLT) ((arg1)->dX);
4936 resultobj = SWIG_From_double((double)(result));
4937 return resultobj;
4938fail:
4939 return NULL;
4940}
4941
4942
4943SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4944 PyObject *resultobj = 0;
4945 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4946 PLFLT arg2 ;
4947 void *argp1 = 0 ;
4948 int res1 = 0 ;
4949 double val2 ;
4950 int ecode2 = 0 ;
4951 PyObject *swig_obj[2] ;
4952
4953 (void)self;
4954 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4956 if (!SWIG_IsOK(res1)) {
4957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4958 }
4959 arg1 = (PLGraphicsIn *)(argp1);
4960 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4961 if (!SWIG_IsOK(ecode2)) {
4962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4963 }
4964 arg2 = (PLFLT)(val2);
4965 if (arg1) (arg1)->dY = arg2;
4966 resultobj = SWIG_Py_Void();
4967 return resultobj;
4968fail:
4969 return NULL;
4970}
4971
4972
4973SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4974 PyObject *resultobj = 0;
4975 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 PyObject *swig_obj[1] ;
4979 PLFLT result;
4980
4981 (void)self;
4982 if (!args) SWIG_fail;
4983 swig_obj[0] = args;
4984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4987 }
4988 arg1 = (PLGraphicsIn *)(argp1);
4989 result = (PLFLT) ((arg1)->dY);
4990 resultobj = SWIG_From_double((double)(result));
4991 return resultobj;
4992fail:
4993 return NULL;
4994}
4995
4996
4997SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4998 PyObject *resultobj = 0;
4999 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5000 PLFLT arg2 ;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 double val2 ;
5004 int ecode2 = 0 ;
5005 PyObject *swig_obj[2] ;
5006
5007 (void)self;
5008 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
5009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5010 if (!SWIG_IsOK(res1)) {
5011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5012 }
5013 arg1 = (PLGraphicsIn *)(argp1);
5014 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5015 if (!SWIG_IsOK(ecode2)) {
5016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
5017 }
5018 arg2 = (PLFLT)(val2);
5019 if (arg1) (arg1)->wX = arg2;
5020 resultobj = SWIG_Py_Void();
5021 return resultobj;
5022fail:
5023 return NULL;
5024}
5025
5026
5027SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
5028 PyObject *resultobj = 0;
5029 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5030 void *argp1 = 0 ;
5031 int res1 = 0 ;
5032 PyObject *swig_obj[1] ;
5033 PLFLT result;
5034
5035 (void)self;
5036 if (!args) SWIG_fail;
5037 swig_obj[0] = args;
5038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5041 }
5042 arg1 = (PLGraphicsIn *)(argp1);
5043 result = (PLFLT) ((arg1)->wX);
5044 resultobj = SWIG_From_double((double)(result));
5045 return resultobj;
5046fail:
5047 return NULL;
5048}
5049
5050
5051SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5052 PyObject *resultobj = 0;
5053 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5054 PLFLT arg2 ;
5055 void *argp1 = 0 ;
5056 int res1 = 0 ;
5057 double val2 ;
5058 int ecode2 = 0 ;
5059 PyObject *swig_obj[2] ;
5060
5061 (void)self;
5062 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5066 }
5067 arg1 = (PLGraphicsIn *)(argp1);
5068 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5069 if (!SWIG_IsOK(ecode2)) {
5070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5071 }
5072 arg2 = (PLFLT)(val2);
5073 if (arg1) (arg1)->wY = arg2;
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076fail:
5077 return NULL;
5078}
5079
5080
5081SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5082 PyObject *resultobj = 0;
5083 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087 PLFLT result;
5088
5089 (void)self;
5090 if (!args) SWIG_fail;
5091 swig_obj[0] = args;
5092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5093 if (!SWIG_IsOK(res1)) {
5094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5095 }
5096 arg1 = (PLGraphicsIn *)(argp1);
5097 result = (PLFLT) ((arg1)->wY);
5098 resultobj = SWIG_From_double((double)(result));
5099 return resultobj;
5100fail:
5101 return NULL;
5102}
5103
5104
5105SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5106 PyObject *resultobj = 0;
5107 PLGraphicsIn *result = 0 ;
5108
5109 (void)self;
5110 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5111 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5113 return resultobj;
5114fail:
5115 return NULL;
5116}
5117
5118
5119SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5120 PyObject *resultobj = 0;
5121 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 PyObject *swig_obj[1] ;
5125
5126 (void)self;
5127 if (!args) SWIG_fail;
5128 swig_obj[0] = args;
5129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5132 }
5133 arg1 = (PLGraphicsIn *)(argp1);
5134 free((char *) arg1);
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137fail:
5138 return NULL;
5139}
5140
5141
5142SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5143 PyObject *obj = NULL;
5144 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5146 return SWIG_Py_Void();
5147}
5148
5149SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5150 return SWIG_Python_InitShadowInstance(args);
5151}
5152
5153SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5154 PyObject *resultobj = 0;
5155 PLINT arg1 ;
5156 int val1 ;
5157 int ecode1 = 0 ;
5158 PyObject *swig_obj[1] ;
5159
5160 (void)self;
5161 if (!args) SWIG_fail;
5162 swig_obj[0] = args;
5163 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5164 if (!SWIG_IsOK(ecode1)) {
5165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5166 }
5167 arg1 = (PLINT)(val1);
5168 plsxwin(arg1);
5169 resultobj = SWIG_Py_Void();
5170 return resultobj;
5171fail:
5172 return NULL;
5173}
5174
5175
5176SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5177 PyObject *resultobj = 0;
5178 PLINT arg1 ;
5179 PLINT arg2 ;
5180 int val1 ;
5181 int ecode1 = 0 ;
5182 int val2 ;
5183 int ecode2 = 0 ;
5184 PyObject *swig_obj[2] ;
5185
5186 (void)self;
5187 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5188 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5189 if (!SWIG_IsOK(ecode1)) {
5190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5191 }
5192 arg1 = (PLINT)(val1);
5193 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5194 if (!SWIG_IsOK(ecode2)) {
5195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5196 }
5197 arg2 = (PLINT)(val2);
5198 pl_setcontlabelformat(arg1,arg2);
5199 resultobj = SWIG_Py_Void();
5200 return resultobj;
5201fail:
5202 return NULL;
5203}
5204
5205
5206SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5207 PyObject *resultobj = 0;
5208 PLFLT arg1 ;
5209 PLFLT arg2 ;
5210 PLFLT arg3 ;
5211 PLINT arg4 ;
5212 double val1 ;
5213 int ecode1 = 0 ;
5214 double val2 ;
5215 int ecode2 = 0 ;
5216 double val3 ;
5217 int ecode3 = 0 ;
5218 int val4 ;
5219 int ecode4 = 0 ;
5220 PyObject *swig_obj[4] ;
5221
5222 (void)self;
5223 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5224 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5227 }
5228 arg1 = (PLFLT)(val1);
5229 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5230 if (!SWIG_IsOK(ecode2)) {
5231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5232 }
5233 arg2 = (PLFLT)(val2);
5234 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5235 if (!SWIG_IsOK(ecode3)) {
5236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5237 }
5238 arg3 = (PLFLT)(val3);
5239 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5240 if (!SWIG_IsOK(ecode4)) {
5241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5242 }
5243 arg4 = (PLINT)(val4);
5244 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5245 resultobj = SWIG_Py_Void();
5246 return resultobj;
5247fail:
5248 return NULL;
5249}
5250
5251
5252SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5253 PyObject *resultobj = 0;
5254 PLINT arg1 ;
5255 int val1 ;
5256 int ecode1 = 0 ;
5257 PyObject *swig_obj[1] ;
5258
5259 (void)self;
5260 if (!args) SWIG_fail;
5261 swig_obj[0] = args;
5262 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5263 if (!SWIG_IsOK(ecode1)) {
5264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5265 }
5266 arg1 = (PLINT)(val1);
5267 pladv(arg1);
5268 resultobj = SWIG_Py_Void();
5269 return resultobj;
5270fail:
5271 return NULL;
5272}
5273
5274
5275SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5276 PyObject *resultobj = 0;
5277 PLFLT arg1 ;
5278 PLFLT arg2 ;
5279 PLFLT arg3 ;
5280 PLFLT arg4 ;
5281 PLFLT arg5 ;
5282 PLFLT arg6 ;
5283 PLFLT arg7 ;
5284 PLBOOL arg8 ;
5285 double val1 ;
5286 int ecode1 = 0 ;
5287 double val2 ;
5288 int ecode2 = 0 ;
5289 double val3 ;
5290 int ecode3 = 0 ;
5291 double val4 ;
5292 int ecode4 = 0 ;
5293 double val5 ;
5294 int ecode5 = 0 ;
5295 double val6 ;
5296 int ecode6 = 0 ;
5297 double val7 ;
5298 int ecode7 = 0 ;
5299 int val8 ;
5300 int ecode8 = 0 ;
5301 PyObject *swig_obj[8] ;
5302
5303 (void)self;
5304 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5305 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5306 if (!SWIG_IsOK(ecode1)) {
5307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5308 }
5309 arg1 = (PLFLT)(val1);
5310 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5311 if (!SWIG_IsOK(ecode2)) {
5312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5313 }
5314 arg2 = (PLFLT)(val2);
5315 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5316 if (!SWIG_IsOK(ecode3)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5318 }
5319 arg3 = (PLFLT)(val3);
5320 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5321 if (!SWIG_IsOK(ecode4)) {
5322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5323 }
5324 arg4 = (PLFLT)(val4);
5325 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5326 if (!SWIG_IsOK(ecode5)) {
5327 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5328 }
5329 arg5 = (PLFLT)(val5);
5330 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5331 if (!SWIG_IsOK(ecode6)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5333 }
5334 arg6 = (PLFLT)(val6);
5335 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5336 if (!SWIG_IsOK(ecode7)) {
5337 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5338 }
5339 arg7 = (PLFLT)(val7);
5340 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5341 if (!SWIG_IsOK(ecode8)) {
5342 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5343 }
5344 arg8 = (PLBOOL)(val8);
5345 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5346 resultobj = SWIG_Py_Void();
5347 return resultobj;
5348fail:
5349 return NULL;
5350}
5351
5352
5353SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5354 PyObject *resultobj = 0;
5355 PLFLT arg1 ;
5356 PLFLT arg2 ;
5357 char *arg3 = (char *) 0 ;
5358 PLFLT arg4 ;
5359 PLINT arg5 ;
5360 char *arg6 = (char *) 0 ;
5361 PLFLT arg7 ;
5362 PLINT arg8 ;
5363 double val1 ;
5364 int ecode1 = 0 ;
5365 double val2 ;
5366 int ecode2 = 0 ;
5367 int res3 ;
5368 char *buf3 = 0 ;
5369 int alloc3 = 0 ;
5370 double val4 ;
5371 int ecode4 = 0 ;
5372 int val5 ;
5373 int ecode5 = 0 ;
5374 int res6 ;
5375 char *buf6 = 0 ;
5376 int alloc6 = 0 ;
5377 double val7 ;
5378 int ecode7 = 0 ;
5379 int val8 ;
5380 int ecode8 = 0 ;
5381 PyObject *swig_obj[8] ;
5382
5383 (void)self;
5384 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5385 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5386 if (!SWIG_IsOK(ecode1)) {
5387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5388 }
5389 arg1 = (PLFLT)(val1);
5390 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5391 if (!SWIG_IsOK(ecode2)) {
5392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5393 }
5394 arg2 = (PLFLT)(val2);
5395 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5396 if (!SWIG_IsOK(res3)) {
5397 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5398 }
5399 arg3 = (char *)(buf3);
5400 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5401 if (!SWIG_IsOK(ecode4)) {
5402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5403 }
5404 arg4 = (PLFLT)(val4);
5405 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5406 if (!SWIG_IsOK(ecode5)) {
5407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5408 }
5409 arg5 = (PLINT)(val5);
5410 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5411 if (!SWIG_IsOK(res6)) {
5412 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5413 }
5414 arg6 = (char *)(buf6);
5415 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5416 if (!SWIG_IsOK(ecode7)) {
5417 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5418 }
5419 arg7 = (PLFLT)(val7);
5420 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5421 if (!SWIG_IsOK(ecode8)) {
5422 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5423 }
5424 arg8 = (PLINT)(val8);
5425 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5426 resultobj = SWIG_Py_Void();
5427 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5428 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5429 return resultobj;
5430fail:
5431 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5432 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5433 return NULL;
5434}
5435
5436
5437SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5438 PyObject *resultobj = 0;
5439 PLINT arg1 ;
5440 PLFLT *arg2 = (PLFLT *) 0 ;
5441 PLFLT *arg3 = (PLFLT *) 0 ;
5442 PLINT arg4 ;
5443 PyArrayObject *tmp1 = NULL ;
5444 PyArrayObject *tmp3 = NULL ;
5445 int val4 ;
5446 int ecode4 = 0 ;
5447 PyObject *swig_obj[3] ;
5448
5449 (void)self;
5450 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5451 {
5452 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5453 if ( tmp1 == NULL )
5454 return NULL;
5455 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5456 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5457 }
5458 {
5459 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5460 if ( tmp3 == NULL )
5461 return NULL;
5462 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5463 {
5464 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5465 return NULL;
5466 }
5467 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5468 }
5469 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5470 if (!SWIG_IsOK(ecode4)) {
5471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5472 }
5473 arg4 = (PLINT)(val4);
5474 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5475 resultobj = SWIG_Py_Void();
5476 {
5477 Py_CLEAR( tmp1 );
5478 }
5479 {
5480 Py_CLEAR( tmp3 );
5481 }
5482 return resultobj;
5483fail:
5484 {
5485 Py_CLEAR( tmp1 );
5486 }
5487 {
5488 Py_CLEAR( tmp3 );
5489 }
5490 return NULL;
5491}
5492
5493
5494SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5495 PyObject *resultobj = 0;
5496 PLINT *arg1 = (PLINT *) 0 ;
5497 PLINT *arg2 = (PLINT *) 0 ;
5498 PLINT *arg3 = (PLINT *) 0 ;
5499 PLINT *arg4 = (PLINT *) 0 ;
5500 PLINT *arg5 = (PLINT *) 0 ;
5501 PLFLT *arg6 = (PLFLT *) 0 ;
5502 PLFLT arg7 ;
5503 PLINT temp1 ;
5504 int res1 = SWIG_TMPOBJ ;
5505 PLINT temp2 ;
5506 int res2 = SWIG_TMPOBJ ;
5507 PLINT temp3 ;
5508 int res3 = SWIG_TMPOBJ ;
5509 PLINT temp4 ;
5510 int res4 = SWIG_TMPOBJ ;
5511 PLINT temp5 ;
5512 int res5 = SWIG_TMPOBJ ;
5513 PLFLT temp6 ;
5514 int res6 = SWIG_TMPOBJ ;
5515 double val7 ;
5516 int ecode7 = 0 ;
5517 PyObject *swig_obj[1] ;
5518
5519 arg1 = &temp1;
5520 arg2 = &temp2;
5521 arg3 = &temp3;
5522 arg4 = &temp4;
5523 arg5 = &temp5;
5524 arg6 = &temp6;
5525 (void)self;
5526 if (!args) SWIG_fail;
5527 swig_obj[0] = args;
5528 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5529 if (!SWIG_IsOK(ecode7)) {
5530 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5531 }
5532 arg7 = (PLFLT)(val7);
5533 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5534 resultobj = SWIG_Py_Void();
5535 if (SWIG_IsTmpObj(res1)) {
5536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
5537 } else {
5538 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
5540 }
5541 if (SWIG_IsTmpObj(res2)) {
5542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
5543 } else {
5544 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
5546 }
5547 if (SWIG_IsTmpObj(res3)) {
5548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
5549 } else {
5550 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
5552 }
5553 if (SWIG_IsTmpObj(res4)) {
5554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
5555 } else {
5556 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
5558 }
5559 if (SWIG_IsTmpObj(res5)) {
5560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5561 } else {
5562 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5564 }
5565 if (SWIG_IsTmpObj(res6)) {
5566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
5567 } else {
5568 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
5570 }
5571 return resultobj;
5572fail:
5573 return NULL;
5574}
5575
5576
5577SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5578 PyObject *resultobj = 0;
5579
5580 (void)self;
5581 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5582 plbop();
5583 resultobj = SWIG_Py_Void();
5584 return resultobj;
5585fail:
5586 return NULL;
5587}
5588
5589
5590SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5591 PyObject *resultobj = 0;
5592 char *arg1 = (char *) 0 ;
5593 PLFLT arg2 ;
5594 PLINT arg3 ;
5595 char *arg4 = (char *) 0 ;
5596 PLFLT arg5 ;
5597 PLINT arg6 ;
5598 int res1 ;
5599 char *buf1 = 0 ;
5600 int alloc1 = 0 ;
5601 double val2 ;
5602 int ecode2 = 0 ;
5603 int val3 ;
5604 int ecode3 = 0 ;
5605 int res4 ;
5606 char *buf4 = 0 ;
5607 int alloc4 = 0 ;
5608 double val5 ;
5609 int ecode5 = 0 ;
5610 int val6 ;
5611 int ecode6 = 0 ;
5612 PyObject *swig_obj[6] ;
5613
5614 (void)self;
5615 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5616 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5617 if (!SWIG_IsOK(res1)) {
5618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5619 }
5620 arg1 = (char *)(buf1);
5621 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5622 if (!SWIG_IsOK(ecode2)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5624 }
5625 arg2 = (PLFLT)(val2);
5626 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5627 if (!SWIG_IsOK(ecode3)) {
5628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5629 }
5630 arg3 = (PLINT)(val3);
5631 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5632 if (!SWIG_IsOK(res4)) {
5633 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5634 }
5635 arg4 = (char *)(buf4);
5636 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5637 if (!SWIG_IsOK(ecode5)) {
5638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5639 }
5640 arg5 = (PLFLT)(val5);
5641 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5642 if (!SWIG_IsOK(ecode6)) {
5643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5644 }
5645 arg6 = (PLINT)(val6);
5646 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5647 resultobj = SWIG_Py_Void();
5648 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5649 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5650 return resultobj;
5651fail:
5652 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5653 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5654 return NULL;
5655}
5656
5657
5658SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5659 PyObject *resultobj = 0;
5660 char *arg1 = (char *) 0 ;
5661 char *arg2 = (char *) 0 ;
5662 PLFLT arg3 ;
5663 PLINT arg4 ;
5664 char *arg5 = (char *) 0 ;
5665 char *arg6 = (char *) 0 ;
5666 PLFLT arg7 ;
5667 PLINT arg8 ;
5668 char *arg9 = (char *) 0 ;
5669 char *arg10 = (char *) 0 ;
5670 PLFLT arg11 ;
5671 PLINT arg12 ;
5672 int res1 ;
5673 char *buf1 = 0 ;
5674 int alloc1 = 0 ;
5675 int res2 ;
5676 char *buf2 = 0 ;
5677 int alloc2 = 0 ;
5678 double val3 ;
5679 int ecode3 = 0 ;
5680 int val4 ;
5681 int ecode4 = 0 ;
5682 int res5 ;
5683 char *buf5 = 0 ;
5684 int alloc5 = 0 ;
5685 int res6 ;
5686 char *buf6 = 0 ;
5687 int alloc6 = 0 ;
5688 double val7 ;
5689 int ecode7 = 0 ;
5690 int val8 ;
5691 int ecode8 = 0 ;
5692 int res9 ;
5693 char *buf9 = 0 ;
5694 int alloc9 = 0 ;
5695 int res10 ;
5696 char *buf10 = 0 ;
5697 int alloc10 = 0 ;
5698 double val11 ;
5699 int ecode11 = 0 ;
5700 int val12 ;
5701 int ecode12 = 0 ;
5702 PyObject *swig_obj[12] ;
5703
5704 (void)self;
5705 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5706 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5707 if (!SWIG_IsOK(res1)) {
5708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5709 }
5710 arg1 = (char *)(buf1);
5711 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5712 if (!SWIG_IsOK(res2)) {
5713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5714 }
5715 arg2 = (char *)(buf2);
5716 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5717 if (!SWIG_IsOK(ecode3)) {
5718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5719 }
5720 arg3 = (PLFLT)(val3);
5721 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5722 if (!SWIG_IsOK(ecode4)) {
5723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5724 }
5725 arg4 = (PLINT)(val4);
5726 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5727 if (!SWIG_IsOK(res5)) {
5728 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5729 }
5730 arg5 = (char *)(buf5);
5731 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5732 if (!SWIG_IsOK(res6)) {
5733 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5734 }
5735 arg6 = (char *)(buf6);
5736 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5737 if (!SWIG_IsOK(ecode7)) {
5738 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5739 }
5740 arg7 = (PLFLT)(val7);
5741 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5742 if (!SWIG_IsOK(ecode8)) {
5743 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5744 }
5745 arg8 = (PLINT)(val8);
5746 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5747 if (!SWIG_IsOK(res9)) {
5748 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5749 }
5750 arg9 = (char *)(buf9);
5751 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5752 if (!SWIG_IsOK(res10)) {
5753 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5754 }
5755 arg10 = (char *)(buf10);
5756 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5757 if (!SWIG_IsOK(ecode11)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5759 }
5760 arg11 = (PLFLT)(val11);
5761 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5762 if (!SWIG_IsOK(ecode12)) {
5763 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5764 }
5765 arg12 = (PLINT)(val12);
5766 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);
5767 resultobj = SWIG_Py_Void();
5768 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5769 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5770 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5771 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5772 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5773 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5774 return resultobj;
5775fail:
5776 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5777 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5778 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5779 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5780 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5781 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5782 return NULL;
5783}
5784
5785
5786SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5787 PyObject *resultobj = 0;
5788 PLFLT arg1 ;
5789 PLFLT arg2 ;
5790 PLFLT *arg3 = (PLFLT *) 0 ;
5791 PLFLT *arg4 = (PLFLT *) 0 ;
5792 PLINT *arg5 = (PLINT *) 0 ;
5793 double val1 ;
5794 int ecode1 = 0 ;
5795 double val2 ;
5796 int ecode2 = 0 ;
5797 PLFLT temp3 ;
5798 int res3 = SWIG_TMPOBJ ;
5799 PLFLT temp4 ;
5800 int res4 = SWIG_TMPOBJ ;
5801 PLINT temp5 ;
5802 int res5 = SWIG_TMPOBJ ;
5803 PyObject *swig_obj[2] ;
5804
5805 arg3 = &temp3;
5806 arg4 = &temp4;
5807 arg5 = &temp5;
5808 (void)self;
5809 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5810 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5811 if (!SWIG_IsOK(ecode1)) {
5812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5813 }
5814 arg1 = (PLFLT)(val1);
5815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5816 if (!SWIG_IsOK(ecode2)) {
5817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5818 }
5819 arg2 = (PLFLT)(val2);
5820 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5821 resultobj = SWIG_Py_Void();
5822 if (SWIG_IsTmpObj(res3)) {
5823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
5824 } else {
5825 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
5827 }
5828 if (SWIG_IsTmpObj(res4)) {
5829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
5830 } else {
5831 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
5833 }
5834 if (SWIG_IsTmpObj(res5)) {
5835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5836 } else {
5837 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5839 }
5840 return resultobj;
5841fail:
5842 return NULL;
5843}
5844
5845
5846SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5847 PyObject *resultobj = 0;
5848
5849 (void)self;
5850 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5851 plclear();
5852 resultobj = SWIG_Py_Void();
5853 return resultobj;
5854fail:
5855 return NULL;
5856}
5857
5858
5859SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5860 PyObject *resultobj = 0;
5861 PLINT arg1 ;
5862 int val1 ;
5863 int ecode1 = 0 ;
5864 PyObject *swig_obj[1] ;
5865
5866 (void)self;
5867 if (!args) SWIG_fail;
5868 swig_obj[0] = args;
5869 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5870 if (!SWIG_IsOK(ecode1)) {
5871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5872 }
5873 arg1 = (PLINT)(val1);
5874 plcol0(arg1);
5875 resultobj = SWIG_Py_Void();
5876 return resultobj;
5877fail:
5878 return NULL;
5879}
5880
5881
5882SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5883 PyObject *resultobj = 0;
5884 PLFLT arg1 ;
5885 double val1 ;
5886 int ecode1 = 0 ;
5887 PyObject *swig_obj[1] ;
5888
5889 (void)self;
5890 if (!args) SWIG_fail;
5891 swig_obj[0] = args;
5892 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5893 if (!SWIG_IsOK(ecode1)) {
5894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5895 }
5896 arg1 = (PLFLT)(val1);
5897 plcol1(arg1);
5898 resultobj = SWIG_Py_Void();
5899 return resultobj;
5900fail:
5901 return NULL;
5902}
5903
5904
5905SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5906 PyObject *resultobj = 0;
5907 PLFLT arg1 ;
5908 PLFLT arg2 ;
5909 PLFLT arg3 ;
5910 PLINT arg4 ;
5911 PLBOOL arg5 ;
5912 PLINT arg6 ;
5913 PLINT arg7 ;
5914 PLINT arg8 ;
5915 PLINT arg9 ;
5916 PLINT arg10 ;
5917 PLFLT arg11 ;
5918 double val1 ;
5919 int ecode1 = 0 ;
5920 double val2 ;
5921 int ecode2 = 0 ;
5922 double val3 ;
5923 int ecode3 = 0 ;
5924 int val4 ;
5925 int ecode4 = 0 ;
5926 int val5 ;
5927 int ecode5 = 0 ;
5928 int val6 ;
5929 int ecode6 = 0 ;
5930 int val7 ;
5931 int ecode7 = 0 ;
5932 int val8 ;
5933 int ecode8 = 0 ;
5934 int val9 ;
5935 int ecode9 = 0 ;
5936 int val10 ;
5937 int ecode10 = 0 ;
5938 double val11 ;
5939 int ecode11 = 0 ;
5940 PyObject *swig_obj[11] ;
5941
5942 (void)self;
5943 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5944 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5945 if (!SWIG_IsOK(ecode1)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5947 }
5948 arg1 = (PLFLT)(val1);
5949 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5950 if (!SWIG_IsOK(ecode2)) {
5951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5952 }
5953 arg2 = (PLFLT)(val2);
5954 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5955 if (!SWIG_IsOK(ecode3)) {
5956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5957 }
5958 arg3 = (PLFLT)(val3);
5959 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5960 if (!SWIG_IsOK(ecode4)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5962 }
5963 arg4 = (PLINT)(val4);
5964 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5965 if (!SWIG_IsOK(ecode5)) {
5966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5967 }
5968 arg5 = (PLBOOL)(val5);
5969 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5970 if (!SWIG_IsOK(ecode6)) {
5971 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5972 }
5973 arg6 = (PLINT)(val6);
5974 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5975 if (!SWIG_IsOK(ecode7)) {
5976 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5977 }
5978 arg7 = (PLINT)(val7);
5979 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5980 if (!SWIG_IsOK(ecode8)) {
5981 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5982 }
5983 arg8 = (PLINT)(val8);
5984 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5985 if (!SWIG_IsOK(ecode9)) {
5986 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5987 }
5988 arg9 = (PLINT)(val9);
5989 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5990 if (!SWIG_IsOK(ecode10)) {
5991 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5992 }
5993 arg10 = (PLINT)(val10);
5994 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5995 if (!SWIG_IsOK(ecode11)) {
5996 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5997 }
5998 arg11 = (PLFLT)(val11);
5999 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
6000 resultobj = SWIG_Py_Void();
6001 return resultobj;
6002fail:
6003 return NULL;
6004}
6005
6006
6007SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
6008 PyObject *resultobj = 0;
6009 PLFLT **arg1 = (PLFLT **) 0 ;
6010 PLINT arg2 ;
6011 PLINT arg3 ;
6012 PLINT arg4 ;
6013 PLINT arg5 ;
6014 PLINT arg6 ;
6015 PLINT arg7 ;
6016 PLFLT *arg8 = (PLFLT *) 0 ;
6017 PLINT arg9 ;
6018 pltr_func arg10 = (pltr_func) 0 ;
6019 PLPointer arg11 = (PLPointer) 0 ;
6020 PyArrayObject *tmp1 = NULL ;
6021 int val4 ;
6022 int ecode4 = 0 ;
6023 int val5 ;
6024 int ecode5 = 0 ;
6025 int val6 ;
6026 int ecode6 = 0 ;
6027 int val7 ;
6028 int ecode7 = 0 ;
6029 PyArrayObject *tmp8 = NULL ;
6030 PyObject *swig_obj[8] ;
6031
6032 {
6033 python_pltr = 0;
6034 arg10 = NULL;
6035 }
6036 {
6037 arg11 = NULL;
6038 }
6039 (void)self;
6040 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6041 {
6042 int i, size;
6043 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6044 if ( tmp1 == NULL )
6045 return NULL;
6046 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6047 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6048 size = arg3;
6049 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6050 for ( i = 0; i < arg2; i++ )
6051 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6052 }
6053 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6054 if (!SWIG_IsOK(ecode4)) {
6055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6056 }
6057 arg4 = (PLINT)(val4);
6058 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6059 if (!SWIG_IsOK(ecode5)) {
6060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6061 }
6062 arg5 = (PLINT)(val5);
6063 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6064 if (!SWIG_IsOK(ecode6)) {
6065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6066 }
6067 arg6 = (PLINT)(val6);
6068 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6069 if (!SWIG_IsOK(ecode7)) {
6070 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6071 }
6072 arg7 = (PLINT)(val7);
6073 {
6074 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6075 if ( tmp8 == NULL )
6076 return NULL;
6077 arg9 = PyArray_DIMS( tmp8 )[0];
6078 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6079 }
6080 if (swig_obj[6]) {
6081 {
6082 // it must be a callable or None
6083 if ( swig_obj[6] == Py_None )
6084 {
6085 arg10 = NULL;
6086 }
6087 else
6088 {
6089 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6090 {
6091 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6092 return NULL;
6093 }
6094 arg10 = marshal_pltr( swig_obj[6] );
6095 }
6096 }
6097 }
6098 if (swig_obj[7]) {
6099 {
6100 if ( swig_obj[7] == Py_None )
6101 arg11 = NULL;
6102 else
6103 {
6104 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6105 }
6106 }
6107 }
6108 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6109 resultobj = SWIG_Py_Void();
6110 {
6111 Py_CLEAR( tmp1 );
6112 free( arg1 );
6113 }
6114 {
6115 Py_CLEAR( tmp8 );
6116 }
6117 {
6118 cleanup_pltr();
6119 }
6120 {
6122 }
6123 return resultobj;
6124fail:
6125 {
6126 Py_CLEAR( tmp1 );
6127 free( arg1 );
6128 }
6129 {
6130 Py_CLEAR( tmp8 );
6131 }
6132 {
6133 cleanup_pltr();
6134 }
6135 {
6137 }
6138 return NULL;
6139}
6140
6141
6142SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6143 PyObject *resultobj = 0;
6144 PLINT arg1 ;
6145 PLINT arg2 ;
6146 PLINT arg3 ;
6147 PLINT arg4 ;
6148 PLINT arg5 ;
6149 PLFLT arg6 ;
6150 PLFLT *arg7 = (PLFLT *) 0 ;
6151 int val1 ;
6152 int ecode1 = 0 ;
6153 int val2 ;
6154 int ecode2 = 0 ;
6155 int val3 ;
6156 int ecode3 = 0 ;
6157 int val4 ;
6158 int ecode4 = 0 ;
6159 int val5 ;
6160 int ecode5 = 0 ;
6161 double val6 ;
6162 int ecode6 = 0 ;
6163 PLFLT temp7 ;
6164 int res7 = SWIG_TMPOBJ ;
6165 PyObject *swig_obj[6] ;
6166
6167 arg7 = &temp7;
6168 (void)self;
6169 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6170 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6171 if (!SWIG_IsOK(ecode1)) {
6172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6173 }
6174 arg1 = (PLINT)(val1);
6175 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6176 if (!SWIG_IsOK(ecode2)) {
6177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6178 }
6179 arg2 = (PLINT)(val2);
6180 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6181 if (!SWIG_IsOK(ecode3)) {
6182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6183 }
6184 arg3 = (PLINT)(val3);
6185 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6186 if (!SWIG_IsOK(ecode4)) {
6187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6188 }
6189 arg4 = (PLINT)(val4);
6190 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6191 if (!SWIG_IsOK(ecode5)) {
6192 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6193 }
6194 arg5 = (PLINT)(val5);
6195 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6196 if (!SWIG_IsOK(ecode6)) {
6197 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6198 }
6199 arg6 = (PLFLT)(val6);
6200 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6201 resultobj = SWIG_Py_Void();
6202 if (SWIG_IsTmpObj(res7)) {
6203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)), 1);
6204 } else {
6205 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags), 1);
6207 }
6208 return resultobj;
6209fail:
6210 return NULL;
6211}
6212
6213
6214SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6215 PyObject *resultobj = 0;
6216 PLINT arg1 ;
6217 PLBOOL arg2 ;
6218 int val1 ;
6219 int ecode1 = 0 ;
6220 int val2 ;
6221 int ecode2 = 0 ;
6222 PyObject *swig_obj[2] ;
6223
6224 (void)self;
6225 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6226 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6227 if (!SWIG_IsOK(ecode1)) {
6228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6229 }
6230 arg1 = (PLINT)(val1);
6231 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6232 if (!SWIG_IsOK(ecode2)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6234 }
6235 arg2 = (PLBOOL)(val2);
6236 plcpstrm(arg1,arg2);
6237 resultobj = SWIG_Py_Void();
6238 return resultobj;
6239fail:
6240 return NULL;
6241}
6242
6243
6244SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6245 PyObject *resultobj = 0;
6246
6247 (void)self;
6248 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6249 plend();
6250 resultobj = SWIG_Py_Void();
6251 return resultobj;
6252fail:
6253 return NULL;
6254}
6255
6256
6257SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6258 PyObject *resultobj = 0;
6259
6260 (void)self;
6261 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6262 plend1();
6263 resultobj = SWIG_Py_Void();
6264 return resultobj;
6265fail:
6266 return NULL;
6267}
6268
6269
6270SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6271 PyObject *resultobj = 0;
6272 PLFLT arg1 ;
6273 PLFLT arg2 ;
6274 PLFLT arg3 ;
6275 PLFLT arg4 ;
6276 PLINT arg5 ;
6277 PLINT arg6 ;
6278 double val1 ;
6279 int ecode1 = 0 ;
6280 double val2 ;
6281 int ecode2 = 0 ;
6282 double val3 ;
6283 int ecode3 = 0 ;
6284 double val4 ;
6285 int ecode4 = 0 ;
6286 int val5 ;
6287 int ecode5 = 0 ;
6288 int val6 ;
6289 int ecode6 = 0 ;
6290 PyObject *swig_obj[6] ;
6291
6292 (void)self;
6293 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6294 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6295 if (!SWIG_IsOK(ecode1)) {
6296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6297 }
6298 arg1 = (PLFLT)(val1);
6299 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6300 if (!SWIG_IsOK(ecode2)) {
6301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6302 }
6303 arg2 = (PLFLT)(val2);
6304 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6305 if (!SWIG_IsOK(ecode3)) {
6306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6307 }
6308 arg3 = (PLFLT)(val3);
6309 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6310 if (!SWIG_IsOK(ecode4)) {
6311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6312 }
6313 arg4 = (PLFLT)(val4);
6314 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6315 if (!SWIG_IsOK(ecode5)) {
6316 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6317 }
6318 arg5 = (PLINT)(val5);
6319 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6320 if (!SWIG_IsOK(ecode6)) {
6321 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6322 }
6323 arg6 = (PLINT)(val6);
6324 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6325 resultobj = SWIG_Py_Void();
6326 return resultobj;
6327fail:
6328 return NULL;
6329}
6330
6331
6332SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6333 PyObject *resultobj = 0;
6334 PLFLT arg1 ;
6335 PLFLT arg2 ;
6336 PLFLT arg3 ;
6337 PLFLT arg4 ;
6338 PLINT arg5 ;
6339 PLINT arg6 ;
6340 double val1 ;
6341 int ecode1 = 0 ;
6342 double val2 ;
6343 int ecode2 = 0 ;
6344 double val3 ;
6345 int ecode3 = 0 ;
6346 double val4 ;
6347 int ecode4 = 0 ;
6348 int val5 ;
6349 int ecode5 = 0 ;
6350 int val6 ;
6351 int ecode6 = 0 ;
6352 PyObject *swig_obj[6] ;
6353
6354 (void)self;
6355 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6356 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6357 if (!SWIG_IsOK(ecode1)) {
6358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6359 }
6360 arg1 = (PLFLT)(val1);
6361 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6362 if (!SWIG_IsOK(ecode2)) {
6363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6364 }
6365 arg2 = (PLFLT)(val2);
6366 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6367 if (!SWIG_IsOK(ecode3)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6369 }
6370 arg3 = (PLFLT)(val3);
6371 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6372 if (!SWIG_IsOK(ecode4)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6374 }
6375 arg4 = (PLFLT)(val4);
6376 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6377 if (!SWIG_IsOK(ecode5)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6379 }
6380 arg5 = (PLINT)(val5);
6381 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6382 if (!SWIG_IsOK(ecode6)) {
6383 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6384 }
6385 arg6 = (PLINT)(val6);
6386 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6387 resultobj = SWIG_Py_Void();
6388 return resultobj;
6389fail:
6390 return NULL;
6391}
6392
6393
6394SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6395 PyObject *resultobj = 0;
6396
6397 (void)self;
6398 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6399 pleop();
6400 resultobj = SWIG_Py_Void();
6401 return resultobj;
6402fail:
6403 return NULL;
6404}
6405
6406
6407SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6408 PyObject *resultobj = 0;
6409 PLINT arg1 ;
6410 PLFLT *arg2 = (PLFLT *) 0 ;
6411 PLFLT *arg3 = (PLFLT *) 0 ;
6412 PLFLT *arg4 = (PLFLT *) 0 ;
6413 PyArrayObject *tmp1 = NULL ;
6414 PyArrayObject *tmp3 = NULL ;
6415 PyArrayObject *tmp4 = NULL ;
6416 PyObject *swig_obj[3] ;
6417
6418 (void)self;
6419 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6420 {
6421 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6422 if ( tmp1 == NULL )
6423 return NULL;
6424 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6425 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6426 }
6427 {
6428 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6429 if ( tmp3 == NULL )
6430 return NULL;
6431 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6432 {
6433 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6434 return NULL;
6435 }
6436 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6437 }
6438 {
6439 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6440 if ( tmp4 == NULL )
6441 return NULL;
6442 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6443 {
6444 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6445 return NULL;
6446 }
6447 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6448 }
6449 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6450 resultobj = SWIG_Py_Void();
6451 {
6452 Py_CLEAR( tmp1 );
6453 }
6454 {
6455 Py_CLEAR( tmp3 );
6456 }
6457 {
6458 Py_CLEAR( tmp4 );
6459 }
6460 return resultobj;
6461fail:
6462 {
6463 Py_CLEAR( tmp1 );
6464 }
6465 {
6466 Py_CLEAR( tmp3 );
6467 }
6468 {
6469 Py_CLEAR( tmp4 );
6470 }
6471 return NULL;
6472}
6473
6474
6475SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6476 PyObject *resultobj = 0;
6477 PLINT arg1 ;
6478 PLFLT *arg2 = (PLFLT *) 0 ;
6479 PLFLT *arg3 = (PLFLT *) 0 ;
6480 PLFLT *arg4 = (PLFLT *) 0 ;
6481 PyArrayObject *tmp1 = NULL ;
6482 PyArrayObject *tmp3 = NULL ;
6483 PyArrayObject *tmp4 = NULL ;
6484 PyObject *swig_obj[3] ;
6485
6486 (void)self;
6487 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6488 {
6489 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6490 if ( tmp1 == NULL )
6491 return NULL;
6492 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6493 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6494 }
6495 {
6496 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6497 if ( tmp3 == NULL )
6498 return NULL;
6499 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6500 {
6501 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6502 return NULL;
6503 }
6504 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6505 }
6506 {
6507 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6508 if ( tmp4 == NULL )
6509 return NULL;
6510 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6511 {
6512 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6513 return NULL;
6514 }
6515 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6516 }
6517 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6518 resultobj = SWIG_Py_Void();
6519 {
6520 Py_CLEAR( tmp1 );
6521 }
6522 {
6523 Py_CLEAR( tmp3 );
6524 }
6525 {
6526 Py_CLEAR( tmp4 );
6527 }
6528 return resultobj;
6529fail:
6530 {
6531 Py_CLEAR( tmp1 );
6532 }
6533 {
6534 Py_CLEAR( tmp3 );
6535 }
6536 {
6537 Py_CLEAR( tmp4 );
6538 }
6539 return NULL;
6540}
6541
6542
6543SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6544 PyObject *resultobj = 0;
6545
6546 (void)self;
6547 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6548 plfamadv();
6549 resultobj = SWIG_Py_Void();
6550 return resultobj;
6551fail:
6552 return NULL;
6553}
6554
6555
6556SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6557 PyObject *resultobj = 0;
6558 PLINT arg1 ;
6559 PLFLT *arg2 = (PLFLT *) 0 ;
6560 PLFLT *arg3 = (PLFLT *) 0 ;
6561 PyArrayObject *tmp1 = NULL ;
6562 PyArrayObject *tmp3 = NULL ;
6563 PyObject *swig_obj[2] ;
6564
6565 (void)self;
6566 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6567 {
6568 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6569 if ( tmp1 == NULL )
6570 return NULL;
6571 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6572 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6573 }
6574 {
6575 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6576 if ( tmp3 == NULL )
6577 return NULL;
6578 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6579 {
6580 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6581 return NULL;
6582 }
6583 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6584 }
6585 plfill(arg1,(double const *)arg2,(double const *)arg3);
6586 resultobj = SWIG_Py_Void();
6587 {
6588 Py_CLEAR( tmp1 );
6589 }
6590 {
6591 Py_CLEAR( tmp3 );
6592 }
6593 return resultobj;
6594fail:
6595 {
6596 Py_CLEAR( tmp1 );
6597 }
6598 {
6599 Py_CLEAR( tmp3 );
6600 }
6601 return NULL;
6602}
6603
6604
6605SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6606 PyObject *resultobj = 0;
6607 PLINT arg1 ;
6608 PLFLT *arg2 = (PLFLT *) 0 ;
6609 PLFLT *arg3 = (PLFLT *) 0 ;
6610 PLFLT *arg4 = (PLFLT *) 0 ;
6611 PyArrayObject *tmp1 = NULL ;
6612 PyArrayObject *tmp3 = NULL ;
6613 PyArrayObject *tmp4 = NULL ;
6614 PyObject *swig_obj[3] ;
6615
6616 (void)self;
6617 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6618 {
6619 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6620 if ( tmp1 == NULL )
6621 return NULL;
6622 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6623 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6624 }
6625 {
6626 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6627 if ( tmp3 == NULL )
6628 return NULL;
6629 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6630 {
6631 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6632 return NULL;
6633 }
6634 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6635 }
6636 {
6637 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6638 if ( tmp4 == NULL )
6639 return NULL;
6640 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6641 {
6642 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6643 return NULL;
6644 }
6645 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6646 }
6647 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6648 resultobj = SWIG_Py_Void();
6649 {
6650 Py_CLEAR( tmp1 );
6651 }
6652 {
6653 Py_CLEAR( tmp3 );
6654 }
6655 {
6656 Py_CLEAR( tmp4 );
6657 }
6658 return resultobj;
6659fail:
6660 {
6661 Py_CLEAR( tmp1 );
6662 }
6663 {
6664 Py_CLEAR( tmp3 );
6665 }
6666 {
6667 Py_CLEAR( tmp4 );
6668 }
6669 return NULL;
6670}
6671
6672
6673SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6674 PyObject *resultobj = 0;
6675 PLINT arg1 ;
6676 PLFLT *arg2 = (PLFLT *) 0 ;
6677 PLFLT *arg3 = (PLFLT *) 0 ;
6678 PLFLT arg4 ;
6679 PyArrayObject *tmp1 = NULL ;
6680 PyArrayObject *tmp3 = NULL ;
6681 double val4 ;
6682 int ecode4 = 0 ;
6683 PyObject *swig_obj[3] ;
6684
6685 (void)self;
6686 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6687 {
6688 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6689 if ( tmp1 == NULL )
6690 return NULL;
6691 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6692 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6693 }
6694 {
6695 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6696 if ( tmp3 == NULL )
6697 return NULL;
6698 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6699 {
6700 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6701 return NULL;
6702 }
6703 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6704 }
6705 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6706 if (!SWIG_IsOK(ecode4)) {
6707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6708 }
6709 arg4 = (PLFLT)(val4);
6710 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6711 resultobj = SWIG_Py_Void();
6712 {
6713 Py_CLEAR( tmp1 );
6714 }
6715 {
6716 Py_CLEAR( tmp3 );
6717 }
6718 return resultobj;
6719fail:
6720 {
6721 Py_CLEAR( tmp1 );
6722 }
6723 {
6724 Py_CLEAR( tmp3 );
6725 }
6726 return NULL;
6727}
6728
6729
6730SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6731 PyObject *resultobj = 0;
6732
6733 (void)self;
6734 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6735 plflush();
6736 resultobj = SWIG_Py_Void();
6737 return resultobj;
6738fail:
6739 return NULL;
6740}
6741
6742
6743SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6744 PyObject *resultobj = 0;
6745 PLINT arg1 ;
6746 int val1 ;
6747 int ecode1 = 0 ;
6748 PyObject *swig_obj[1] ;
6749
6750 (void)self;
6751 if (!args) SWIG_fail;
6752 swig_obj[0] = args;
6753 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6754 if (!SWIG_IsOK(ecode1)) {
6755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6756 }
6757 arg1 = (PLINT)(val1);
6758 plfont(arg1);
6759 resultobj = SWIG_Py_Void();
6760 return resultobj;
6761fail:
6762 return NULL;
6763}
6764
6765
6766SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6767 PyObject *resultobj = 0;
6768 PLINT arg1 ;
6769 int val1 ;
6770 int ecode1 = 0 ;
6771 PyObject *swig_obj[1] ;
6772
6773 (void)self;
6774 if (!args) SWIG_fail;
6775 swig_obj[0] = args;
6776 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6777 if (!SWIG_IsOK(ecode1)) {
6778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6779 }
6780 arg1 = (PLINT)(val1);
6781 plfontld(arg1);
6782 resultobj = SWIG_Py_Void();
6783 return resultobj;
6784fail:
6785 return NULL;
6786}
6787
6788
6789SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6790 PyObject *resultobj = 0;
6791 PLFLT *arg1 = (PLFLT *) 0 ;
6792 PLFLT *arg2 = (PLFLT *) 0 ;
6793 PLFLT temp1 ;
6794 int res1 = SWIG_TMPOBJ ;
6795 PLFLT temp2 ;
6796 int res2 = SWIG_TMPOBJ ;
6797
6798 arg1 = &temp1;
6799 arg2 = &temp2;
6800 (void)self;
6801 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6802 plgchr(arg1,arg2);
6803 resultobj = SWIG_Py_Void();
6804 if (SWIG_IsTmpObj(res1)) {
6805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
6806 } else {
6807 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
6809 }
6810 if (SWIG_IsTmpObj(res2)) {
6811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
6812 } else {
6813 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
6815 }
6816 return resultobj;
6817fail:
6818 return NULL;
6819}
6820
6821
6822SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6823 PyObject *resultobj = 0;
6824 PLINT arg1 ;
6825 PLINT *arg2 = (PLINT *) 0 ;
6826 PLINT *arg3 = (PLINT *) 0 ;
6827 PLINT *arg4 = (PLINT *) 0 ;
6828 int val1 ;
6829 int ecode1 = 0 ;
6830 PLINT temp2 ;
6831 int res2 = SWIG_TMPOBJ ;
6832 PLINT temp3 ;
6833 int res3 = SWIG_TMPOBJ ;
6834 PLINT temp4 ;
6835 int res4 = SWIG_TMPOBJ ;
6836 PyObject *swig_obj[1] ;
6837
6838 arg2 = &temp2;
6839 arg3 = &temp3;
6840 arg4 = &temp4;
6841 (void)self;
6842 if (!args) SWIG_fail;
6843 swig_obj[0] = args;
6844 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6845 if (!SWIG_IsOK(ecode1)) {
6846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6847 }
6848 arg1 = (PLINT)(val1);
6849 plgcol0(arg1,arg2,arg3,arg4);
6850 resultobj = SWIG_Py_Void();
6851 if (SWIG_IsTmpObj(res2)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6856 }
6857 if (SWIG_IsTmpObj(res3)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6862 }
6863 if (SWIG_IsTmpObj(res4)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6868 }
6869 return resultobj;
6870fail:
6871 return NULL;
6872}
6873
6874
6875SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6876 PyObject *resultobj = 0;
6877 PLINT arg1 ;
6878 PLINT *arg2 = (PLINT *) 0 ;
6879 PLINT *arg3 = (PLINT *) 0 ;
6880 PLINT *arg4 = (PLINT *) 0 ;
6881 PLFLT *arg5 = (PLFLT *) 0 ;
6882 int val1 ;
6883 int ecode1 = 0 ;
6884 PLINT temp2 ;
6885 int res2 = SWIG_TMPOBJ ;
6886 PLINT temp3 ;
6887 int res3 = SWIG_TMPOBJ ;
6888 PLINT temp4 ;
6889 int res4 = SWIG_TMPOBJ ;
6890 PLFLT temp5 ;
6891 int res5 = SWIG_TMPOBJ ;
6892 PyObject *swig_obj[1] ;
6893
6894 arg2 = &temp2;
6895 arg3 = &temp3;
6896 arg4 = &temp4;
6897 arg5 = &temp5;
6898 (void)self;
6899 if (!args) SWIG_fail;
6900 swig_obj[0] = args;
6901 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6902 if (!SWIG_IsOK(ecode1)) {
6903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6904 }
6905 arg1 = (PLINT)(val1);
6906 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6907 resultobj = SWIG_Py_Void();
6908 if (SWIG_IsTmpObj(res2)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6913 }
6914 if (SWIG_IsTmpObj(res3)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6919 }
6920 if (SWIG_IsTmpObj(res4)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6925 }
6926 if (SWIG_IsTmpObj(res5)) {
6927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
6928 } else {
6929 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
6931 }
6932 return resultobj;
6933fail:
6934 return NULL;
6935}
6936
6937
6938SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6939 PyObject *resultobj = 0;
6940 PLINT *arg1 = (PLINT *) 0 ;
6941 PLINT *arg2 = (PLINT *) 0 ;
6942 PLINT *arg3 = (PLINT *) 0 ;
6943 PLINT temp1 ;
6944 int res1 = SWIG_TMPOBJ ;
6945 PLINT temp2 ;
6946 int res2 = SWIG_TMPOBJ ;
6947 PLINT temp3 ;
6948 int res3 = SWIG_TMPOBJ ;
6949
6950 arg1 = &temp1;
6951 arg2 = &temp2;
6952 arg3 = &temp3;
6953 (void)self;
6954 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6955 plgcolbg(arg1,arg2,arg3);
6956 resultobj = SWIG_Py_Void();
6957 if (SWIG_IsTmpObj(res1)) {
6958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
6959 } else {
6960 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
6962 }
6963 if (SWIG_IsTmpObj(res2)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6968 }
6969 if (SWIG_IsTmpObj(res3)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6974 }
6975 return resultobj;
6976fail:
6977 return NULL;
6978}
6979
6980
6981SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6982 PyObject *resultobj = 0;
6983 PLINT *arg1 = (PLINT *) 0 ;
6984 PLINT *arg2 = (PLINT *) 0 ;
6985 PLINT *arg3 = (PLINT *) 0 ;
6986 PLFLT *arg4 = (PLFLT *) 0 ;
6987 PLINT temp1 ;
6988 int res1 = SWIG_TMPOBJ ;
6989 PLINT temp2 ;
6990 int res2 = SWIG_TMPOBJ ;
6991 PLINT temp3 ;
6992 int res3 = SWIG_TMPOBJ ;
6993 PLFLT temp4 ;
6994 int res4 = SWIG_TMPOBJ ;
6995
6996 arg1 = &temp1;
6997 arg2 = &temp2;
6998 arg3 = &temp3;
6999 arg4 = &temp4;
7000 (void)self;
7001 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
7002 plgcolbga(arg1,arg2,arg3,arg4);
7003 resultobj = SWIG_Py_Void();
7004 if (SWIG_IsTmpObj(res1)) {
7005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7006 } else {
7007 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7009 }
7010 if (SWIG_IsTmpObj(res2)) {
7011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7012 } else {
7013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7015 }
7016 if (SWIG_IsTmpObj(res3)) {
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7018 } else {
7019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7021 }
7022 if (SWIG_IsTmpObj(res4)) {
7023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7024 } else {
7025 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7027 }
7028 return resultobj;
7029fail:
7030 return NULL;
7031}
7032
7033
7034SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
7035 PyObject *resultobj = 0;
7036 PLINT *arg1 = (PLINT *) 0 ;
7037 PLINT temp1 ;
7038 int res1 = SWIG_TMPOBJ ;
7039
7040 arg1 = &temp1;
7041 (void)self;
7042 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7043 plgcompression(arg1);
7044 resultobj = SWIG_Py_Void();
7045 if (SWIG_IsTmpObj(res1)) {
7046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7047 } else {
7048 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7050 }
7051 return resultobj;
7052fail:
7053 return NULL;
7054}
7055
7056
7057SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7058 PyObject *resultobj = 0;
7059 char *arg1 = (char *) 0 ;
7060 char buff1[1000] ;
7061
7062 {
7063 arg1 = buff1;
7064 }
7065 (void)self;
7066 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7067 plgdev(arg1);
7068 resultobj = SWIG_Py_Void();
7069 {
7070 PyObject *o = PyString_FromString( arg1 );
7071 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7072 }
7073 return resultobj;
7074fail:
7075 return NULL;
7076}
7077
7078
7079SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7080 PyObject *resultobj = 0;
7081 PLFLT *arg1 = (PLFLT *) 0 ;
7082 PLFLT *arg2 = (PLFLT *) 0 ;
7083 PLFLT *arg3 = (PLFLT *) 0 ;
7084 PLFLT *arg4 = (PLFLT *) 0 ;
7085 PLFLT temp1 ;
7086 int res1 = SWIG_TMPOBJ ;
7087 PLFLT temp2 ;
7088 int res2 = SWIG_TMPOBJ ;
7089 PLFLT temp3 ;
7090 int res3 = SWIG_TMPOBJ ;
7091 PLFLT temp4 ;
7092 int res4 = SWIG_TMPOBJ ;
7093
7094 arg1 = &temp1;
7095 arg2 = &temp2;
7096 arg3 = &temp3;
7097 arg4 = &temp4;
7098 (void)self;
7099 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7100 plgdidev(arg1,arg2,arg3,arg4);
7101 resultobj = SWIG_Py_Void();
7102 if (SWIG_IsTmpObj(res1)) {
7103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7104 } else {
7105 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7107 }
7108 if (SWIG_IsTmpObj(res2)) {
7109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7110 } else {
7111 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7113 }
7114 if (SWIG_IsTmpObj(res3)) {
7115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7116 } else {
7117 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7119 }
7120 if (SWIG_IsTmpObj(res4)) {
7121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7122 } else {
7123 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7124 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7125 }
7126 return resultobj;
7127fail:
7128 return NULL;
7129}
7130
7131
7132SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7133 PyObject *resultobj = 0;
7134 PLFLT *arg1 = (PLFLT *) 0 ;
7135 PLFLT temp1 ;
7136 int res1 = SWIG_TMPOBJ ;
7137
7138 arg1 = &temp1;
7139 (void)self;
7140 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7141 plgdiori(arg1);
7142 resultobj = SWIG_Py_Void();
7143 if (SWIG_IsTmpObj(res1)) {
7144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7145 } else {
7146 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7148 }
7149 return resultobj;
7150fail:
7151 return NULL;
7152}
7153
7154
7155SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7156 PyObject *resultobj = 0;
7157 PLFLT *arg1 = (PLFLT *) 0 ;
7158 PLFLT *arg2 = (PLFLT *) 0 ;
7159 PLFLT *arg3 = (PLFLT *) 0 ;
7160 PLFLT *arg4 = (PLFLT *) 0 ;
7161 PLFLT temp1 ;
7162 int res1 = SWIG_TMPOBJ ;
7163 PLFLT temp2 ;
7164 int res2 = SWIG_TMPOBJ ;
7165 PLFLT temp3 ;
7166 int res3 = SWIG_TMPOBJ ;
7167 PLFLT temp4 ;
7168 int res4 = SWIG_TMPOBJ ;
7169
7170 arg1 = &temp1;
7171 arg2 = &temp2;
7172 arg3 = &temp3;
7173 arg4 = &temp4;
7174 (void)self;
7175 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7176 plgdiplt(arg1,arg2,arg3,arg4);
7177 resultobj = SWIG_Py_Void();
7178 if (SWIG_IsTmpObj(res1)) {
7179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7180 } else {
7181 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7183 }
7184 if (SWIG_IsTmpObj(res2)) {
7185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7186 } else {
7187 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7189 }
7190 if (SWIG_IsTmpObj(res3)) {
7191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7192 } else {
7193 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7195 }
7196 if (SWIG_IsTmpObj(res4)) {
7197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7198 } else {
7199 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7201 }
7202 return resultobj;
7203fail:
7204 return NULL;
7205}
7206
7207
7208SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7209 PyObject *resultobj = 0;
7210 PLINT *arg1 = (PLINT *) 0 ;
7211 PLINT *arg2 = (PLINT *) 0 ;
7212 PLINT *arg3 = (PLINT *) 0 ;
7213 PLINT temp1 ;
7214 int res1 = SWIG_TMPOBJ ;
7215 PLINT temp2 ;
7216 int res2 = SWIG_TMPOBJ ;
7217 PLINT temp3 ;
7218 int res3 = SWIG_TMPOBJ ;
7219
7220 arg1 = &temp1;
7221 arg2 = &temp2;
7222 arg3 = &temp3;
7223 (void)self;
7224 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7225 plgfam(arg1,arg2,arg3);
7226 resultobj = SWIG_Py_Void();
7227 if (SWIG_IsTmpObj(res1)) {
7228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7229 } else {
7230 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7232 }
7233 if (SWIG_IsTmpObj(res2)) {
7234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7235 } else {
7236 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7238 }
7239 if (SWIG_IsTmpObj(res3)) {
7240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7241 } else {
7242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7244 }
7245 return resultobj;
7246fail:
7247 return NULL;
7248}
7249
7250
7251SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7252 PyObject *resultobj = 0;
7253 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7254 PLUNICODE temp1 ;
7255 int res1 = SWIG_TMPOBJ ;
7256
7257 arg1 = &temp1;
7258 (void)self;
7259 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7260 plgfci(arg1);
7261 resultobj = SWIG_Py_Void();
7262 if (SWIG_IsTmpObj(res1)) {
7263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)), 1);
7264 } else {
7265 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags), 1);
7267 }
7268 return resultobj;
7269fail:
7270 return NULL;
7271}
7272
7273
7274SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7275 PyObject *resultobj = 0;
7276 char *arg1 = (char *) 0 ;
7277 char buff1[1000] ;
7278
7279 {
7280 arg1 = buff1;
7281 }
7282 (void)self;
7283 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7284 plgfnam(arg1);
7285 resultobj = SWIG_Py_Void();
7286 {
7287 PyObject *o = PyString_FromString( arg1 );
7288 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7289 }
7290 return resultobj;
7291fail:
7292 return NULL;
7293}
7294
7295
7296SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7297 PyObject *resultobj = 0;
7298 PLINT *arg1 = (PLINT *) 0 ;
7299 PLINT *arg2 = (PLINT *) 0 ;
7300 PLINT *arg3 = (PLINT *) 0 ;
7301 PLINT temp1 ;
7302 int res1 = SWIG_TMPOBJ ;
7303 PLINT temp2 ;
7304 int res2 = SWIG_TMPOBJ ;
7305 PLINT temp3 ;
7306 int res3 = SWIG_TMPOBJ ;
7307
7308 arg1 = &temp1;
7309 arg2 = &temp2;
7310 arg3 = &temp3;
7311 (void)self;
7312 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7313 plgfont(arg1,arg2,arg3);
7314 resultobj = SWIG_Py_Void();
7315 if (SWIG_IsTmpObj(res1)) {
7316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7317 } else {
7318 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7320 }
7321 if (SWIG_IsTmpObj(res2)) {
7322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7323 } else {
7324 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7326 }
7327 if (SWIG_IsTmpObj(res3)) {
7328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7329 } else {
7330 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7332 }
7333 return resultobj;
7334fail:
7335 return NULL;
7336}
7337
7338
7339SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7340 PyObject *resultobj = 0;
7341 PLINT *arg1 = (PLINT *) 0 ;
7342 PLINT temp1 ;
7343 int res1 = SWIG_TMPOBJ ;
7344
7345 arg1 = &temp1;
7346 (void)self;
7347 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7348 plglevel(arg1);
7349 resultobj = SWIG_Py_Void();
7350 if (SWIG_IsTmpObj(res1)) {
7351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7352 } else {
7353 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7355 }
7356 return resultobj;
7357fail:
7358 return NULL;
7359}
7360
7361
7362SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7363 PyObject *resultobj = 0;
7364 PLFLT *arg1 = (PLFLT *) 0 ;
7365 PLFLT *arg2 = (PLFLT *) 0 ;
7366 PLINT *arg3 = (PLINT *) 0 ;
7367 PLINT *arg4 = (PLINT *) 0 ;
7368 PLINT *arg5 = (PLINT *) 0 ;
7369 PLINT *arg6 = (PLINT *) 0 ;
7370 PLFLT temp1 ;
7371 int res1 = SWIG_TMPOBJ ;
7372 PLFLT temp2 ;
7373 int res2 = SWIG_TMPOBJ ;
7374 PLINT temp3 ;
7375 int res3 = SWIG_TMPOBJ ;
7376 PLINT temp4 ;
7377 int res4 = SWIG_TMPOBJ ;
7378 PLINT temp5 ;
7379 int res5 = SWIG_TMPOBJ ;
7380 PLINT temp6 ;
7381 int res6 = SWIG_TMPOBJ ;
7382
7383 arg1 = &temp1;
7384 arg2 = &temp2;
7385 arg3 = &temp3;
7386 arg4 = &temp4;
7387 arg5 = &temp5;
7388 arg6 = &temp6;
7389 (void)self;
7390 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7391 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7392 resultobj = SWIG_Py_Void();
7393 if (SWIG_IsTmpObj(res1)) {
7394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7395 } else {
7396 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7398 }
7399 if (SWIG_IsTmpObj(res2)) {
7400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7401 } else {
7402 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7404 }
7405 if (SWIG_IsTmpObj(res3)) {
7406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7407 } else {
7408 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7410 }
7411 if (SWIG_IsTmpObj(res4)) {
7412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
7413 } else {
7414 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
7416 }
7417 if (SWIG_IsTmpObj(res5)) {
7418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
7419 } else {
7420 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
7422 }
7423 if (SWIG_IsTmpObj(res6)) {
7424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
7425 } else {
7426 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
7428 }
7429 return resultobj;
7430fail:
7431 return NULL;
7432}
7433
7434
7435SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7436 PyObject *resultobj = 0;
7437
7438 (void)self;
7439 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7440 plgra();
7441 resultobj = SWIG_Py_Void();
7442 return resultobj;
7443fail:
7444 return NULL;
7445}
7446
7447
7448SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7449 PyObject *resultobj = 0;
7450 PLFLT *arg1 = (PLFLT *) 0 ;
7451 PLFLT *arg2 = (PLFLT *) 0 ;
7452 PLFLT *arg3 = (PLFLT *) 0 ;
7453 PLINT arg4 ;
7454 PLFLT *arg5 = (PLFLT *) 0 ;
7455 PLINT arg6 ;
7456 PLFLT *arg7 = (PLFLT *) 0 ;
7457 PLINT arg8 ;
7458 PLFLT **arg9 = (PLFLT **) 0 ;
7459 PLINT arg10 ;
7460 PLFLT arg11 ;
7461 PyArrayObject *tmp1 = NULL ;
7462 PyArrayObject *tmp2 = NULL ;
7463 PyArrayObject *tmp3 = NULL ;
7464 PyArrayObject *tmp5 = NULL ;
7465 PyArrayObject *tmp7 = NULL ;
7466 PyObject *array7 = NULL ;
7467 int val10 ;
7468 int ecode10 = 0 ;
7469 double val11 ;
7470 int ecode11 = 0 ;
7471 PyObject *swig_obj[7] ;
7472
7473 (void)self;
7474 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7475 {
7476 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7477 if ( tmp1 == NULL )
7478 return NULL;
7479 Alen = PyArray_DIMS( tmp1 )[0];
7480 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7481 }
7482 {
7483 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7484 if ( tmp2 == NULL )
7485 return NULL;
7486 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7487 {
7488 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7489 return NULL;
7490 }
7491 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7492 }
7493 {
7494 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7495 if ( tmp3 == NULL )
7496 return NULL;
7497 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7498 {
7499 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7500 return NULL;
7501 }
7502 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7503 arg4 = PyArray_DIMS( tmp3 )[0];
7504 }
7505 {
7506 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7507 if ( tmp5 == NULL )
7508 return NULL;
7509 Xlen = PyArray_DIMS( tmp5 )[0];
7510 arg6 = Xlen;
7511 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7512 }
7513 {
7514 int i, size;
7515 npy_intp dims[2];
7516 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7517 if ( tmp7 == NULL )
7518 return NULL;
7519 Ylen = PyArray_DIMS( tmp7 )[0];
7520 arg8 = Ylen;
7521 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7522 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7523 // list and this ArrayY.
7524 dims[0] = Xlen;
7525 dims[1] = Ylen;
7526 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7527 if ( !array7 )
7528 return NULL;
7529 size = Ylen;
7530 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7531 for ( i = 0; i < Xlen; i++ )
7532 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7533 }
7534 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7535 if (!SWIG_IsOK(ecode10)) {
7536 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7537 }
7538 arg10 = (PLINT)(val10);
7539 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7540 if (!SWIG_IsOK(ecode11)) {
7541 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7542 }
7543 arg11 = (PLFLT)(val11);
7544 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7545 resultobj = SWIG_Py_Void();
7546 {
7547 resultobj = SWIG_Python_AppendOutput(resultobj, array7, 1);
7548 }
7549 {
7550 Py_CLEAR( tmp1 );
7551 }
7552 {
7553 Py_CLEAR( tmp2 );
7554 }
7555 {
7556 Py_CLEAR( tmp3 );
7557 }
7558 {
7559 Py_CLEAR( tmp5 );
7560 }
7561 {
7562 Py_CLEAR( tmp7 );
7563 free( arg9 );
7564 }
7565 return resultobj;
7566fail:
7567 {
7568 Py_CLEAR( tmp1 );
7569 }
7570 {
7571 Py_CLEAR( tmp2 );
7572 }
7573 {
7574 Py_CLEAR( tmp3 );
7575 }
7576 {
7577 Py_CLEAR( tmp5 );
7578 }
7579 {
7580 Py_CLEAR( tmp7 );
7581 free( arg9 );
7582 }
7583 return NULL;
7584}
7585
7586
7587SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7588 PyObject *resultobj = 0;
7589 PLFLT *arg1 = (PLFLT *) 0 ;
7590 PLFLT *arg2 = (PLFLT *) 0 ;
7591 PLFLT *arg3 = (PLFLT *) 0 ;
7592 PLFLT *arg4 = (PLFLT *) 0 ;
7593 PLFLT temp1 ;
7594 int res1 = SWIG_TMPOBJ ;
7595 PLFLT temp2 ;
7596 int res2 = SWIG_TMPOBJ ;
7597 PLFLT temp3 ;
7598 int res3 = SWIG_TMPOBJ ;
7599 PLFLT temp4 ;
7600 int res4 = SWIG_TMPOBJ ;
7601
7602 arg1 = &temp1;
7603 arg2 = &temp2;
7604 arg3 = &temp3;
7605 arg4 = &temp4;
7606 (void)self;
7607 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7608 plgspa(arg1,arg2,arg3,arg4);
7609 resultobj = SWIG_Py_Void();
7610 if (SWIG_IsTmpObj(res1)) {
7611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7612 } else {
7613 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7615 }
7616 if (SWIG_IsTmpObj(res2)) {
7617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7618 } else {
7619 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7621 }
7622 if (SWIG_IsTmpObj(res3)) {
7623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7624 } else {
7625 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7627 }
7628 if (SWIG_IsTmpObj(res4)) {
7629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7630 } else {
7631 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7633 }
7634 return resultobj;
7635fail:
7636 return NULL;
7637}
7638
7639
7640SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7641 PyObject *resultobj = 0;
7642 PLINT *arg1 = (PLINT *) 0 ;
7643 PLINT temp1 ;
7644 int res1 = SWIG_TMPOBJ ;
7645
7646 arg1 = &temp1;
7647 (void)self;
7648 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7649 plgstrm(arg1);
7650 resultobj = SWIG_Py_Void();
7651 if (SWIG_IsTmpObj(res1)) {
7652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7653 } else {
7654 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7656 }
7657 return resultobj;
7658fail:
7659 return NULL;
7660}
7661
7662
7663SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7664 PyObject *resultobj = 0;
7665 char *arg1 = (char *) 0 ;
7666 char buff1[1000] ;
7667
7668 {
7669 arg1 = buff1;
7670 }
7671 (void)self;
7672 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7673 plgver(arg1);
7674 resultobj = SWIG_Py_Void();
7675 {
7676 PyObject *o = PyString_FromString( arg1 );
7677 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7678 }
7679 return resultobj;
7680fail:
7681 return NULL;
7682}
7683
7684
7685SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7686 PyObject *resultobj = 0;
7687 PLFLT *arg1 = (PLFLT *) 0 ;
7688 PLFLT *arg2 = (PLFLT *) 0 ;
7689 PLFLT *arg3 = (PLFLT *) 0 ;
7690 PLFLT *arg4 = (PLFLT *) 0 ;
7691 PLFLT temp1 ;
7692 int res1 = SWIG_TMPOBJ ;
7693 PLFLT temp2 ;
7694 int res2 = SWIG_TMPOBJ ;
7695 PLFLT temp3 ;
7696 int res3 = SWIG_TMPOBJ ;
7697 PLFLT temp4 ;
7698 int res4 = SWIG_TMPOBJ ;
7699
7700 arg1 = &temp1;
7701 arg2 = &temp2;
7702 arg3 = &temp3;
7703 arg4 = &temp4;
7704 (void)self;
7705 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7706 plgvpd(arg1,arg2,arg3,arg4);
7707 resultobj = SWIG_Py_Void();
7708 if (SWIG_IsTmpObj(res1)) {
7709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7710 } else {
7711 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7713 }
7714 if (SWIG_IsTmpObj(res2)) {
7715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7716 } else {
7717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7719 }
7720 if (SWIG_IsTmpObj(res3)) {
7721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7722 } else {
7723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7725 }
7726 if (SWIG_IsTmpObj(res4)) {
7727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7728 } else {
7729 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7731 }
7732 return resultobj;
7733fail:
7734 return NULL;
7735}
7736
7737
7738SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7739 PyObject *resultobj = 0;
7740 PLFLT *arg1 = (PLFLT *) 0 ;
7741 PLFLT *arg2 = (PLFLT *) 0 ;
7742 PLFLT *arg3 = (PLFLT *) 0 ;
7743 PLFLT *arg4 = (PLFLT *) 0 ;
7744 PLFLT temp1 ;
7745 int res1 = SWIG_TMPOBJ ;
7746 PLFLT temp2 ;
7747 int res2 = SWIG_TMPOBJ ;
7748 PLFLT temp3 ;
7749 int res3 = SWIG_TMPOBJ ;
7750 PLFLT temp4 ;
7751 int res4 = SWIG_TMPOBJ ;
7752
7753 arg1 = &temp1;
7754 arg2 = &temp2;
7755 arg3 = &temp3;
7756 arg4 = &temp4;
7757 (void)self;
7758 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7759 plgvpw(arg1,arg2,arg3,arg4);
7760 resultobj = SWIG_Py_Void();
7761 if (SWIG_IsTmpObj(res1)) {
7762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7763 } else {
7764 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7766 }
7767 if (SWIG_IsTmpObj(res2)) {
7768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7769 } else {
7770 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7772 }
7773 if (SWIG_IsTmpObj(res3)) {
7774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7775 } else {
7776 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7778 }
7779 if (SWIG_IsTmpObj(res4)) {
7780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7781 } else {
7782 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7784 }
7785 return resultobj;
7786fail:
7787 return NULL;
7788}
7789
7790
7791SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7792 PyObject *resultobj = 0;
7793 PLINT *arg1 = (PLINT *) 0 ;
7794 PLINT *arg2 = (PLINT *) 0 ;
7795 PLINT temp1 ;
7796 int res1 = SWIG_TMPOBJ ;
7797 PLINT temp2 ;
7798 int res2 = SWIG_TMPOBJ ;
7799
7800 arg1 = &temp1;
7801 arg2 = &temp2;
7802 (void)self;
7803 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7804 plgxax(arg1,arg2);
7805 resultobj = SWIG_Py_Void();
7806 if (SWIG_IsTmpObj(res1)) {
7807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7808 } else {
7809 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7811 }
7812 if (SWIG_IsTmpObj(res2)) {
7813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7814 } else {
7815 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7817 }
7818 return resultobj;
7819fail:
7820 return NULL;
7821}
7822
7823
7824SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7825 PyObject *resultobj = 0;
7826 PLINT *arg1 = (PLINT *) 0 ;
7827 PLINT *arg2 = (PLINT *) 0 ;
7828 PLINT temp1 ;
7829 int res1 = SWIG_TMPOBJ ;
7830 PLINT temp2 ;
7831 int res2 = SWIG_TMPOBJ ;
7832
7833 arg1 = &temp1;
7834 arg2 = &temp2;
7835 (void)self;
7836 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7837 plgyax(arg1,arg2);
7838 resultobj = SWIG_Py_Void();
7839 if (SWIG_IsTmpObj(res1)) {
7840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7841 } else {
7842 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7844 }
7845 if (SWIG_IsTmpObj(res2)) {
7846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7847 } else {
7848 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7850 }
7851 return resultobj;
7852fail:
7853 return NULL;
7854}
7855
7856
7857SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7858 PyObject *resultobj = 0;
7859 PLINT *arg1 = (PLINT *) 0 ;
7860 PLINT *arg2 = (PLINT *) 0 ;
7861 PLINT temp1 ;
7862 int res1 = SWIG_TMPOBJ ;
7863 PLINT temp2 ;
7864 int res2 = SWIG_TMPOBJ ;
7865
7866 arg1 = &temp1;
7867 arg2 = &temp2;
7868 (void)self;
7869 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7870 plgzax(arg1,arg2);
7871 resultobj = SWIG_Py_Void();
7872 if (SWIG_IsTmpObj(res1)) {
7873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7874 } else {
7875 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7877 }
7878 if (SWIG_IsTmpObj(res2)) {
7879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7880 } else {
7881 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7883 }
7884 return resultobj;
7885fail:
7886 return NULL;
7887}
7888
7889
7890SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7891 PyObject *resultobj = 0;
7892 PLINT arg1 ;
7893 PLFLT *arg2 = (PLFLT *) 0 ;
7894 PLFLT arg3 ;
7895 PLFLT arg4 ;
7896 PLINT arg5 ;
7897 PLINT arg6 ;
7898 PyArrayObject *tmp1 = NULL ;
7899 double val3 ;
7900 int ecode3 = 0 ;
7901 double val4 ;
7902 int ecode4 = 0 ;
7903 int val5 ;
7904 int ecode5 = 0 ;
7905 int val6 ;
7906 int ecode6 = 0 ;
7907 PyObject *swig_obj[5] ;
7908
7909 (void)self;
7910 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7911 {
7912 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7913 if ( tmp1 == NULL )
7914 return NULL;
7915 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7916 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7917 }
7918 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7919 if (!SWIG_IsOK(ecode3)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7921 }
7922 arg3 = (PLFLT)(val3);
7923 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7924 if (!SWIG_IsOK(ecode4)) {
7925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7926 }
7927 arg4 = (PLFLT)(val4);
7928 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7929 if (!SWIG_IsOK(ecode5)) {
7930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7931 }
7932 arg5 = (PLINT)(val5);
7933 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7934 if (!SWIG_IsOK(ecode6)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7936 }
7937 arg6 = (PLINT)(val6);
7938 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7939 resultobj = SWIG_Py_Void();
7940 {
7941 Py_CLEAR( tmp1 );
7942 }
7943 return resultobj;
7944fail:
7945 {
7946 Py_CLEAR( tmp1 );
7947 }
7948 return NULL;
7949}
7950
7951
7952SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7953 PyObject *resultobj = 0;
7954 PLFLT arg1 ;
7955 PLFLT arg2 ;
7956 PLFLT arg3 ;
7957 PLFLT *arg4 = (PLFLT *) 0 ;
7958 PLFLT *arg5 = (PLFLT *) 0 ;
7959 PLFLT *arg6 = (PLFLT *) 0 ;
7960 double val1 ;
7961 int ecode1 = 0 ;
7962 double val2 ;
7963 int ecode2 = 0 ;
7964 double val3 ;
7965 int ecode3 = 0 ;
7966 PLFLT temp4 ;
7967 int res4 = SWIG_TMPOBJ ;
7968 PLFLT temp5 ;
7969 int res5 = SWIG_TMPOBJ ;
7970 PLFLT temp6 ;
7971 int res6 = SWIG_TMPOBJ ;
7972 PyObject *swig_obj[3] ;
7973
7974 arg4 = &temp4;
7975 arg5 = &temp5;
7976 arg6 = &temp6;
7977 (void)self;
7978 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7979 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7980 if (!SWIG_IsOK(ecode1)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7982 }
7983 arg1 = (PLFLT)(val1);
7984 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7985 if (!SWIG_IsOK(ecode2)) {
7986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7987 }
7988 arg2 = (PLFLT)(val2);
7989 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7990 if (!SWIG_IsOK(ecode3)) {
7991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7992 }
7993 arg3 = (PLFLT)(val3);
7994 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7995 resultobj = SWIG_Py_Void();
7996 if (SWIG_IsTmpObj(res4)) {
7997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7998 } else {
7999 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
8001 }
8002 if (SWIG_IsTmpObj(res5)) {
8003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
8004 } else {
8005 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
8007 }
8008 if (SWIG_IsTmpObj(res6)) {
8009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
8010 } else {
8011 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
8013 }
8014 return resultobj;
8015fail:
8016 return NULL;
8017}
8018
8019
8020SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
8021 PyObject *resultobj = 0;
8022
8023 (void)self;
8024 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
8025 plinit();
8026 resultobj = SWIG_Py_Void();
8027 return resultobj;
8028fail:
8029 return NULL;
8030}
8031
8032
8033SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
8034 PyObject *resultobj = 0;
8035 PLFLT arg1 ;
8036 PLFLT arg2 ;
8037 PLFLT arg3 ;
8038 PLFLT arg4 ;
8039 double val1 ;
8040 int ecode1 = 0 ;
8041 double val2 ;
8042 int ecode2 = 0 ;
8043 double val3 ;
8044 int ecode3 = 0 ;
8045 double val4 ;
8046 int ecode4 = 0 ;
8047 PyObject *swig_obj[4] ;
8048
8049 (void)self;
8050 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8051 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8052 if (!SWIG_IsOK(ecode1)) {
8053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8054 }
8055 arg1 = (PLFLT)(val1);
8056 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8057 if (!SWIG_IsOK(ecode2)) {
8058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8059 }
8060 arg2 = (PLFLT)(val2);
8061 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8062 if (!SWIG_IsOK(ecode3)) {
8063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8064 }
8065 arg3 = (PLFLT)(val3);
8066 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8067 if (!SWIG_IsOK(ecode4)) {
8068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8069 }
8070 arg4 = (PLFLT)(val4);
8071 pljoin(arg1,arg2,arg3,arg4);
8072 resultobj = SWIG_Py_Void();
8073 return resultobj;
8074fail:
8075 return NULL;
8076}
8077
8078
8079SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8080 PyObject *resultobj = 0;
8081 char *arg1 = (char *) 0 ;
8082 char *arg2 = (char *) 0 ;
8083 char *arg3 = (char *) 0 ;
8084 int res1 ;
8085 char *buf1 = 0 ;
8086 int alloc1 = 0 ;
8087 int res2 ;
8088 char *buf2 = 0 ;
8089 int alloc2 = 0 ;
8090 int res3 ;
8091 char *buf3 = 0 ;
8092 int alloc3 = 0 ;
8093 PyObject *swig_obj[3] ;
8094
8095 (void)self;
8096 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8097 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8098 if (!SWIG_IsOK(res1)) {
8099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8100 }
8101 arg1 = (char *)(buf1);
8102 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8103 if (!SWIG_IsOK(res2)) {
8104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8105 }
8106 arg2 = (char *)(buf2);
8107 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8108 if (!SWIG_IsOK(res3)) {
8109 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8110 }
8111 arg3 = (char *)(buf3);
8112 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8113 resultobj = SWIG_Py_Void();
8114 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8115 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8116 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8117 return resultobj;
8118fail:
8119 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8120 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8121 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8122 return NULL;
8123}
8124
8125
8126SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8127 PyObject *resultobj = 0;
8128 PLFLT *arg1 = (PLFLT *) 0 ;
8129 PLFLT *arg2 = (PLFLT *) 0 ;
8130 PLINT arg3 ;
8131 PLINT arg4 ;
8132 PLFLT arg5 ;
8133 PLFLT arg6 ;
8134 PLFLT arg7 ;
8135 PLINT arg8 ;
8136 PLINT arg9 ;
8137 PLINT arg10 ;
8138 PLINT arg11 ;
8139 PLINT arg12 ;
8140 PLINT arg13 ;
8141 PLINT *arg14 = (PLINT *) 0 ;
8142 PLFLT arg15 ;
8143 PLFLT arg16 ;
8144 PLFLT arg17 ;
8145 PLFLT arg18 ;
8146 PLINT *arg19 = (PLINT *) 0 ;
8147 char **arg20 = (char **) 0 ;
8148 PLINT *arg21 = (PLINT *) 0 ;
8149 PLINT *arg22 = (PLINT *) 0 ;
8150 PLFLT *arg23 = (PLFLT *) 0 ;
8151 PLFLT *arg24 = (PLFLT *) 0 ;
8152 PLINT *arg25 = (PLINT *) 0 ;
8153 PLINT *arg26 = (PLINT *) 0 ;
8154 PLFLT *arg27 = (PLFLT *) 0 ;
8155 PLINT *arg28 = (PLINT *) 0 ;
8156 PLFLT *arg29 = (PLFLT *) 0 ;
8157 PLINT *arg30 = (PLINT *) 0 ;
8158 char **arg31 = (char **) 0 ;
8159 PLFLT temp1 ;
8160 int res1 = SWIG_TMPOBJ ;
8161 PLFLT temp2 ;
8162 int res2 = SWIG_TMPOBJ ;
8163 int val3 ;
8164 int ecode3 = 0 ;
8165 int val4 ;
8166 int ecode4 = 0 ;
8167 double val5 ;
8168 int ecode5 = 0 ;
8169 double val6 ;
8170 int ecode6 = 0 ;
8171 double val7 ;
8172 int ecode7 = 0 ;
8173 int val8 ;
8174 int ecode8 = 0 ;
8175 int val9 ;
8176 int ecode9 = 0 ;
8177 int val10 ;
8178 int ecode10 = 0 ;
8179 int val11 ;
8180 int ecode11 = 0 ;
8181 int val12 ;
8182 int ecode12 = 0 ;
8183 PyArrayObject *tmp13 = NULL ;
8184 double val15 ;
8185 int ecode15 = 0 ;
8186 double val16 ;
8187 int ecode16 = 0 ;
8188 double val17 ;
8189 int ecode17 = 0 ;
8190 double val18 ;
8191 int ecode18 = 0 ;
8192 PyArrayObject *tmp19 = NULL ;
8193 PyArrayObject *tmp20 = NULL ;
8194 PyArrayObject *tmp21 = NULL ;
8195 PyArrayObject *tmp22 = NULL ;
8196 PyArrayObject *tmp23 = NULL ;
8197 PyArrayObject *tmp24 = NULL ;
8198 PyArrayObject *tmp25 = NULL ;
8199 PyArrayObject *tmp26 = NULL ;
8200 PyArrayObject *tmp27 = NULL ;
8201 PyArrayObject *tmp28 = NULL ;
8202 PyArrayObject *tmp29 = NULL ;
8203 PyArrayObject *tmp30 = NULL ;
8204 PyArrayObject *tmp31 = NULL ;
8205 PyObject *swig_obj[28] ;
8206
8207 arg1 = &temp1;
8208 arg2 = &temp2;
8209 (void)self;
8210 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8211 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8212 if (!SWIG_IsOK(ecode3)) {
8213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8214 }
8215 arg3 = (PLINT)(val3);
8216 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8217 if (!SWIG_IsOK(ecode4)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8219 }
8220 arg4 = (PLINT)(val4);
8221 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8222 if (!SWIG_IsOK(ecode5)) {
8223 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8224 }
8225 arg5 = (PLFLT)(val5);
8226 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8227 if (!SWIG_IsOK(ecode6)) {
8228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8229 }
8230 arg6 = (PLFLT)(val6);
8231 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8232 if (!SWIG_IsOK(ecode7)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8234 }
8235 arg7 = (PLFLT)(val7);
8236 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8237 if (!SWIG_IsOK(ecode8)) {
8238 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8239 }
8240 arg8 = (PLINT)(val8);
8241 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8242 if (!SWIG_IsOK(ecode9)) {
8243 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8244 }
8245 arg9 = (PLINT)(val9);
8246 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8247 if (!SWIG_IsOK(ecode10)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8249 }
8250 arg10 = (PLINT)(val10);
8251 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8252 if (!SWIG_IsOK(ecode11)) {
8253 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8254 }
8255 arg11 = (PLINT)(val11);
8256 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8257 if (!SWIG_IsOK(ecode12)) {
8258 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8259 }
8260 arg12 = (PLINT)(val12);
8261 {
8262 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8263 if ( tmp13 == NULL )
8264 return NULL;
8265 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8266 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8267 }
8268 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8269 if (!SWIG_IsOK(ecode15)) {
8270 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8271 }
8272 arg15 = (PLFLT)(val15);
8273 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8274 if (!SWIG_IsOK(ecode16)) {
8275 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8276 }
8277 arg16 = (PLFLT)(val16);
8278 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8279 if (!SWIG_IsOK(ecode17)) {
8280 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8281 }
8282 arg17 = (PLFLT)(val17);
8283 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8284 if (!SWIG_IsOK(ecode18)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8286 }
8287 arg18 = (PLFLT)(val18);
8288 {
8289 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8290 if ( tmp19 == NULL )
8291 return NULL;
8292 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8293 {
8294 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8295 return NULL;
8296 }
8297 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8298 }
8299 {
8300 int i;
8301 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8302 if ( tmp20 == NULL )
8303 return NULL;
8304 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8305 {
8306 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8307 return NULL;
8308 }
8309 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8310 for ( i = 0; i < Alen; i++ )
8311 {
8312 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8313 if ( arg20[i] == NULL )
8314 {
8315 free( arg20 );
8316 return NULL;
8317 }
8318 }
8319 }
8320 {
8321 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8322 if ( tmp21 == NULL )
8323 return NULL;
8324 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8325 {
8326 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8327 return NULL;
8328 }
8329 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8330 }
8331 {
8332 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8333 if ( tmp22 == NULL )
8334 return NULL;
8335 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8336 {
8337 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8338 return NULL;
8339 }
8340 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8341 }
8342 {
8343 if ( swig_obj[19] != Py_None )
8344 {
8345 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8346 if ( tmp23 == NULL )
8347 return NULL;
8348 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8349 {
8350 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8351 return NULL;
8352 }
8353 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8354 }
8355 else
8356 {
8357 arg23 = NULL;
8358 }
8359 }
8360 {
8361 if ( swig_obj[20] != Py_None )
8362 {
8363 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8364 if ( tmp24 == NULL )
8365 return NULL;
8366 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8367 {
8368 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8369 return NULL;
8370 }
8371 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8372 }
8373 else
8374 {
8375 arg24 = NULL;
8376 }
8377 }
8378 {
8379 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8380 if ( tmp25 == NULL )
8381 return NULL;
8382 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8383 {
8384 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8385 return NULL;
8386 }
8387 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8388 }
8389 {
8390 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8391 if ( tmp26 == NULL )
8392 return NULL;
8393 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8394 {
8395 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8396 return NULL;
8397 }
8398 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8399 }
8400 {
8401 if ( swig_obj[23] != Py_None )
8402 {
8403 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8404 if ( tmp27 == NULL )
8405 return NULL;
8406 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8407 {
8408 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8409 return NULL;
8410 }
8411 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8412 }
8413 else
8414 {
8415 arg27 = NULL;
8416 }
8417 }
8418 {
8419 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8420 if ( tmp28 == NULL )
8421 return NULL;
8422 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8423 {
8424 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8425 return NULL;
8426 }
8427 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8428 }
8429 {
8430 if ( swig_obj[25] != Py_None )
8431 {
8432 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8433 if ( tmp29 == NULL )
8434 return NULL;
8435 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8436 {
8437 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8438 return NULL;
8439 }
8440 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8441 }
8442 else
8443 {
8444 arg29 = NULL;
8445 }
8446 }
8447 {
8448 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8449 if ( tmp30 == NULL )
8450 return NULL;
8451 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8452 {
8453 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8454 return NULL;
8455 }
8456 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8457 }
8458 {
8459 int i;
8460 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8461 if ( tmp31 == NULL )
8462 return NULL;
8463 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8464 {
8465 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8466 return NULL;
8467 }
8468 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8469 for ( i = 0; i < Alen; i++ )
8470 {
8471 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8472 if ( arg31[i] == NULL )
8473 {
8474 free( arg31 );
8475 return NULL;
8476 }
8477 }
8478 }
8479 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);
8480 resultobj = SWIG_Py_Void();
8481 if (SWIG_IsTmpObj(res1)) {
8482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8483 } else {
8484 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8486 }
8487 if (SWIG_IsTmpObj(res2)) {
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8489 } else {
8490 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8492 }
8493 {
8494 Py_CLEAR( tmp13 );
8495 }
8496 {
8497 Py_CLEAR( tmp19 );
8498 }
8499 {
8500 Py_CLEAR( tmp20 ); free( arg20 );
8501 }
8502 {
8503 Py_CLEAR( tmp21 );
8504 }
8505 {
8506 Py_CLEAR( tmp22 );
8507 }
8508 {
8509 Py_CLEAR( tmp23 );
8510 }
8511 {
8512 Py_CLEAR( tmp24 );
8513 }
8514 {
8515 Py_CLEAR( tmp25 );
8516 }
8517 {
8518 Py_CLEAR( tmp26 );
8519 }
8520 {
8521 Py_CLEAR( tmp27 );
8522 }
8523 {
8524 Py_CLEAR( tmp28 );
8525 }
8526 {
8527 Py_CLEAR( tmp29 );
8528 }
8529 {
8530 Py_CLEAR( tmp30 );
8531 }
8532 {
8533 Py_CLEAR( tmp31 ); free( arg31 );
8534 }
8535 return resultobj;
8536fail:
8537 {
8538 Py_CLEAR( tmp13 );
8539 }
8540 {
8541 Py_CLEAR( tmp19 );
8542 }
8543 {
8544 Py_CLEAR( tmp20 ); free( arg20 );
8545 }
8546 {
8547 Py_CLEAR( tmp21 );
8548 }
8549 {
8550 Py_CLEAR( tmp22 );
8551 }
8552 {
8553 Py_CLEAR( tmp23 );
8554 }
8555 {
8556 Py_CLEAR( tmp24 );
8557 }
8558 {
8559 Py_CLEAR( tmp25 );
8560 }
8561 {
8562 Py_CLEAR( tmp26 );
8563 }
8564 {
8565 Py_CLEAR( tmp27 );
8566 }
8567 {
8568 Py_CLEAR( tmp28 );
8569 }
8570 {
8571 Py_CLEAR( tmp29 );
8572 }
8573 {
8574 Py_CLEAR( tmp30 );
8575 }
8576 {
8577 Py_CLEAR( tmp31 ); free( arg31 );
8578 }
8579 return NULL;
8580}
8581
8582
8583SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8584 PyObject *resultobj = 0;
8585 PLFLT *arg1 = (PLFLT *) 0 ;
8586 PLFLT *arg2 = (PLFLT *) 0 ;
8587 PLINT arg3 ;
8588 PLINT arg4 ;
8589 PLFLT arg5 ;
8590 PLFLT arg6 ;
8591 PLFLT arg7 ;
8592 PLFLT arg8 ;
8593 PLINT arg9 ;
8594 PLINT arg10 ;
8595 PLINT arg11 ;
8596 PLFLT arg12 ;
8597 PLFLT arg13 ;
8598 PLINT arg14 ;
8599 PLFLT arg15 ;
8600 PLINT arg16 ;
8601 PLINT *arg17 = (PLINT *) 0 ;
8602 char **arg18 = (char **) 0 ;
8603 PLINT arg19 ;
8604 char **arg20 = (char **) 0 ;
8605 PLFLT *arg21 = (PLFLT *) 0 ;
8606 PLINT *arg22 = (PLINT *) 0 ;
8607 PLINT *arg23 = (PLINT *) 0 ;
8608 PLFLT **arg24 = (PLFLT **) 0 ;
8609 PLFLT temp1 ;
8610 int res1 = SWIG_TMPOBJ ;
8611 PLFLT temp2 ;
8612 int res2 = SWIG_TMPOBJ ;
8613 int val3 ;
8614 int ecode3 = 0 ;
8615 int val4 ;
8616 int ecode4 = 0 ;
8617 double val5 ;
8618 int ecode5 = 0 ;
8619 double val6 ;
8620 int ecode6 = 0 ;
8621 double val7 ;
8622 int ecode7 = 0 ;
8623 double val8 ;
8624 int ecode8 = 0 ;
8625 int val9 ;
8626 int ecode9 = 0 ;
8627 int val10 ;
8628 int ecode10 = 0 ;
8629 int val11 ;
8630 int ecode11 = 0 ;
8631 double val12 ;
8632 int ecode12 = 0 ;
8633 double val13 ;
8634 int ecode13 = 0 ;
8635 int val14 ;
8636 int ecode14 = 0 ;
8637 double val15 ;
8638 int ecode15 = 0 ;
8639 PyArrayObject *tmp16 = NULL ;
8640 PyArrayObject *tmp18 = NULL ;
8641 PyArrayObject *tmp19 = NULL ;
8642 PyArrayObject *tmp21 = NULL ;
8643 PyArrayObject *tmp22 = NULL ;
8644 PyArrayObject *tmp23 = NULL ;
8645 PyArrayObject *tmp24 = NULL ;
8646 PyObject *swig_obj[20] ;
8647
8648 arg1 = &temp1;
8649 arg2 = &temp2;
8650 (void)self;
8651 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8652 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8653 if (!SWIG_IsOK(ecode3)) {
8654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8655 }
8656 arg3 = (PLINT)(val3);
8657 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8658 if (!SWIG_IsOK(ecode4)) {
8659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8660 }
8661 arg4 = (PLINT)(val4);
8662 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8663 if (!SWIG_IsOK(ecode5)) {
8664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8665 }
8666 arg5 = (PLFLT)(val5);
8667 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8668 if (!SWIG_IsOK(ecode6)) {
8669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8670 }
8671 arg6 = (PLFLT)(val6);
8672 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8673 if (!SWIG_IsOK(ecode7)) {
8674 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8675 }
8676 arg7 = (PLFLT)(val7);
8677 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8678 if (!SWIG_IsOK(ecode8)) {
8679 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8680 }
8681 arg8 = (PLFLT)(val8);
8682 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8683 if (!SWIG_IsOK(ecode9)) {
8684 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8685 }
8686 arg9 = (PLINT)(val9);
8687 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8688 if (!SWIG_IsOK(ecode10)) {
8689 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8690 }
8691 arg10 = (PLINT)(val10);
8692 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8693 if (!SWIG_IsOK(ecode11)) {
8694 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8695 }
8696 arg11 = (PLINT)(val11);
8697 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8698 if (!SWIG_IsOK(ecode12)) {
8699 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8700 }
8701 arg12 = (PLFLT)(val12);
8702 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8703 if (!SWIG_IsOK(ecode13)) {
8704 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8705 }
8706 arg13 = (PLFLT)(val13);
8707 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8708 if (!SWIG_IsOK(ecode14)) {
8709 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8710 }
8711 arg14 = (PLINT)(val14);
8712 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8713 if (!SWIG_IsOK(ecode15)) {
8714 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8715 }
8716 arg15 = (PLFLT)(val15);
8717 {
8718 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8719 if ( tmp16 == NULL )
8720 return NULL;
8721 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8722 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8723 }
8724 {
8725 int i;
8726 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8727 if ( tmp18 == NULL )
8728 return NULL;
8729 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8730 {
8731 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8732 return NULL;
8733 }
8734 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8735 for ( i = 0; i < Alen; i++ )
8736 {
8737 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8738 if ( arg18[i] == NULL )
8739 {
8740 free( arg18 );
8741 return NULL;
8742 }
8743 }
8744 }
8745 {
8746 int i;
8747 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8748 if ( tmp19 == NULL )
8749 return NULL;
8750 Alen = PyArray_DIMS( tmp19 )[0];
8751 arg19 = Alen;
8752 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8753 for ( i = 0; i < Alen; i++ )
8754 {
8755 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8756 if ( arg20[i] == NULL )
8757 {
8758 free( arg20 );
8759 return NULL;
8760 }
8761 }
8762 }
8763 {
8764 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8765 if ( tmp21 == NULL )
8766 return NULL;
8767 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8768 {
8769 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8770 return NULL;
8771 }
8772 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8773 }
8774 {
8775 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8776 if ( tmp22 == NULL )
8777 return NULL;
8778 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8779 {
8780 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8781 return NULL;
8782 }
8783 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8784 }
8785 {
8786 int i;
8787 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8788 if ( tmp23 == NULL )
8789 return NULL;
8790 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8791 {
8792 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8793 return NULL;
8794 }
8795 Xlen = PyArray_DIMS( tmp23 )[0];
8796 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8797 Ylen = -1;
8798 for ( i = 0; i < Xlen; i++ )
8799 if ( arg23[i] > Ylen )
8800 Ylen = arg23[i];
8801 }
8802 {
8803 int i, size;
8804 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8805 if ( tmp24 == NULL )
8806 return NULL;
8807 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8808 {
8809 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8810 return NULL;
8811 }
8812 size = Ylen;
8813 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8814 for ( i = 0; i < Xlen; i++ )
8815 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8816 }
8817 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);
8818 resultobj = SWIG_Py_Void();
8819 if (SWIG_IsTmpObj(res1)) {
8820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8821 } else {
8822 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8824 }
8825 if (SWIG_IsTmpObj(res2)) {
8826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8827 } else {
8828 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8830 }
8831 {
8832 Py_CLEAR( tmp16 );
8833 }
8834 {
8835 Py_CLEAR( tmp18 ); free( arg18 );
8836 }
8837 {
8838 Py_CLEAR( tmp19 ); free( arg20 );
8839 }
8840 {
8841 Py_CLEAR( tmp21 );
8842 }
8843 {
8844 Py_CLEAR( tmp22 );
8845 }
8846 {
8847 Py_CLEAR( tmp23 );
8848 }
8849 {
8850 Py_CLEAR( tmp24 );
8851 free( arg24 );
8852 }
8853 return resultobj;
8854fail:
8855 {
8856 Py_CLEAR( tmp16 );
8857 }
8858 {
8859 Py_CLEAR( tmp18 ); free( arg18 );
8860 }
8861 {
8862 Py_CLEAR( tmp19 ); free( arg20 );
8863 }
8864 {
8865 Py_CLEAR( tmp21 );
8866 }
8867 {
8868 Py_CLEAR( tmp22 );
8869 }
8870 {
8871 Py_CLEAR( tmp23 );
8872 }
8873 {
8874 Py_CLEAR( tmp24 );
8875 free( arg24 );
8876 }
8877 return NULL;
8878}
8879
8880
8881SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8882 PyObject *resultobj = 0;
8883 PLFLT arg1 ;
8884 PLFLT arg2 ;
8885 PLFLT arg3 ;
8886 double val1 ;
8887 int ecode1 = 0 ;
8888 double val2 ;
8889 int ecode2 = 0 ;
8890 double val3 ;
8891 int ecode3 = 0 ;
8892 PyObject *swig_obj[3] ;
8893
8894 (void)self;
8895 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8896 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8897 if (!SWIG_IsOK(ecode1)) {
8898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8899 }
8900 arg1 = (PLFLT)(val1);
8901 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8902 if (!SWIG_IsOK(ecode2)) {
8903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8904 }
8905 arg2 = (PLFLT)(val2);
8906 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8907 if (!SWIG_IsOK(ecode3)) {
8908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8909 }
8910 arg3 = (PLFLT)(val3);
8911 pllightsource(arg1,arg2,arg3);
8912 resultobj = SWIG_Py_Void();
8913 return resultobj;
8914fail:
8915 return NULL;
8916}
8917
8918
8919SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8920 PyObject *resultobj = 0;
8921 PLINT arg1 ;
8922 PLFLT *arg2 = (PLFLT *) 0 ;
8923 PLFLT *arg3 = (PLFLT *) 0 ;
8924 PyArrayObject *tmp1 = NULL ;
8925 PyArrayObject *tmp3 = NULL ;
8926 PyObject *swig_obj[2] ;
8927
8928 (void)self;
8929 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8930 {
8931 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8932 if ( tmp1 == NULL )
8933 return NULL;
8934 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8935 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8936 }
8937 {
8938 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8939 if ( tmp3 == NULL )
8940 return NULL;
8941 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8942 {
8943 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8944 return NULL;
8945 }
8946 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8947 }
8948 plline(arg1,(double const *)arg2,(double const *)arg3);
8949 resultobj = SWIG_Py_Void();
8950 {
8951 Py_CLEAR( tmp1 );
8952 }
8953 {
8954 Py_CLEAR( tmp3 );
8955 }
8956 return resultobj;
8957fail:
8958 {
8959 Py_CLEAR( tmp1 );
8960 }
8961 {
8962 Py_CLEAR( tmp3 );
8963 }
8964 return NULL;
8965}
8966
8967
8968SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8969 PyObject *resultobj = 0;
8970 PLINT arg1 ;
8971 PLFLT *arg2 = (PLFLT *) 0 ;
8972 PLFLT *arg3 = (PLFLT *) 0 ;
8973 PLFLT *arg4 = (PLFLT *) 0 ;
8974 PyArrayObject *tmp1 = NULL ;
8975 PyArrayObject *tmp3 = NULL ;
8976 PyArrayObject *tmp4 = NULL ;
8977 PyObject *swig_obj[3] ;
8978
8979 (void)self;
8980 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8981 {
8982 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8983 if ( tmp1 == NULL )
8984 return NULL;
8985 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8986 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8987 }
8988 {
8989 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8990 if ( tmp3 == NULL )
8991 return NULL;
8992 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8993 {
8994 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8995 return NULL;
8996 }
8997 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8998 }
8999 {
9000 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9001 if ( tmp4 == NULL )
9002 return NULL;
9003 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9004 {
9005 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9006 return NULL;
9007 }
9008 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9009 }
9010 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
9011 resultobj = SWIG_Py_Void();
9012 {
9013 Py_CLEAR( tmp1 );
9014 }
9015 {
9016 Py_CLEAR( tmp3 );
9017 }
9018 {
9019 Py_CLEAR( tmp4 );
9020 }
9021 return resultobj;
9022fail:
9023 {
9024 Py_CLEAR( tmp1 );
9025 }
9026 {
9027 Py_CLEAR( tmp3 );
9028 }
9029 {
9030 Py_CLEAR( tmp4 );
9031 }
9032 return NULL;
9033}
9034
9035
9036SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
9037 PyObject *resultobj = 0;
9038 PLINT arg1 ;
9039 int val1 ;
9040 int ecode1 = 0 ;
9041 PyObject *swig_obj[1] ;
9042
9043 (void)self;
9044 if (!args) SWIG_fail;
9045 swig_obj[0] = args;
9046 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9047 if (!SWIG_IsOK(ecode1)) {
9048 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9049 }
9050 arg1 = (PLINT)(val1);
9051 pllsty(arg1);
9052 resultobj = SWIG_Py_Void();
9053 return resultobj;
9054fail:
9055 return NULL;
9056}
9057
9058
9059SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9060 PyObject *resultobj = 0;
9061 PLFLT *arg1 = (PLFLT *) 0 ;
9062 PLFLT *arg2 = (PLFLT *) 0 ;
9063 PLFLT **arg3 = (PLFLT **) 0 ;
9064 PLINT arg4 ;
9065 PLINT arg5 ;
9066 PLINT arg6 ;
9067 PyArrayObject *tmp1 = NULL ;
9068 PyArrayObject *tmp2 = NULL ;
9069 PyArrayObject *tmp3 = NULL ;
9070 int val6 ;
9071 int ecode6 = 0 ;
9072 PyObject *swig_obj[4] ;
9073
9074 (void)self;
9075 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9076 {
9077 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9078 if ( tmp1 == NULL )
9079 return NULL;
9080 Xlen = PyArray_DIMS( tmp1 )[0];
9081 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9082 }
9083 {
9084 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9085 if ( tmp2 == NULL )
9086 return NULL;
9087 Ylen = PyArray_DIMS( tmp2 )[0];
9088 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9089 }
9090 {
9091 int i, size;
9092 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9093 if ( tmp3 == NULL )
9094 return NULL;
9095 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9096 {
9097 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9098 return NULL;
9099 }
9100 arg4 = PyArray_DIMS( tmp3 )[0];
9101 arg5 = PyArray_DIMS( tmp3 )[1];
9102 size = arg5;
9103 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9104 for ( i = 0; i < arg4; i++ )
9105 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9106 }
9107 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9108 if (!SWIG_IsOK(ecode6)) {
9109 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9110 }
9111 arg6 = (PLINT)(val6);
9112 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9113 resultobj = SWIG_Py_Void();
9114 {
9115 Py_CLEAR( tmp1 );
9116 }
9117 {
9118 Py_CLEAR( tmp2 );
9119 }
9120 {
9121 Py_CLEAR( tmp3 );
9122 free( arg3 );
9123 }
9124 return resultobj;
9125fail:
9126 {
9127 Py_CLEAR( tmp1 );
9128 }
9129 {
9130 Py_CLEAR( tmp2 );
9131 }
9132 {
9133 Py_CLEAR( tmp3 );
9134 free( arg3 );
9135 }
9136 return NULL;
9137}
9138
9139
9140SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9141 PyObject *resultobj = 0;
9142 PLFLT *arg1 = (PLFLT *) 0 ;
9143 PLFLT *arg2 = (PLFLT *) 0 ;
9144 PLFLT **arg3 = (PLFLT **) 0 ;
9145 PLINT arg4 ;
9146 PLINT arg5 ;
9147 PLINT arg6 ;
9148 PLFLT *arg7 = (PLFLT *) 0 ;
9149 PLINT arg8 ;
9150 PyArrayObject *tmp1 = NULL ;
9151 PyArrayObject *tmp2 = NULL ;
9152 PyArrayObject *tmp3 = NULL ;
9153 int val6 ;
9154 int ecode6 = 0 ;
9155 PyArrayObject *tmp7 = NULL ;
9156 PyObject *swig_obj[5] ;
9157
9158 (void)self;
9159 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9160 {
9161 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9162 if ( tmp1 == NULL )
9163 return NULL;
9164 Xlen = PyArray_DIMS( tmp1 )[0];
9165 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9166 }
9167 {
9168 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9169 if ( tmp2 == NULL )
9170 return NULL;
9171 Ylen = PyArray_DIMS( tmp2 )[0];
9172 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9173 }
9174 {
9175 int i, size;
9176 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9177 if ( tmp3 == NULL )
9178 return NULL;
9179 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9180 {
9181 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9182 return NULL;
9183 }
9184 arg4 = PyArray_DIMS( tmp3 )[0];
9185 arg5 = PyArray_DIMS( tmp3 )[1];
9186 size = arg5;
9187 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9188 for ( i = 0; i < arg4; i++ )
9189 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9190 }
9191 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9192 if (!SWIG_IsOK(ecode6)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9194 }
9195 arg6 = (PLINT)(val6);
9196 {
9197 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9198 if ( tmp7 == NULL )
9199 return NULL;
9200 arg8 = PyArray_DIMS( tmp7 )[0];
9201 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9202 }
9203 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9204 resultobj = SWIG_Py_Void();
9205 {
9206 Py_CLEAR( tmp1 );
9207 }
9208 {
9209 Py_CLEAR( tmp2 );
9210 }
9211 {
9212 Py_CLEAR( tmp3 );
9213 free( arg3 );
9214 }
9215 {
9216 Py_CLEAR( tmp7 );
9217 }
9218 return resultobj;
9219fail:
9220 {
9221 Py_CLEAR( tmp1 );
9222 }
9223 {
9224 Py_CLEAR( tmp2 );
9225 }
9226 {
9227 Py_CLEAR( tmp3 );
9228 free( arg3 );
9229 }
9230 {
9231 Py_CLEAR( tmp7 );
9232 }
9233 return NULL;
9234}
9235
9236
9237SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9238 PyObject *resultobj = 0;
9239 PLINT *arg1 = (PLINT *) 0 ;
9240 PLINT temp1 ;
9241 int res1 = SWIG_TMPOBJ ;
9242
9243 arg1 = &temp1;
9244 (void)self;
9245 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9246 plmkstrm(arg1);
9247 resultobj = SWIG_Py_Void();
9248 if (SWIG_IsTmpObj(res1)) {
9249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
9250 } else {
9251 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
9253 }
9254 return resultobj;
9255fail:
9256 return NULL;
9257}
9258
9259
9260SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9261 PyObject *resultobj = 0;
9262 char *arg1 = (char *) 0 ;
9263 PLFLT arg2 ;
9264 PLFLT arg3 ;
9265 PLFLT arg4 ;
9266 char *arg5 = (char *) 0 ;
9267 int res1 ;
9268 char *buf1 = 0 ;
9269 int alloc1 = 0 ;
9270 double val2 ;
9271 int ecode2 = 0 ;
9272 double val3 ;
9273 int ecode3 = 0 ;
9274 double val4 ;
9275 int ecode4 = 0 ;
9276 int res5 ;
9277 char *buf5 = 0 ;
9278 int alloc5 = 0 ;
9279 PyObject *swig_obj[5] ;
9280
9281 (void)self;
9282 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9283 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9286 }
9287 arg1 = (char *)(buf1);
9288 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9289 if (!SWIG_IsOK(ecode2)) {
9290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9291 }
9292 arg2 = (PLFLT)(val2);
9293 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9294 if (!SWIG_IsOK(ecode3)) {
9295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9296 }
9297 arg3 = (PLFLT)(val3);
9298 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9299 if (!SWIG_IsOK(ecode4)) {
9300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9301 }
9302 arg4 = (PLFLT)(val4);
9303 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9304 if (!SWIG_IsOK(res5)) {
9305 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9306 }
9307 arg5 = (char *)(buf5);
9308 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9309 resultobj = SWIG_Py_Void();
9310 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9311 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9312 return resultobj;
9313fail:
9314 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9315 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9316 return NULL;
9317}
9318
9319
9320SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9321 PyObject *resultobj = 0;
9322 char *arg1 = (char *) 0 ;
9323 PLFLT arg2 ;
9324 PLFLT arg3 ;
9325 PLFLT arg4 ;
9326 char *arg5 = (char *) 0 ;
9327 int res1 ;
9328 char *buf1 = 0 ;
9329 int alloc1 = 0 ;
9330 double val2 ;
9331 int ecode2 = 0 ;
9332 double val3 ;
9333 int ecode3 = 0 ;
9334 double val4 ;
9335 int ecode4 = 0 ;
9336 int res5 ;
9337 char *buf5 = 0 ;
9338 int alloc5 = 0 ;
9339 PyObject *swig_obj[5] ;
9340
9341 (void)self;
9342 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9343 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9346 }
9347 arg1 = (char *)(buf1);
9348 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9349 if (!SWIG_IsOK(ecode2)) {
9350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9351 }
9352 arg2 = (PLFLT)(val2);
9353 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9354 if (!SWIG_IsOK(ecode3)) {
9355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9356 }
9357 arg3 = (PLFLT)(val3);
9358 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9359 if (!SWIG_IsOK(ecode4)) {
9360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9361 }
9362 arg4 = (PLFLT)(val4);
9363 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9364 if (!SWIG_IsOK(res5)) {
9365 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9366 }
9367 arg5 = (char *)(buf5);
9368 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9369 resultobj = SWIG_Py_Void();
9370 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9371 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9372 return resultobj;
9373fail:
9374 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9375 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9376 return NULL;
9377}
9378
9379
9380SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9381 PyObject *resultobj = 0;
9382 PLFLT *arg1 = (PLFLT *) 0 ;
9383 PLFLT *arg2 = (PLFLT *) 0 ;
9384 PLFLT **arg3 = (PLFLT **) 0 ;
9385 PLINT arg4 ;
9386 PLINT arg5 ;
9387 PLINT arg6 ;
9388 PLBOOL arg7 ;
9389 PyArrayObject *tmp1 = NULL ;
9390 PyArrayObject *tmp2 = NULL ;
9391 PyArrayObject *tmp3 = NULL ;
9392 int val6 ;
9393 int ecode6 = 0 ;
9394 int val7 ;
9395 int ecode7 = 0 ;
9396 PyObject *swig_obj[5] ;
9397
9398 (void)self;
9399 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9400 {
9401 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9402 if ( tmp1 == NULL )
9403 return NULL;
9404 Xlen = PyArray_DIMS( tmp1 )[0];
9405 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9406 }
9407 {
9408 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9409 if ( tmp2 == NULL )
9410 return NULL;
9411 Ylen = PyArray_DIMS( tmp2 )[0];
9412 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9413 }
9414 {
9415 int i, size;
9416 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9417 if ( tmp3 == NULL )
9418 return NULL;
9419 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9420 {
9421 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9422 return NULL;
9423 }
9424 arg4 = PyArray_DIMS( tmp3 )[0];
9425 arg5 = PyArray_DIMS( tmp3 )[1];
9426 size = arg5;
9427 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9428 for ( i = 0; i < arg4; i++ )
9429 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9430 }
9431 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9432 if (!SWIG_IsOK(ecode6)) {
9433 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9434 }
9435 arg6 = (PLINT)(val6);
9436 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9437 if (!SWIG_IsOK(ecode7)) {
9438 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9439 }
9440 arg7 = (PLBOOL)(val7);
9441 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9442 resultobj = SWIG_Py_Void();
9443 {
9444 Py_CLEAR( tmp1 );
9445 }
9446 {
9447 Py_CLEAR( tmp2 );
9448 }
9449 {
9450 Py_CLEAR( tmp3 );
9451 free( arg3 );
9452 }
9453 return resultobj;
9454fail:
9455 {
9456 Py_CLEAR( tmp1 );
9457 }
9458 {
9459 Py_CLEAR( tmp2 );
9460 }
9461 {
9462 Py_CLEAR( tmp3 );
9463 free( arg3 );
9464 }
9465 return NULL;
9466}
9467
9468
9469SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9470 PyObject *resultobj = 0;
9471 PLFLT *arg1 = (PLFLT *) 0 ;
9472 PLFLT *arg2 = (PLFLT *) 0 ;
9473 PLFLT **arg3 = (PLFLT **) 0 ;
9474 PLINT arg4 ;
9475 PLINT arg5 ;
9476 PLINT arg6 ;
9477 PLFLT *arg7 = (PLFLT *) 0 ;
9478 PLINT arg8 ;
9479 PyArrayObject *tmp1 = NULL ;
9480 PyArrayObject *tmp2 = NULL ;
9481 PyArrayObject *tmp3 = NULL ;
9482 int val6 ;
9483 int ecode6 = 0 ;
9484 PyArrayObject *tmp7 = NULL ;
9485 PyObject *swig_obj[5] ;
9486
9487 (void)self;
9488 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9489 {
9490 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9491 if ( tmp1 == NULL )
9492 return NULL;
9493 Xlen = PyArray_DIMS( tmp1 )[0];
9494 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9495 }
9496 {
9497 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9498 if ( tmp2 == NULL )
9499 return NULL;
9500 Ylen = PyArray_DIMS( tmp2 )[0];
9501 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9502 }
9503 {
9504 int i, size;
9505 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9506 if ( tmp3 == NULL )
9507 return NULL;
9508 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9509 {
9510 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9511 return NULL;
9512 }
9513 arg4 = PyArray_DIMS( tmp3 )[0];
9514 arg5 = PyArray_DIMS( tmp3 )[1];
9515 size = arg5;
9516 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9517 for ( i = 0; i < arg4; i++ )
9518 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9519 }
9520 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9521 if (!SWIG_IsOK(ecode6)) {
9522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9523 }
9524 arg6 = (PLINT)(val6);
9525 {
9526 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9527 if ( tmp7 == NULL )
9528 return NULL;
9529 arg8 = PyArray_DIMS( tmp7 )[0];
9530 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9531 }
9532 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9533 resultobj = SWIG_Py_Void();
9534 {
9535 Py_CLEAR( tmp1 );
9536 }
9537 {
9538 Py_CLEAR( tmp2 );
9539 }
9540 {
9541 Py_CLEAR( tmp3 );
9542 free( arg3 );
9543 }
9544 {
9545 Py_CLEAR( tmp7 );
9546 }
9547 return resultobj;
9548fail:
9549 {
9550 Py_CLEAR( tmp1 );
9551 }
9552 {
9553 Py_CLEAR( tmp2 );
9554 }
9555 {
9556 Py_CLEAR( tmp3 );
9557 free( arg3 );
9558 }
9559 {
9560 Py_CLEAR( tmp7 );
9561 }
9562 return NULL;
9563}
9564
9565
9566SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9567 PyObject *resultobj = 0;
9568 PLFLT *arg1 = (PLFLT *) 0 ;
9569 PLFLT *arg2 = (PLFLT *) 0 ;
9570 PLFLT **arg3 = (PLFLT **) 0 ;
9571 PLINT arg4 ;
9572 PLINT arg5 ;
9573 PLINT arg6 ;
9574 PLFLT *arg7 = (PLFLT *) 0 ;
9575 PLINT arg8 ;
9576 PLINT arg9 ;
9577 PLINT arg10 ;
9578 PLINT *arg11 = (PLINT *) 0 ;
9579 PLINT *arg12 = (PLINT *) 0 ;
9580 PyArrayObject *tmp1 = NULL ;
9581 PyArrayObject *tmp2 = NULL ;
9582 PyArrayObject *tmp3 = NULL ;
9583 int val6 ;
9584 int ecode6 = 0 ;
9585 PyArrayObject *tmp7 = NULL ;
9586 int val9 ;
9587 int ecode9 = 0 ;
9588 PyArrayObject *tmp10 = NULL ;
9589 PyArrayObject *tmp12 = NULL ;
9590 PyObject *swig_obj[8] ;
9591
9592 (void)self;
9593 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9594 {
9595 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9596 if ( tmp1 == NULL )
9597 return NULL;
9598 Xlen = PyArray_DIMS( tmp1 )[0];
9599 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9600 }
9601 {
9602 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9603 if ( tmp2 == NULL )
9604 return NULL;
9605 Ylen = PyArray_DIMS( tmp2 )[0];
9606 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9607 }
9608 {
9609 int i, size;
9610 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9611 if ( tmp3 == NULL )
9612 return NULL;
9613 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9614 {
9615 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9616 return NULL;
9617 }
9618 arg4 = PyArray_DIMS( tmp3 )[0];
9619 arg5 = PyArray_DIMS( tmp3 )[1];
9620 size = arg5;
9621 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9622 for ( i = 0; i < arg4; i++ )
9623 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9624 }
9625 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9626 if (!SWIG_IsOK(ecode6)) {
9627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9628 }
9629 arg6 = (PLINT)(val6);
9630 {
9631 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9632 if ( tmp7 == NULL )
9633 return NULL;
9634 arg8 = PyArray_DIMS( tmp7 )[0];
9635 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9636 }
9637 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9638 if (!SWIG_IsOK(ecode9)) {
9639 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9640 }
9641 arg9 = (PLINT)(val9);
9642 {
9643 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9644 if ( tmp10 == NULL )
9645 return NULL;
9646 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9647 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9648 }
9649 {
9650 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9651 if ( tmp12 == NULL )
9652 return NULL;
9653 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9654 {
9655 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9656 return NULL;
9657 }
9658 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9659 }
9660 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);
9661 resultobj = SWIG_Py_Void();
9662 {
9663 Py_CLEAR( tmp1 );
9664 }
9665 {
9666 Py_CLEAR( tmp2 );
9667 }
9668 {
9669 Py_CLEAR( tmp3 );
9670 free( arg3 );
9671 }
9672 {
9673 Py_CLEAR( tmp7 );
9674 }
9675 {
9676 Py_CLEAR( tmp10 );
9677 }
9678 {
9679 Py_CLEAR( tmp12 );
9680 }
9681 return resultobj;
9682fail:
9683 {
9684 Py_CLEAR( tmp1 );
9685 }
9686 {
9687 Py_CLEAR( tmp2 );
9688 }
9689 {
9690 Py_CLEAR( tmp3 );
9691 free( arg3 );
9692 }
9693 {
9694 Py_CLEAR( tmp7 );
9695 }
9696 {
9697 Py_CLEAR( tmp10 );
9698 }
9699 {
9700 Py_CLEAR( tmp12 );
9701 }
9702 return NULL;
9703}
9704
9705
9706SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9707 PyObject *resultobj = 0;
9708 PLFLT *arg1 = (PLFLT *) 0 ;
9709 PLFLT *arg2 = (PLFLT *) 0 ;
9710 PLFLT **arg3 = (PLFLT **) 0 ;
9711 PLINT arg4 ;
9712 PLINT arg5 ;
9713 PLINT arg6 ;
9714 PLFLT *arg7 = (PLFLT *) 0 ;
9715 PLINT arg8 ;
9716 PyArrayObject *tmp1 = NULL ;
9717 PyArrayObject *tmp2 = NULL ;
9718 PyArrayObject *tmp3 = NULL ;
9719 int val6 ;
9720 int ecode6 = 0 ;
9721 PyArrayObject *tmp7 = NULL ;
9722 PyObject *swig_obj[5] ;
9723
9724 (void)self;
9725 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9726 {
9727 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9728 if ( tmp1 == NULL )
9729 return NULL;
9730 Xlen = PyArray_DIMS( tmp1 )[0];
9731 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9732 }
9733 {
9734 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9735 if ( tmp2 == NULL )
9736 return NULL;
9737 Ylen = PyArray_DIMS( tmp2 )[0];
9738 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9739 }
9740 {
9741 int i, size;
9742 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9743 if ( tmp3 == NULL )
9744 return NULL;
9745 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9746 {
9747 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9748 return NULL;
9749 }
9750 arg4 = PyArray_DIMS( tmp3 )[0];
9751 arg5 = PyArray_DIMS( tmp3 )[1];
9752 size = arg5;
9753 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9754 for ( i = 0; i < arg4; i++ )
9755 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9756 }
9757 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9758 if (!SWIG_IsOK(ecode6)) {
9759 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9760 }
9761 arg6 = (PLINT)(val6);
9762 {
9763 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9764 if ( tmp7 == NULL )
9765 return NULL;
9766 arg8 = PyArray_DIMS( tmp7 )[0];
9767 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9768 }
9769 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9770 resultobj = SWIG_Py_Void();
9771 {
9772 Py_CLEAR( tmp1 );
9773 }
9774 {
9775 Py_CLEAR( tmp2 );
9776 }
9777 {
9778 Py_CLEAR( tmp3 );
9779 free( arg3 );
9780 }
9781 {
9782 Py_CLEAR( tmp7 );
9783 }
9784 return resultobj;
9785fail:
9786 {
9787 Py_CLEAR( tmp1 );
9788 }
9789 {
9790 Py_CLEAR( tmp2 );
9791 }
9792 {
9793 Py_CLEAR( tmp3 );
9794 free( arg3 );
9795 }
9796 {
9797 Py_CLEAR( tmp7 );
9798 }
9799 return NULL;
9800}
9801
9802
9803SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9804 PyObject *resultobj = 0;
9805 PLFLT *arg1 = (PLFLT *) 0 ;
9806 PLFLT *arg2 = (PLFLT *) 0 ;
9807 PLFLT **arg3 = (PLFLT **) 0 ;
9808 PLINT arg4 ;
9809 PLINT arg5 ;
9810 PLINT arg6 ;
9811 PLFLT *arg7 = (PLFLT *) 0 ;
9812 PLINT arg8 ;
9813 PLINT arg9 ;
9814 PLINT arg10 ;
9815 PLINT *arg11 = (PLINT *) 0 ;
9816 PLINT *arg12 = (PLINT *) 0 ;
9817 PyArrayObject *tmp1 = NULL ;
9818 PyArrayObject *tmp2 = NULL ;
9819 PyArrayObject *tmp3 = NULL ;
9820 int val6 ;
9821 int ecode6 = 0 ;
9822 PyArrayObject *tmp7 = NULL ;
9823 int val9 ;
9824 int ecode9 = 0 ;
9825 PyArrayObject *tmp10 = NULL ;
9826 PyArrayObject *tmp12 = NULL ;
9827 PyObject *swig_obj[8] ;
9828
9829 (void)self;
9830 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9831 {
9832 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9833 if ( tmp1 == NULL )
9834 return NULL;
9835 Xlen = PyArray_DIMS( tmp1 )[0];
9836 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9837 }
9838 {
9839 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9840 if ( tmp2 == NULL )
9841 return NULL;
9842 Ylen = PyArray_DIMS( tmp2 )[0];
9843 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9844 }
9845 {
9846 int i, size;
9847 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9848 if ( tmp3 == NULL )
9849 return NULL;
9850 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9851 {
9852 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9853 return NULL;
9854 }
9855 arg4 = PyArray_DIMS( tmp3 )[0];
9856 arg5 = PyArray_DIMS( tmp3 )[1];
9857 size = arg5;
9858 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9859 for ( i = 0; i < arg4; i++ )
9860 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9861 }
9862 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9863 if (!SWIG_IsOK(ecode6)) {
9864 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9865 }
9866 arg6 = (PLINT)(val6);
9867 {
9868 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9869 if ( tmp7 == NULL )
9870 return NULL;
9871 arg8 = PyArray_DIMS( tmp7 )[0];
9872 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9873 }
9874 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9875 if (!SWIG_IsOK(ecode9)) {
9876 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9877 }
9878 arg9 = (PLINT)(val9);
9879 {
9880 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9881 if ( tmp10 == NULL )
9882 return NULL;
9883 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9884 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9885 }
9886 {
9887 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9888 if ( tmp12 == NULL )
9889 return NULL;
9890 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9891 {
9892 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9893 return NULL;
9894 }
9895 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9896 }
9897 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);
9898 resultobj = SWIG_Py_Void();
9899 {
9900 Py_CLEAR( tmp1 );
9901 }
9902 {
9903 Py_CLEAR( tmp2 );
9904 }
9905 {
9906 Py_CLEAR( tmp3 );
9907 free( arg3 );
9908 }
9909 {
9910 Py_CLEAR( tmp7 );
9911 }
9912 {
9913 Py_CLEAR( tmp10 );
9914 }
9915 {
9916 Py_CLEAR( tmp12 );
9917 }
9918 return resultobj;
9919fail:
9920 {
9921 Py_CLEAR( tmp1 );
9922 }
9923 {
9924 Py_CLEAR( tmp2 );
9925 }
9926 {
9927 Py_CLEAR( tmp3 );
9928 free( arg3 );
9929 }
9930 {
9931 Py_CLEAR( tmp7 );
9932 }
9933 {
9934 Py_CLEAR( tmp10 );
9935 }
9936 {
9937 Py_CLEAR( tmp12 );
9938 }
9939 return NULL;
9940}
9941
9942
9943SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9944 PyObject *resultobj = 0;
9945 int *arg1 = (int *) 0 ;
9946 char **arg2 = (char **) 0 ;
9947 PLINT arg3 ;
9948 int tmp1 ;
9949 int val3 ;
9950 int ecode3 = 0 ;
9951 PyObject *swig_obj[2] ;
9952 PLINT result;
9953
9954 (void)self;
9955 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9956 {
9957 int i;
9958 PyObject *unicode_string;
9959
9960 if ( !PyList_Check( swig_obj[0] ) )
9961 {
9962 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9963 return NULL;
9964 }
9965 tmp1 = PyList_Size( swig_obj[0] );
9966 arg1 = &tmp1;
9967 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9968 for ( i = 0; i < tmp1; i++ )
9969 {
9970 PyObject *s = PyList_GetItem( swig_obj[0], i );
9971 if ( PyString_Check( s ) )
9972 {
9973 arg2[i] = PyString_AsString( s );
9974 }
9975 else if ( PyUnicode_Check( s ) )
9976 {
9977 // unicode_string is never freed? memory leak here?
9978 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9979 arg2[i] = PyBytes_AS_STRING( unicode_string );
9980 }
9981 else
9982 {
9983 free( arg2 );
9984 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9985 return NULL;
9986 }
9987 }
9988 arg2[i] = 0;
9989 }
9990 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9991 if (!SWIG_IsOK(ecode3)) {
9992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9993 }
9994 arg3 = (PLINT)(val3);
9995 result = (PLINT)plparseopts(arg1,arg2,arg3);
9996 resultobj = SWIG_From_int((int)(result));
9997 {
9998 if ( arg2 )
9999 free( arg2 );
10000 }
10001 return resultobj;
10002fail:
10003 {
10004 if ( arg2 )
10005 free( arg2 );
10006 }
10007 return NULL;
10008}
10009
10010
10011SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
10012 PyObject *resultobj = 0;
10013 PLINT arg1 ;
10014 PLINT *arg2 = (PLINT *) 0 ;
10015 PLINT *arg3 = (PLINT *) 0 ;
10016 PyArrayObject *tmp1 = NULL ;
10017 PyArrayObject *tmp3 = NULL ;
10018 PyObject *swig_obj[2] ;
10019
10020 (void)self;
10021 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
10022 {
10023 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10024 if ( tmp1 == NULL )
10025 return NULL;
10026 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10027 arg2 = (PLINT *) PyArray_DATA( tmp1 );
10028 }
10029 {
10030 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10031 if ( tmp3 == NULL )
10032 return NULL;
10033 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10034 {
10035 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10036 return NULL;
10037 }
10038 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10039 }
10040 plpat(arg1,(int const *)arg2,(int const *)arg3);
10041 resultobj = SWIG_Py_Void();
10042 {
10043 Py_CLEAR( tmp1 );
10044 }
10045 {
10046 Py_CLEAR( tmp3 );
10047 }
10048 return resultobj;
10049fail:
10050 {
10051 Py_CLEAR( tmp1 );
10052 }
10053 {
10054 Py_CLEAR( tmp3 );
10055 }
10056 return NULL;
10057}
10058
10059
10060SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10061 PyObject *resultobj = 0;
10062 PLINT arg1 ;
10063 PLFLT arg2 ;
10064 PLFLT arg3 ;
10065 PLFLT arg4 ;
10066 PLFLT arg5 ;
10067 int val1 ;
10068 int ecode1 = 0 ;
10069 double val2 ;
10070 int ecode2 = 0 ;
10071 double val3 ;
10072 int ecode3 = 0 ;
10073 double val4 ;
10074 int ecode4 = 0 ;
10075 double val5 ;
10076 int ecode5 = 0 ;
10077 PyObject *swig_obj[5] ;
10078
10079 (void)self;
10080 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10081 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10082 if (!SWIG_IsOK(ecode1)) {
10083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10084 }
10085 arg1 = (PLINT)(val1);
10086 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10087 if (!SWIG_IsOK(ecode2)) {
10088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10089 }
10090 arg2 = (PLFLT)(val2);
10091 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10092 if (!SWIG_IsOK(ecode3)) {
10093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10094 }
10095 arg3 = (PLFLT)(val3);
10096 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10097 if (!SWIG_IsOK(ecode4)) {
10098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10099 }
10100 arg4 = (PLFLT)(val4);
10101 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10102 if (!SWIG_IsOK(ecode5)) {
10103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10104 }
10105 arg5 = (PLFLT)(val5);
10106 plpath(arg1,arg2,arg3,arg4,arg5);
10107 resultobj = SWIG_Py_Void();
10108 return resultobj;
10109fail:
10110 return NULL;
10111}
10112
10113
10114SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10115 PyObject *resultobj = 0;
10116 PLINT arg1 ;
10117 PLFLT *arg2 = (PLFLT *) 0 ;
10118 PLFLT *arg3 = (PLFLT *) 0 ;
10119 PLINT arg4 ;
10120 PyArrayObject *tmp1 = NULL ;
10121 PyArrayObject *tmp3 = NULL ;
10122 int val4 ;
10123 int ecode4 = 0 ;
10124 PyObject *swig_obj[3] ;
10125
10126 (void)self;
10127 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10128 {
10129 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10130 if ( tmp1 == NULL )
10131 return NULL;
10132 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10133 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10134 }
10135 {
10136 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10137 if ( tmp3 == NULL )
10138 return NULL;
10139 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10140 {
10141 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10142 return NULL;
10143 }
10144 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10145 }
10146 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10147 if (!SWIG_IsOK(ecode4)) {
10148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10149 }
10150 arg4 = (PLINT)(val4);
10151 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10152 resultobj = SWIG_Py_Void();
10153 {
10154 Py_CLEAR( tmp1 );
10155 }
10156 {
10157 Py_CLEAR( tmp3 );
10158 }
10159 return resultobj;
10160fail:
10161 {
10162 Py_CLEAR( tmp1 );
10163 }
10164 {
10165 Py_CLEAR( tmp3 );
10166 }
10167 return NULL;
10168}
10169
10170
10171SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10172 PyObject *resultobj = 0;
10173 PLINT arg1 ;
10174 PLFLT *arg2 = (PLFLT *) 0 ;
10175 PLFLT *arg3 = (PLFLT *) 0 ;
10176 PLFLT *arg4 = (PLFLT *) 0 ;
10177 PLINT arg5 ;
10178 PyArrayObject *tmp1 = NULL ;
10179 PyArrayObject *tmp3 = NULL ;
10180 PyArrayObject *tmp4 = NULL ;
10181 int val5 ;
10182 int ecode5 = 0 ;
10183 PyObject *swig_obj[4] ;
10184
10185 (void)self;
10186 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10187 {
10188 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10189 if ( tmp1 == NULL )
10190 return NULL;
10191 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10192 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10193 }
10194 {
10195 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10196 if ( tmp3 == NULL )
10197 return NULL;
10198 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10199 {
10200 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10201 return NULL;
10202 }
10203 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10204 }
10205 {
10206 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10207 if ( tmp4 == NULL )
10208 return NULL;
10209 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10210 {
10211 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10212 return NULL;
10213 }
10214 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10215 }
10216 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10217 if (!SWIG_IsOK(ecode5)) {
10218 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10219 }
10220 arg5 = (PLINT)(val5);
10221 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10222 resultobj = SWIG_Py_Void();
10223 {
10224 Py_CLEAR( tmp1 );
10225 }
10226 {
10227 Py_CLEAR( tmp3 );
10228 }
10229 {
10230 Py_CLEAR( tmp4 );
10231 }
10232 return resultobj;
10233fail:
10234 {
10235 Py_CLEAR( tmp1 );
10236 }
10237 {
10238 Py_CLEAR( tmp3 );
10239 }
10240 {
10241 Py_CLEAR( tmp4 );
10242 }
10243 return NULL;
10244}
10245
10246
10247SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10248 PyObject *resultobj = 0;
10249 PLINT arg1 ;
10250 PLFLT *arg2 = (PLFLT *) 0 ;
10251 PLFLT *arg3 = (PLFLT *) 0 ;
10252 PLFLT *arg4 = (PLFLT *) 0 ;
10253 PLBOOL *arg5 = (PLBOOL *) 0 ;
10254 PLBOOL arg6 ;
10255 PyArrayObject *tmp1 = NULL ;
10256 PyArrayObject *tmp3 = NULL ;
10257 PyArrayObject *tmp4 = NULL ;
10258 PyArrayObject *tmp5 = NULL ;
10259 int val6 ;
10260 int ecode6 = 0 ;
10261 PyObject *swig_obj[5] ;
10262
10263 (void)self;
10264 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10265 {
10266 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10267 if ( tmp1 == NULL )
10268 return NULL;
10269 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10270 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10271 }
10272 {
10273 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10274 if ( tmp3 == NULL )
10275 return NULL;
10276 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10277 {
10278 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10279 return NULL;
10280 }
10281 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10282 }
10283 {
10284 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10285 if ( tmp4 == NULL )
10286 return NULL;
10287 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10288 {
10289 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10290 return NULL;
10291 }
10292 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10293 }
10294 {
10295 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10296 if ( tmp5 == NULL )
10297 return NULL;
10298 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10299 {
10300 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10301 return NULL;
10302 }
10303 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10304 }
10305 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10306 if (!SWIG_IsOK(ecode6)) {
10307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10308 }
10309 arg6 = (PLBOOL)(val6);
10310 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10311 resultobj = SWIG_Py_Void();
10312 {
10313 Py_CLEAR( tmp1 );
10314 }
10315 {
10316 Py_CLEAR( tmp3 );
10317 }
10318 {
10319 Py_CLEAR( tmp4 );
10320 }
10321 {
10322 Py_CLEAR( tmp5 );
10323 }
10324 return resultobj;
10325fail:
10326 {
10327 Py_CLEAR( tmp1 );
10328 }
10329 {
10330 Py_CLEAR( tmp3 );
10331 }
10332 {
10333 Py_CLEAR( tmp4 );
10334 }
10335 {
10336 Py_CLEAR( tmp5 );
10337 }
10338 return NULL;
10339}
10340
10341
10342SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10343 PyObject *resultobj = 0;
10344 PLINT arg1 ;
10345 PLINT arg2 ;
10346 int val1 ;
10347 int ecode1 = 0 ;
10348 int val2 ;
10349 int ecode2 = 0 ;
10350 PyObject *swig_obj[2] ;
10351
10352 (void)self;
10353 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10354 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10355 if (!SWIG_IsOK(ecode1)) {
10356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10357 }
10358 arg1 = (PLINT)(val1);
10359 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10360 if (!SWIG_IsOK(ecode2)) {
10361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10362 }
10363 arg2 = (PLINT)(val2);
10364 plprec(arg1,arg2);
10365 resultobj = SWIG_Py_Void();
10366 return resultobj;
10367fail:
10368 return NULL;
10369}
10370
10371
10372SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10373 PyObject *resultobj = 0;
10374 PLINT arg1 ;
10375 int val1 ;
10376 int ecode1 = 0 ;
10377 PyObject *swig_obj[1] ;
10378
10379 (void)self;
10380 if (!args) SWIG_fail;
10381 swig_obj[0] = args;
10382 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10383 if (!SWIG_IsOK(ecode1)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10385 }
10386 arg1 = (PLINT)(val1);
10387 plpsty(arg1);
10388 resultobj = SWIG_Py_Void();
10389 return resultobj;
10390fail:
10391 return NULL;
10392}
10393
10394
10395SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10396 PyObject *resultobj = 0;
10397 PLFLT arg1 ;
10398 PLFLT arg2 ;
10399 PLFLT arg3 ;
10400 PLFLT arg4 ;
10401 PLFLT arg5 ;
10402 char *arg6 = (char *) 0 ;
10403 double val1 ;
10404 int ecode1 = 0 ;
10405 double val2 ;
10406 int ecode2 = 0 ;
10407 double val3 ;
10408 int ecode3 = 0 ;
10409 double val4 ;
10410 int ecode4 = 0 ;
10411 double val5 ;
10412 int ecode5 = 0 ;
10413 int res6 ;
10414 char *buf6 = 0 ;
10415 int alloc6 = 0 ;
10416 PyObject *swig_obj[6] ;
10417
10418 (void)self;
10419 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10420 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10421 if (!SWIG_IsOK(ecode1)) {
10422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10423 }
10424 arg1 = (PLFLT)(val1);
10425 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10426 if (!SWIG_IsOK(ecode2)) {
10427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10428 }
10429 arg2 = (PLFLT)(val2);
10430 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10431 if (!SWIG_IsOK(ecode3)) {
10432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10433 }
10434 arg3 = (PLFLT)(val3);
10435 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10436 if (!SWIG_IsOK(ecode4)) {
10437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10438 }
10439 arg4 = (PLFLT)(val4);
10440 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10441 if (!SWIG_IsOK(ecode5)) {
10442 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10443 }
10444 arg5 = (PLFLT)(val5);
10445 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10446 if (!SWIG_IsOK(res6)) {
10447 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10448 }
10449 arg6 = (char *)(buf6);
10450 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10451 resultobj = SWIG_Py_Void();
10452 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10453 return resultobj;
10454fail:
10455 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10456 return NULL;
10457}
10458
10459
10460SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10461 PyObject *resultobj = 0;
10462 PLFLT arg1 ;
10463 PLFLT arg2 ;
10464 PLFLT arg3 ;
10465 PLFLT arg4 ;
10466 PLFLT arg5 ;
10467 PLFLT arg6 ;
10468 PLFLT arg7 ;
10469 PLFLT arg8 ;
10470 PLFLT arg9 ;
10471 PLFLT arg10 ;
10472 char *arg11 = (char *) 0 ;
10473 double val1 ;
10474 int ecode1 = 0 ;
10475 double val2 ;
10476 int ecode2 = 0 ;
10477 double val3 ;
10478 int ecode3 = 0 ;
10479 double val4 ;
10480 int ecode4 = 0 ;
10481 double val5 ;
10482 int ecode5 = 0 ;
10483 double val6 ;
10484 int ecode6 = 0 ;
10485 double val7 ;
10486 int ecode7 = 0 ;
10487 double val8 ;
10488 int ecode8 = 0 ;
10489 double val9 ;
10490 int ecode9 = 0 ;
10491 double val10 ;
10492 int ecode10 = 0 ;
10493 int res11 ;
10494 char *buf11 = 0 ;
10495 int alloc11 = 0 ;
10496 PyObject *swig_obj[11] ;
10497
10498 (void)self;
10499 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10500 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10501 if (!SWIG_IsOK(ecode1)) {
10502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10503 }
10504 arg1 = (PLFLT)(val1);
10505 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10506 if (!SWIG_IsOK(ecode2)) {
10507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10508 }
10509 arg2 = (PLFLT)(val2);
10510 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10511 if (!SWIG_IsOK(ecode3)) {
10512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10513 }
10514 arg3 = (PLFLT)(val3);
10515 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10516 if (!SWIG_IsOK(ecode4)) {
10517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10518 }
10519 arg4 = (PLFLT)(val4);
10520 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10521 if (!SWIG_IsOK(ecode5)) {
10522 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10523 }
10524 arg5 = (PLFLT)(val5);
10525 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10526 if (!SWIG_IsOK(ecode6)) {
10527 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10528 }
10529 arg6 = (PLFLT)(val6);
10530 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10531 if (!SWIG_IsOK(ecode7)) {
10532 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10533 }
10534 arg7 = (PLFLT)(val7);
10535 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10536 if (!SWIG_IsOK(ecode8)) {
10537 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10538 }
10539 arg8 = (PLFLT)(val8);
10540 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10541 if (!SWIG_IsOK(ecode9)) {
10542 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10543 }
10544 arg9 = (PLFLT)(val9);
10545 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10546 if (!SWIG_IsOK(ecode10)) {
10547 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10548 }
10549 arg10 = (PLFLT)(val10);
10550 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10551 if (!SWIG_IsOK(res11)) {
10552 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10553 }
10554 arg11 = (char *)(buf11);
10555 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10556 resultobj = SWIG_Py_Void();
10557 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10558 return resultobj;
10559fail:
10560 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10561 return NULL;
10562}
10563
10564
10565SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10566 PyObject *resultobj = 0;
10567 PLFLT result;
10568
10569 (void)self;
10570 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10571 result = (PLFLT)plrandd();
10572 resultobj = SWIG_From_double((double)(result));
10573 return resultobj;
10574fail:
10575 return NULL;
10576}
10577
10578
10579SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10580 PyObject *resultobj = 0;
10581
10582 (void)self;
10583 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10584 plreplot();
10585 resultobj = SWIG_Py_Void();
10586 return resultobj;
10587fail:
10588 return NULL;
10589}
10590
10591
10592SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10593 PyObject *resultobj = 0;
10594 PLFLT arg1 ;
10595 PLFLT arg2 ;
10596 PLFLT arg3 ;
10597 PLFLT *arg4 = (PLFLT *) 0 ;
10598 PLFLT *arg5 = (PLFLT *) 0 ;
10599 PLFLT *arg6 = (PLFLT *) 0 ;
10600 double val1 ;
10601 int ecode1 = 0 ;
10602 double val2 ;
10603 int ecode2 = 0 ;
10604 double val3 ;
10605 int ecode3 = 0 ;
10606 PLFLT temp4 ;
10607 int res4 = SWIG_TMPOBJ ;
10608 PLFLT temp5 ;
10609 int res5 = SWIG_TMPOBJ ;
10610 PLFLT temp6 ;
10611 int res6 = SWIG_TMPOBJ ;
10612 PyObject *swig_obj[3] ;
10613
10614 arg4 = &temp4;
10615 arg5 = &temp5;
10616 arg6 = &temp6;
10617 (void)self;
10618 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10619 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10620 if (!SWIG_IsOK(ecode1)) {
10621 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10622 }
10623 arg1 = (PLFLT)(val1);
10624 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10625 if (!SWIG_IsOK(ecode2)) {
10626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10627 }
10628 arg2 = (PLFLT)(val2);
10629 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10630 if (!SWIG_IsOK(ecode3)) {
10631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10632 }
10633 arg3 = (PLFLT)(val3);
10634 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10635 resultobj = SWIG_Py_Void();
10636 if (SWIG_IsTmpObj(res4)) {
10637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
10638 } else {
10639 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
10641 }
10642 if (SWIG_IsTmpObj(res5)) {
10643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
10644 } else {
10645 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
10647 }
10648 if (SWIG_IsTmpObj(res6)) {
10649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
10650 } else {
10651 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
10653 }
10654 return resultobj;
10655fail:
10656 return NULL;
10657}
10658
10659
10660SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10661 PyObject *resultobj = 0;
10662 PLFLT arg1 ;
10663 PLFLT arg2 ;
10664 double val1 ;
10665 int ecode1 = 0 ;
10666 double val2 ;
10667 int ecode2 = 0 ;
10668 PyObject *swig_obj[2] ;
10669
10670 (void)self;
10671 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10672 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10673 if (!SWIG_IsOK(ecode1)) {
10674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10675 }
10676 arg1 = (PLFLT)(val1);
10677 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10678 if (!SWIG_IsOK(ecode2)) {
10679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10680 }
10681 arg2 = (PLFLT)(val2);
10682 plschr(arg1,arg2);
10683 resultobj = SWIG_Py_Void();
10684 return resultobj;
10685fail:
10686 return NULL;
10687}
10688
10689
10690SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10691 PyObject *resultobj = 0;
10692 PLINT *arg1 = (PLINT *) 0 ;
10693 PLINT *arg2 = (PLINT *) 0 ;
10694 PLINT *arg3 = (PLINT *) 0 ;
10695 PLINT arg4 ;
10696 PyArrayObject *tmp1 = NULL ;
10697 PyArrayObject *tmp2 = NULL ;
10698 PyArrayObject *tmp3 = NULL ;
10699 PyObject *swig_obj[3] ;
10700
10701 (void)self;
10702 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10703 {
10704 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10705 if ( tmp1 == NULL )
10706 return NULL;
10707 Alen = PyArray_DIMS( tmp1 )[0];
10708 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10709 }
10710 {
10711 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10712 if ( tmp2 == NULL )
10713 return NULL;
10714 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10715 {
10716 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10717 return NULL;
10718 }
10719 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10720 }
10721 {
10722 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10723 if ( tmp3 == NULL )
10724 return NULL;
10725 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10726 {
10727 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10728 return NULL;
10729 }
10730 arg4 = PyArray_DIMS( tmp3 )[0];
10731 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10732 }
10733 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10734 resultobj = SWIG_Py_Void();
10735 {
10736 Py_CLEAR( tmp1 );
10737 }
10738 {
10739 Py_CLEAR( tmp2 );
10740 }
10741 {
10742 Py_CLEAR( tmp3 );
10743 }
10744 return resultobj;
10745fail:
10746 {
10747 Py_CLEAR( tmp1 );
10748 }
10749 {
10750 Py_CLEAR( tmp2 );
10751 }
10752 {
10753 Py_CLEAR( tmp3 );
10754 }
10755 return NULL;
10756}
10757
10758
10759SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10760 PyObject *resultobj = 0;
10761 PLINT *arg1 = (PLINT *) 0 ;
10762 PLINT *arg2 = (PLINT *) 0 ;
10763 PLINT *arg3 = (PLINT *) 0 ;
10764 PLFLT *arg4 = (PLFLT *) 0 ;
10765 PLINT arg5 ;
10766 PyArrayObject *tmp1 = NULL ;
10767 PyArrayObject *tmp2 = NULL ;
10768 PyArrayObject *tmp3 = NULL ;
10769 PyArrayObject *tmp4 = NULL ;
10770 PyObject *swig_obj[4] ;
10771
10772 (void)self;
10773 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10774 {
10775 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10776 if ( tmp1 == NULL )
10777 return NULL;
10778 Alen = PyArray_DIMS( tmp1 )[0];
10779 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10780 }
10781 {
10782 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10783 if ( tmp2 == NULL )
10784 return NULL;
10785 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10786 {
10787 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10788 return NULL;
10789 }
10790 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10791 }
10792 {
10793 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10794 if ( tmp3 == NULL )
10795 return NULL;
10796 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10797 {
10798 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10799 return NULL;
10800 }
10801 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10802 }
10803 {
10804 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10805 if ( tmp4 == NULL )
10806 return NULL;
10807 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10808 {
10809 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10810 return NULL;
10811 }
10812 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10813 arg5 = PyArray_DIMS( tmp4 )[0];
10814 }
10815 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10816 resultobj = SWIG_Py_Void();
10817 {
10818 Py_CLEAR( tmp1 );
10819 }
10820 {
10821 Py_CLEAR( tmp2 );
10822 }
10823 {
10824 Py_CLEAR( tmp3 );
10825 }
10826 {
10827 Py_CLEAR( tmp4 );
10828 }
10829 return resultobj;
10830fail:
10831 {
10832 Py_CLEAR( tmp1 );
10833 }
10834 {
10835 Py_CLEAR( tmp2 );
10836 }
10837 {
10838 Py_CLEAR( tmp3 );
10839 }
10840 {
10841 Py_CLEAR( tmp4 );
10842 }
10843 return NULL;
10844}
10845
10846
10847SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10848 PyObject *resultobj = 0;
10849 PLINT arg1 ;
10850 int val1 ;
10851 int ecode1 = 0 ;
10852 PyObject *swig_obj[1] ;
10853
10854 (void)self;
10855 if (!args) SWIG_fail;
10856 swig_obj[0] = args;
10857 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10858 if (!SWIG_IsOK(ecode1)) {
10859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10860 }
10861 arg1 = (PLINT)(val1);
10862 plscmap0n(arg1);
10863 resultobj = SWIG_Py_Void();
10864 return resultobj;
10865fail:
10866 return NULL;
10867}
10868
10869
10870SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10871 PyObject *resultobj = 0;
10872 PLINT *arg1 = (PLINT *) 0 ;
10873 PLINT *arg2 = (PLINT *) 0 ;
10874 PLINT *arg3 = (PLINT *) 0 ;
10875 PLINT arg4 ;
10876 PyArrayObject *tmp1 = NULL ;
10877 PyArrayObject *tmp2 = NULL ;
10878 PyArrayObject *tmp3 = NULL ;
10879 PyObject *swig_obj[3] ;
10880
10881 (void)self;
10882 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10883 {
10884 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10885 if ( tmp1 == NULL )
10886 return NULL;
10887 Alen = PyArray_DIMS( tmp1 )[0];
10888 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10889 }
10890 {
10891 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10892 if ( tmp2 == NULL )
10893 return NULL;
10894 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10895 {
10896 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10897 return NULL;
10898 }
10899 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10900 }
10901 {
10902 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10903 if ( tmp3 == NULL )
10904 return NULL;
10905 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10906 {
10907 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10908 return NULL;
10909 }
10910 arg4 = PyArray_DIMS( tmp3 )[0];
10911 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10912 }
10913 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10914 resultobj = SWIG_Py_Void();
10915 {
10916 Py_CLEAR( tmp1 );
10917 }
10918 {
10919 Py_CLEAR( tmp2 );
10920 }
10921 {
10922 Py_CLEAR( tmp3 );
10923 }
10924 return resultobj;
10925fail:
10926 {
10927 Py_CLEAR( tmp1 );
10928 }
10929 {
10930 Py_CLEAR( tmp2 );
10931 }
10932 {
10933 Py_CLEAR( tmp3 );
10934 }
10935 return NULL;
10936}
10937
10938
10939SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10940 PyObject *resultobj = 0;
10941 PLINT *arg1 = (PLINT *) 0 ;
10942 PLINT *arg2 = (PLINT *) 0 ;
10943 PLINT *arg3 = (PLINT *) 0 ;
10944 PLFLT *arg4 = (PLFLT *) 0 ;
10945 PLINT arg5 ;
10946 PyArrayObject *tmp1 = NULL ;
10947 PyArrayObject *tmp2 = NULL ;
10948 PyArrayObject *tmp3 = NULL ;
10949 PyArrayObject *tmp4 = NULL ;
10950 PyObject *swig_obj[4] ;
10951
10952 (void)self;
10953 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10954 {
10955 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10956 if ( tmp1 == NULL )
10957 return NULL;
10958 Alen = PyArray_DIMS( tmp1 )[0];
10959 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10960 }
10961 {
10962 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10963 if ( tmp2 == NULL )
10964 return NULL;
10965 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10966 {
10967 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10968 return NULL;
10969 }
10970 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10971 }
10972 {
10973 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10974 if ( tmp3 == NULL )
10975 return NULL;
10976 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10977 {
10978 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10979 return NULL;
10980 }
10981 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10982 }
10983 {
10984 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10985 if ( tmp4 == NULL )
10986 return NULL;
10987 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10988 {
10989 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10990 return NULL;
10991 }
10992 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10993 arg5 = PyArray_DIMS( tmp4 )[0];
10994 }
10995 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10996 resultobj = SWIG_Py_Void();
10997 {
10998 Py_CLEAR( tmp1 );
10999 }
11000 {
11001 Py_CLEAR( tmp2 );
11002 }
11003 {
11004 Py_CLEAR( tmp3 );
11005 }
11006 {
11007 Py_CLEAR( tmp4 );
11008 }
11009 return resultobj;
11010fail:
11011 {
11012 Py_CLEAR( tmp1 );
11013 }
11014 {
11015 Py_CLEAR( tmp2 );
11016 }
11017 {
11018 Py_CLEAR( tmp3 );
11019 }
11020 {
11021 Py_CLEAR( tmp4 );
11022 }
11023 return NULL;
11024}
11025
11026
11027SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
11028 PyObject *resultobj = 0;
11029 PLBOOL arg1 ;
11030 PLINT arg2 ;
11031 PLFLT *arg3 = (PLFLT *) 0 ;
11032 PLFLT *arg4 = (PLFLT *) 0 ;
11033 PLFLT *arg5 = (PLFLT *) 0 ;
11034 PLFLT *arg6 = (PLFLT *) 0 ;
11035 PLBOOL *arg7 = (PLBOOL *) 0 ;
11036 int val1 ;
11037 int ecode1 = 0 ;
11038 PyArrayObject *tmp2 = NULL ;
11039 PyArrayObject *tmp4 = NULL ;
11040 PyArrayObject *tmp5 = NULL ;
11041 PyArrayObject *tmp6 = NULL ;
11042 PyArrayObject *tmp7 = NULL ;
11043 PyObject *swig_obj[6] ;
11044
11045 (void)self;
11046 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11047 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11048 if (!SWIG_IsOK(ecode1)) {
11049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11050 }
11051 arg1 = (PLBOOL)(val1);
11052 {
11053 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11054 if ( tmp2 == NULL )
11055 return NULL;
11056 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11057 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11058 }
11059 {
11060 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11061 if ( tmp4 == NULL )
11062 return NULL;
11063 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11064 {
11065 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11066 return NULL;
11067 }
11068 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11069 }
11070 {
11071 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11072 if ( tmp5 == NULL )
11073 return NULL;
11074 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11075 {
11076 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11077 return NULL;
11078 }
11079 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11080 }
11081 {
11082 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11083 if ( tmp6 == NULL )
11084 return NULL;
11085 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11086 {
11087 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11088 return NULL;
11089 }
11090 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11091 }
11092 {
11093 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11094 if ( tmp7 == NULL )
11095 return NULL;
11096 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11097 {
11098 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11099 return NULL;
11100 }
11101 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11102 }
11103 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11104 resultobj = SWIG_Py_Void();
11105 {
11106 Py_CLEAR( tmp2 );
11107 }
11108 {
11109 Py_CLEAR( tmp4 );
11110 }
11111 {
11112 Py_CLEAR( tmp5 );
11113 }
11114 {
11115 Py_CLEAR( tmp6 );
11116 }
11117 {
11118 Py_CLEAR( tmp7 );
11119 }
11120 return resultobj;
11121fail:
11122 {
11123 Py_CLEAR( tmp2 );
11124 }
11125 {
11126 Py_CLEAR( tmp4 );
11127 }
11128 {
11129 Py_CLEAR( tmp5 );
11130 }
11131 {
11132 Py_CLEAR( tmp6 );
11133 }
11134 {
11135 Py_CLEAR( tmp7 );
11136 }
11137 return NULL;
11138}
11139
11140
11141SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11142 PyObject *resultobj = 0;
11143 PLBOOL arg1 ;
11144 PLINT arg2 ;
11145 PLFLT *arg3 = (PLFLT *) 0 ;
11146 PLFLT *arg4 = (PLFLT *) 0 ;
11147 PLFLT *arg5 = (PLFLT *) 0 ;
11148 PLFLT *arg6 = (PLFLT *) 0 ;
11149 PLFLT *arg7 = (PLFLT *) 0 ;
11150 PLBOOL *arg8 = (PLBOOL *) 0 ;
11151 int val1 ;
11152 int ecode1 = 0 ;
11153 PyArrayObject *tmp2 = NULL ;
11154 PyArrayObject *tmp4 = NULL ;
11155 PyArrayObject *tmp5 = NULL ;
11156 PyArrayObject *tmp6 = NULL ;
11157 PyArrayObject *tmp7 = NULL ;
11158 PyArrayObject *tmp8 = NULL ;
11159 PyObject *swig_obj[7] ;
11160
11161 (void)self;
11162 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11163 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11164 if (!SWIG_IsOK(ecode1)) {
11165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11166 }
11167 arg1 = (PLBOOL)(val1);
11168 {
11169 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11170 if ( tmp2 == NULL )
11171 return NULL;
11172 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11173 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11174 }
11175 {
11176 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11177 if ( tmp4 == NULL )
11178 return NULL;
11179 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11180 {
11181 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11182 return NULL;
11183 }
11184 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11185 }
11186 {
11187 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11188 if ( tmp5 == NULL )
11189 return NULL;
11190 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11191 {
11192 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11193 return NULL;
11194 }
11195 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11196 }
11197 {
11198 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11199 if ( tmp6 == NULL )
11200 return NULL;
11201 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11202 {
11203 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11204 return NULL;
11205 }
11206 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11207 }
11208 {
11209 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11210 if ( tmp7 == NULL )
11211 return NULL;
11212 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11213 {
11214 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11215 return NULL;
11216 }
11217 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11218 }
11219 {
11220 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11221 if ( tmp8 == NULL )
11222 return NULL;
11223 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11224 {
11225 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11226 return NULL;
11227 }
11228 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11229 }
11230 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11231 resultobj = SWIG_Py_Void();
11232 {
11233 Py_CLEAR( tmp2 );
11234 }
11235 {
11236 Py_CLEAR( tmp4 );
11237 }
11238 {
11239 Py_CLEAR( tmp5 );
11240 }
11241 {
11242 Py_CLEAR( tmp6 );
11243 }
11244 {
11245 Py_CLEAR( tmp7 );
11246 }
11247 {
11248 Py_CLEAR( tmp8 );
11249 }
11250 return resultobj;
11251fail:
11252 {
11253 Py_CLEAR( tmp2 );
11254 }
11255 {
11256 Py_CLEAR( tmp4 );
11257 }
11258 {
11259 Py_CLEAR( tmp5 );
11260 }
11261 {
11262 Py_CLEAR( tmp6 );
11263 }
11264 {
11265 Py_CLEAR( tmp7 );
11266 }
11267 {
11268 Py_CLEAR( tmp8 );
11269 }
11270 return NULL;
11271}
11272
11273
11274SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11275 PyObject *resultobj = 0;
11276 PLINT arg1 ;
11277 int val1 ;
11278 int ecode1 = 0 ;
11279 PyObject *swig_obj[1] ;
11280
11281 (void)self;
11282 if (!args) SWIG_fail;
11283 swig_obj[0] = args;
11284 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11285 if (!SWIG_IsOK(ecode1)) {
11286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11287 }
11288 arg1 = (PLINT)(val1);
11289 plscmap1n(arg1);
11290 resultobj = SWIG_Py_Void();
11291 return resultobj;
11292fail:
11293 return NULL;
11294}
11295
11296
11297SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11298 PyObject *resultobj = 0;
11299 PLFLT arg1 ;
11300 PLFLT arg2 ;
11301 double val1 ;
11302 int ecode1 = 0 ;
11303 double val2 ;
11304 int ecode2 = 0 ;
11305 PyObject *swig_obj[2] ;
11306
11307 (void)self;
11308 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11309 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11310 if (!SWIG_IsOK(ecode1)) {
11311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11312 }
11313 arg1 = (PLFLT)(val1);
11314 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11315 if (!SWIG_IsOK(ecode2)) {
11316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11317 }
11318 arg2 = (PLFLT)(val2);
11319 plscmap1_range(arg1,arg2);
11320 resultobj = SWIG_Py_Void();
11321 return resultobj;
11322fail:
11323 return NULL;
11324}
11325
11326
11327SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11328 PyObject *resultobj = 0;
11329 PLFLT *arg1 = (PLFLT *) 0 ;
11330 PLFLT *arg2 = (PLFLT *) 0 ;
11331 PLFLT temp1 ;
11332 int res1 = SWIG_TMPOBJ ;
11333 PLFLT temp2 ;
11334 int res2 = SWIG_TMPOBJ ;
11335
11336 arg1 = &temp1;
11337 arg2 = &temp2;
11338 (void)self;
11339 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11340 plgcmap1_range(arg1,arg2);
11341 resultobj = SWIG_Py_Void();
11342 if (SWIG_IsTmpObj(res1)) {
11343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
11344 } else {
11345 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
11347 }
11348 if (SWIG_IsTmpObj(res2)) {
11349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
11350 } else {
11351 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
11353 }
11354 return resultobj;
11355fail:
11356 return NULL;
11357}
11358
11359
11360SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11361 PyObject *resultobj = 0;
11362 PLINT arg1 ;
11363 PLINT arg2 ;
11364 PLINT arg3 ;
11365 PLINT arg4 ;
11366 int val1 ;
11367 int ecode1 = 0 ;
11368 int val2 ;
11369 int ecode2 = 0 ;
11370 int val3 ;
11371 int ecode3 = 0 ;
11372 int val4 ;
11373 int ecode4 = 0 ;
11374 PyObject *swig_obj[4] ;
11375
11376 (void)self;
11377 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11378 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11379 if (!SWIG_IsOK(ecode1)) {
11380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11381 }
11382 arg1 = (PLINT)(val1);
11383 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11384 if (!SWIG_IsOK(ecode2)) {
11385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11386 }
11387 arg2 = (PLINT)(val2);
11388 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11389 if (!SWIG_IsOK(ecode3)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11391 }
11392 arg3 = (PLINT)(val3);
11393 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11394 if (!SWIG_IsOK(ecode4)) {
11395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11396 }
11397 arg4 = (PLINT)(val4);
11398 plscol0(arg1,arg2,arg3,arg4);
11399 resultobj = SWIG_Py_Void();
11400 return resultobj;
11401fail:
11402 return NULL;
11403}
11404
11405
11406SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11407 PyObject *resultobj = 0;
11408 PLINT arg1 ;
11409 PLINT arg2 ;
11410 PLINT arg3 ;
11411 PLINT arg4 ;
11412 PLFLT arg5 ;
11413 int val1 ;
11414 int ecode1 = 0 ;
11415 int val2 ;
11416 int ecode2 = 0 ;
11417 int val3 ;
11418 int ecode3 = 0 ;
11419 int val4 ;
11420 int ecode4 = 0 ;
11421 double val5 ;
11422 int ecode5 = 0 ;
11423 PyObject *swig_obj[5] ;
11424
11425 (void)self;
11426 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11427 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11428 if (!SWIG_IsOK(ecode1)) {
11429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11430 }
11431 arg1 = (PLINT)(val1);
11432 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11433 if (!SWIG_IsOK(ecode2)) {
11434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11435 }
11436 arg2 = (PLINT)(val2);
11437 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11438 if (!SWIG_IsOK(ecode3)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11440 }
11441 arg3 = (PLINT)(val3);
11442 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11443 if (!SWIG_IsOK(ecode4)) {
11444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11445 }
11446 arg4 = (PLINT)(val4);
11447 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11448 if (!SWIG_IsOK(ecode5)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11450 }
11451 arg5 = (PLFLT)(val5);
11452 plscol0a(arg1,arg2,arg3,arg4,arg5);
11453 resultobj = SWIG_Py_Void();
11454 return resultobj;
11455fail:
11456 return NULL;
11457}
11458
11459
11460SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11461 PyObject *resultobj = 0;
11462 PLINT arg1 ;
11463 PLINT arg2 ;
11464 PLINT arg3 ;
11465 int val1 ;
11466 int ecode1 = 0 ;
11467 int val2 ;
11468 int ecode2 = 0 ;
11469 int val3 ;
11470 int ecode3 = 0 ;
11471 PyObject *swig_obj[3] ;
11472
11473 (void)self;
11474 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11475 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11476 if (!SWIG_IsOK(ecode1)) {
11477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11478 }
11479 arg1 = (PLINT)(val1);
11480 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11481 if (!SWIG_IsOK(ecode2)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11483 }
11484 arg2 = (PLINT)(val2);
11485 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11486 if (!SWIG_IsOK(ecode3)) {
11487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11488 }
11489 arg3 = (PLINT)(val3);
11490 plscolbg(arg1,arg2,arg3);
11491 resultobj = SWIG_Py_Void();
11492 return resultobj;
11493fail:
11494 return NULL;
11495}
11496
11497
11498SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11499 PyObject *resultobj = 0;
11500 PLINT arg1 ;
11501 PLINT arg2 ;
11502 PLINT arg3 ;
11503 PLFLT arg4 ;
11504 int val1 ;
11505 int ecode1 = 0 ;
11506 int val2 ;
11507 int ecode2 = 0 ;
11508 int val3 ;
11509 int ecode3 = 0 ;
11510 double val4 ;
11511 int ecode4 = 0 ;
11512 PyObject *swig_obj[4] ;
11513
11514 (void)self;
11515 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11516 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11517 if (!SWIG_IsOK(ecode1)) {
11518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11519 }
11520 arg1 = (PLINT)(val1);
11521 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11522 if (!SWIG_IsOK(ecode2)) {
11523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11524 }
11525 arg2 = (PLINT)(val2);
11526 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11527 if (!SWIG_IsOK(ecode3)) {
11528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11529 }
11530 arg3 = (PLINT)(val3);
11531 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11532 if (!SWIG_IsOK(ecode4)) {
11533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11534 }
11535 arg4 = (PLFLT)(val4);
11536 plscolbga(arg1,arg2,arg3,arg4);
11537 resultobj = SWIG_Py_Void();
11538 return resultobj;
11539fail:
11540 return NULL;
11541}
11542
11543
11544SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11545 PyObject *resultobj = 0;
11546 PLINT arg1 ;
11547 int val1 ;
11548 int ecode1 = 0 ;
11549 PyObject *swig_obj[1] ;
11550
11551 (void)self;
11552 if (!args) SWIG_fail;
11553 swig_obj[0] = args;
11554 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11555 if (!SWIG_IsOK(ecode1)) {
11556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11557 }
11558 arg1 = (PLINT)(val1);
11559 plscolor(arg1);
11560 resultobj = SWIG_Py_Void();
11561 return resultobj;
11562fail:
11563 return NULL;
11564}
11565
11566
11567SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11568 PyObject *resultobj = 0;
11569 PLINT arg1 ;
11570 int val1 ;
11571 int ecode1 = 0 ;
11572 PyObject *swig_obj[1] ;
11573
11574 (void)self;
11575 if (!args) SWIG_fail;
11576 swig_obj[0] = args;
11577 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11578 if (!SWIG_IsOK(ecode1)) {
11579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11580 }
11581 arg1 = (PLINT)(val1);
11582 plscompression(arg1);
11583 resultobj = SWIG_Py_Void();
11584 return resultobj;
11585fail:
11586 return NULL;
11587}
11588
11589
11590SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11591 PyObject *resultobj = 0;
11592 char *arg1 = (char *) 0 ;
11593 int res1 ;
11594 char *buf1 = 0 ;
11595 int alloc1 = 0 ;
11596 PyObject *swig_obj[1] ;
11597
11598 (void)self;
11599 if (!args) SWIG_fail;
11600 swig_obj[0] = args;
11601 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11604 }
11605 arg1 = (char *)(buf1);
11606 plsdev((char const *)arg1);
11607 resultobj = SWIG_Py_Void();
11608 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11609 return resultobj;
11610fail:
11611 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11612 return NULL;
11613}
11614
11615
11616SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11617 PyObject *resultobj = 0;
11618 PLFLT arg1 ;
11619 PLFLT arg2 ;
11620 PLFLT arg3 ;
11621 PLFLT arg4 ;
11622 double val1 ;
11623 int ecode1 = 0 ;
11624 double val2 ;
11625 int ecode2 = 0 ;
11626 double val3 ;
11627 int ecode3 = 0 ;
11628 double val4 ;
11629 int ecode4 = 0 ;
11630 PyObject *swig_obj[4] ;
11631
11632 (void)self;
11633 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11634 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11635 if (!SWIG_IsOK(ecode1)) {
11636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11637 }
11638 arg1 = (PLFLT)(val1);
11639 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11640 if (!SWIG_IsOK(ecode2)) {
11641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11642 }
11643 arg2 = (PLFLT)(val2);
11644 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11645 if (!SWIG_IsOK(ecode3)) {
11646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11647 }
11648 arg3 = (PLFLT)(val3);
11649 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11650 if (!SWIG_IsOK(ecode4)) {
11651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11652 }
11653 arg4 = (PLFLT)(val4);
11654 plsdidev(arg1,arg2,arg3,arg4);
11655 resultobj = SWIG_Py_Void();
11656 return resultobj;
11657fail:
11658 return NULL;
11659}
11660
11661
11662SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11663 PyObject *resultobj = 0;
11664 PLINT arg1 ;
11665 PLINT arg2 ;
11666 PLINT arg3 ;
11667 PLINT arg4 ;
11668 PLFLT arg5 ;
11669 PLFLT arg6 ;
11670 int val1 ;
11671 int ecode1 = 0 ;
11672 int val2 ;
11673 int ecode2 = 0 ;
11674 int val3 ;
11675 int ecode3 = 0 ;
11676 int val4 ;
11677 int ecode4 = 0 ;
11678 double val5 ;
11679 int ecode5 = 0 ;
11680 double val6 ;
11681 int ecode6 = 0 ;
11682 PyObject *swig_obj[6] ;
11683
11684 (void)self;
11685 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11686 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11687 if (!SWIG_IsOK(ecode1)) {
11688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11689 }
11690 arg1 = (PLINT)(val1);
11691 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11692 if (!SWIG_IsOK(ecode2)) {
11693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11694 }
11695 arg2 = (PLINT)(val2);
11696 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11697 if (!SWIG_IsOK(ecode3)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11699 }
11700 arg3 = (PLINT)(val3);
11701 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11702 if (!SWIG_IsOK(ecode4)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11704 }
11705 arg4 = (PLINT)(val4);
11706 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11707 if (!SWIG_IsOK(ecode5)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11709 }
11710 arg5 = (PLFLT)(val5);
11711 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11712 if (!SWIG_IsOK(ecode6)) {
11713 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11714 }
11715 arg6 = (PLFLT)(val6);
11716 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11717 resultobj = SWIG_Py_Void();
11718 return resultobj;
11719fail:
11720 return NULL;
11721}
11722
11723
11724SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11725 PyObject *resultobj = 0;
11726 PLFLT arg1 ;
11727 double val1 ;
11728 int ecode1 = 0 ;
11729 PyObject *swig_obj[1] ;
11730
11731 (void)self;
11732 if (!args) SWIG_fail;
11733 swig_obj[0] = args;
11734 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11735 if (!SWIG_IsOK(ecode1)) {
11736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11737 }
11738 arg1 = (PLFLT)(val1);
11739 plsdiori(arg1);
11740 resultobj = SWIG_Py_Void();
11741 return resultobj;
11742fail:
11743 return NULL;
11744}
11745
11746
11747SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11748 PyObject *resultobj = 0;
11749 PLFLT arg1 ;
11750 PLFLT arg2 ;
11751 PLFLT arg3 ;
11752 PLFLT arg4 ;
11753 double val1 ;
11754 int ecode1 = 0 ;
11755 double val2 ;
11756 int ecode2 = 0 ;
11757 double val3 ;
11758 int ecode3 = 0 ;
11759 double val4 ;
11760 int ecode4 = 0 ;
11761 PyObject *swig_obj[4] ;
11762
11763 (void)self;
11764 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11765 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11766 if (!SWIG_IsOK(ecode1)) {
11767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11768 }
11769 arg1 = (PLFLT)(val1);
11770 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11771 if (!SWIG_IsOK(ecode2)) {
11772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11773 }
11774 arg2 = (PLFLT)(val2);
11775 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11776 if (!SWIG_IsOK(ecode3)) {
11777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11778 }
11779 arg3 = (PLFLT)(val3);
11780 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11781 if (!SWIG_IsOK(ecode4)) {
11782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11783 }
11784 arg4 = (PLFLT)(val4);
11785 plsdiplt(arg1,arg2,arg3,arg4);
11786 resultobj = SWIG_Py_Void();
11787 return resultobj;
11788fail:
11789 return NULL;
11790}
11791
11792
11793SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11794 PyObject *resultobj = 0;
11795 PLFLT arg1 ;
11796 PLFLT arg2 ;
11797 PLFLT arg3 ;
11798 PLFLT arg4 ;
11799 double val1 ;
11800 int ecode1 = 0 ;
11801 double val2 ;
11802 int ecode2 = 0 ;
11803 double val3 ;
11804 int ecode3 = 0 ;
11805 double val4 ;
11806 int ecode4 = 0 ;
11807 PyObject *swig_obj[4] ;
11808
11809 (void)self;
11810 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11811 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11812 if (!SWIG_IsOK(ecode1)) {
11813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11814 }
11815 arg1 = (PLFLT)(val1);
11816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11817 if (!SWIG_IsOK(ecode2)) {
11818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11819 }
11820 arg2 = (PLFLT)(val2);
11821 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11822 if (!SWIG_IsOK(ecode3)) {
11823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11824 }
11825 arg3 = (PLFLT)(val3);
11826 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11827 if (!SWIG_IsOK(ecode4)) {
11828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11829 }
11830 arg4 = (PLFLT)(val4);
11831 plsdiplz(arg1,arg2,arg3,arg4);
11832 resultobj = SWIG_Py_Void();
11833 return resultobj;
11834fail:
11835 return NULL;
11836}
11837
11838
11839SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11840 PyObject *resultobj = 0;
11841 unsigned int arg1 ;
11842 unsigned int val1 ;
11843 int ecode1 = 0 ;
11844 PyObject *swig_obj[1] ;
11845
11846 (void)self;
11847 if (!args) SWIG_fail;
11848 swig_obj[0] = args;
11849 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11850 if (!SWIG_IsOK(ecode1)) {
11851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11852 }
11853 arg1 = (unsigned int)(val1);
11854 plseed(arg1);
11855 resultobj = SWIG_Py_Void();
11856 return resultobj;
11857fail:
11858 return NULL;
11859}
11860
11861
11862SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11863 PyObject *resultobj = 0;
11864 char arg1 ;
11865 char val1 ;
11866 int ecode1 = 0 ;
11867 PyObject *swig_obj[1] ;
11868
11869 (void)self;
11870 if (!args) SWIG_fail;
11871 swig_obj[0] = args;
11872 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11873 if (!SWIG_IsOK(ecode1)) {
11874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11875 }
11876 arg1 = (char)(val1);
11877 plsesc(arg1);
11878 resultobj = SWIG_Py_Void();
11879 return resultobj;
11880fail:
11881 return NULL;
11882}
11883
11884
11885SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11886 PyObject *resultobj = 0;
11887 char *arg1 = (char *) 0 ;
11888 char *arg2 = (char *) 0 ;
11889 int res1 ;
11890 char *buf1 = 0 ;
11891 int alloc1 = 0 ;
11892 int res2 ;
11893 char *buf2 = 0 ;
11894 int alloc2 = 0 ;
11895 PyObject *swig_obj[2] ;
11896 PLINT result;
11897
11898 (void)self;
11899 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11900 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11901 if (!SWIG_IsOK(res1)) {
11902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11903 }
11904 arg1 = (char *)(buf1);
11905 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11906 if (!SWIG_IsOK(res2)) {
11907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11908 }
11909 arg2 = (char *)(buf2);
11910 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11911 resultobj = SWIG_From_int((int)(result));
11912 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11913 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11914 return resultobj;
11915fail:
11916 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11917 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11918 return NULL;
11919}
11920
11921
11922SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11923 PyObject *resultobj = 0;
11924 PLINT arg1 ;
11925 PLINT arg2 ;
11926 PLINT arg3 ;
11927 int val1 ;
11928 int ecode1 = 0 ;
11929 int val2 ;
11930 int ecode2 = 0 ;
11931 int val3 ;
11932 int ecode3 = 0 ;
11933 PyObject *swig_obj[3] ;
11934
11935 (void)self;
11936 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11937 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11938 if (!SWIG_IsOK(ecode1)) {
11939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11940 }
11941 arg1 = (PLINT)(val1);
11942 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11943 if (!SWIG_IsOK(ecode2)) {
11944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11945 }
11946 arg2 = (PLINT)(val2);
11947 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11948 if (!SWIG_IsOK(ecode3)) {
11949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11950 }
11951 arg3 = (PLINT)(val3);
11952 plsfam(arg1,arg2,arg3);
11953 resultobj = SWIG_Py_Void();
11954 return resultobj;
11955fail:
11956 return NULL;
11957}
11958
11959
11960SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11961 PyObject *resultobj = 0;
11962 PLUNICODE arg1 ;
11963 unsigned int val1 ;
11964 int ecode1 = 0 ;
11965 PyObject *swig_obj[1] ;
11966
11967 (void)self;
11968 if (!args) SWIG_fail;
11969 swig_obj[0] = args;
11970 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11971 if (!SWIG_IsOK(ecode1)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11973 }
11974 arg1 = (PLUNICODE)(val1);
11975 plsfci(arg1);
11976 resultobj = SWIG_Py_Void();
11977 return resultobj;
11978fail:
11979 return NULL;
11980}
11981
11982
11983SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11984 PyObject *resultobj = 0;
11985 char *arg1 = (char *) 0 ;
11986 int res1 ;
11987 char *buf1 = 0 ;
11988 int alloc1 = 0 ;
11989 PyObject *swig_obj[1] ;
11990
11991 (void)self;
11992 if (!args) SWIG_fail;
11993 swig_obj[0] = args;
11994 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11995 if (!SWIG_IsOK(res1)) {
11996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11997 }
11998 arg1 = (char *)(buf1);
11999 plsfnam((char const *)arg1);
12000 resultobj = SWIG_Py_Void();
12001 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12002 return resultobj;
12003fail:
12004 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12005 return NULL;
12006}
12007
12008
12009SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
12010 PyObject *resultobj = 0;
12011 PLINT arg1 ;
12012 PLINT arg2 ;
12013 PLINT arg3 ;
12014 int val1 ;
12015 int ecode1 = 0 ;
12016 int val2 ;
12017 int ecode2 = 0 ;
12018 int val3 ;
12019 int ecode3 = 0 ;
12020 PyObject *swig_obj[3] ;
12021
12022 (void)self;
12023 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
12024 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12025 if (!SWIG_IsOK(ecode1)) {
12026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
12027 }
12028 arg1 = (PLINT)(val1);
12029 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12030 if (!SWIG_IsOK(ecode2)) {
12031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
12032 }
12033 arg2 = (PLINT)(val2);
12034 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12035 if (!SWIG_IsOK(ecode3)) {
12036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
12037 }
12038 arg3 = (PLINT)(val3);
12039 plsfont(arg1,arg2,arg3);
12040 resultobj = SWIG_Py_Void();
12041 return resultobj;
12042fail:
12043 return NULL;
12044}
12045
12046
12047SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12048 PyObject *resultobj = 0;
12049 PLFLT **arg1 = (PLFLT **) 0 ;
12050 PLINT arg2 ;
12051 PLINT arg3 ;
12052 defined_func arg4 = (defined_func) 0 ;
12053 PLFLT arg5 ;
12054 PLFLT arg6 ;
12055 PLFLT arg7 ;
12056 PLFLT arg8 ;
12057 PLFLT *arg9 = (PLFLT *) 0 ;
12058 PLINT arg10 ;
12059 PLFLT arg11 ;
12060 PLINT arg12 ;
12061 PLFLT arg13 ;
12062 fill_func arg14 = (fill_func) 0 ;
12063 PLBOOL arg15 ;
12064 pltr_func arg16 = (pltr_func) 0 ;
12065 PLPointer arg17 = (PLPointer) 0 ;
12066 PyArrayObject *tmp1 = NULL ;
12067 double val5 ;
12068 int ecode5 = 0 ;
12069 double val6 ;
12070 int ecode6 = 0 ;
12071 double val7 ;
12072 int ecode7 = 0 ;
12073 double val8 ;
12074 int ecode8 = 0 ;
12075 PyArrayObject *tmp9 = NULL ;
12076 double val11 ;
12077 int ecode11 = 0 ;
12078 int val12 ;
12079 int ecode12 = 0 ;
12080 double val13 ;
12081 int ecode13 = 0 ;
12082 int val15 ;
12083 int ecode15 = 0 ;
12084 PyObject *swig_obj[12] ;
12085
12086 {
12087 python_pltr = 0;
12088 arg16 = NULL;
12089 }
12090 {
12091 arg17 = NULL;
12092 }
12093 {
12094 arg4 = NULL;
12095 }
12096 {
12097 arg14 = plfill;
12098 }
12099 (void)self;
12100 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12101 {
12102 int i, size;
12103 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12104 if ( tmp1 == NULL )
12105 return NULL;
12106 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12107 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12108 size = arg3;
12109 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12110 for ( i = 0; i < arg2; i++ )
12111 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12112 }
12113 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12114 if (!SWIG_IsOK(ecode5)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12116 }
12117 arg5 = (PLFLT)(val5);
12118 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12119 if (!SWIG_IsOK(ecode6)) {
12120 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12121 }
12122 arg6 = (PLFLT)(val6);
12123 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12124 if (!SWIG_IsOK(ecode7)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12126 }
12127 arg7 = (PLFLT)(val7);
12128 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12129 if (!SWIG_IsOK(ecode8)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12131 }
12132 arg8 = (PLFLT)(val8);
12133 {
12134 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12135 if ( tmp9 == NULL )
12136 return NULL;
12137 arg10 = PyArray_DIMS( tmp9 )[0];
12138 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12139 }
12140 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12141 if (!SWIG_IsOK(ecode11)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12143 }
12144 arg11 = (PLFLT)(val11);
12145 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12146 if (!SWIG_IsOK(ecode12)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12148 }
12149 arg12 = (PLINT)(val12);
12150 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12151 if (!SWIG_IsOK(ecode13)) {
12152 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12153 }
12154 arg13 = (PLFLT)(val13);
12155 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12156 if (!SWIG_IsOK(ecode15)) {
12157 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12158 }
12159 arg15 = (PLBOOL)(val15);
12160 if (swig_obj[10]) {
12161 {
12162 // it must be a callable or None
12163 if ( swig_obj[10] == Py_None )
12164 {
12165 arg16 = NULL;
12166 }
12167 else
12168 {
12169 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12170 {
12171 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12172 return NULL;
12173 }
12174 arg16 = marshal_pltr( swig_obj[10] );
12175 }
12176 }
12177 }
12178 if (swig_obj[11]) {
12179 {
12180 if ( swig_obj[11] == Py_None )
12181 arg17 = NULL;
12182 else
12183 {
12184 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12185 }
12186 }
12187 }
12188 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12189 resultobj = SWIG_Py_Void();
12190 {
12191 Py_CLEAR( tmp1 );
12192 free( arg1 );
12193 }
12194 {
12195 Py_CLEAR( tmp9 );
12196 }
12197 {
12198 cleanup_pltr();
12199 }
12200 {
12202 }
12203 return resultobj;
12204fail:
12205 {
12206 Py_CLEAR( tmp1 );
12207 free( arg1 );
12208 }
12209 {
12210 Py_CLEAR( tmp9 );
12211 }
12212 {
12213 cleanup_pltr();
12214 }
12215 {
12217 }
12218 return NULL;
12219}
12220
12221
12222SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12223 PyObject *resultobj = 0;
12224 PLFLT **arg1 = (PLFLT **) 0 ;
12225 PLINT arg2 ;
12226 PLINT arg3 ;
12227 defined_func arg4 = (defined_func) 0 ;
12228 PLFLT arg5 ;
12229 PLFLT arg6 ;
12230 PLFLT arg7 ;
12231 PLFLT arg8 ;
12232 PLFLT arg9 ;
12233 PLFLT arg10 ;
12234 PLINT arg11 ;
12235 PLFLT arg12 ;
12236 PLFLT arg13 ;
12237 PLINT arg14 ;
12238 PLFLT arg15 ;
12239 PLINT arg16 ;
12240 PLFLT arg17 ;
12241 fill_func arg18 = (fill_func) 0 ;
12242 PLBOOL arg19 ;
12243 pltr_func arg20 = (pltr_func) 0 ;
12244 PLPointer arg21 = (PLPointer) 0 ;
12245 PyArrayObject *tmp1 = NULL ;
12246 double val5 ;
12247 int ecode5 = 0 ;
12248 double val6 ;
12249 int ecode6 = 0 ;
12250 double val7 ;
12251 int ecode7 = 0 ;
12252 double val8 ;
12253 int ecode8 = 0 ;
12254 double val9 ;
12255 int ecode9 = 0 ;
12256 double val10 ;
12257 int ecode10 = 0 ;
12258 int val11 ;
12259 int ecode11 = 0 ;
12260 double val12 ;
12261 int ecode12 = 0 ;
12262 double val13 ;
12263 int ecode13 = 0 ;
12264 int val14 ;
12265 int ecode14 = 0 ;
12266 double val15 ;
12267 int ecode15 = 0 ;
12268 int val16 ;
12269 int ecode16 = 0 ;
12270 double val17 ;
12271 int ecode17 = 0 ;
12272 int val19 ;
12273 int ecode19 = 0 ;
12274 PyObject *swig_obj[17] ;
12275
12276 {
12277 python_pltr = 0;
12278 arg20 = NULL;
12279 }
12280 {
12281 arg21 = NULL;
12282 }
12283 {
12284 arg4 = NULL;
12285 }
12286 {
12287 arg18 = plfill;
12288 }
12289 (void)self;
12290 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12291 {
12292 int i, size;
12293 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12294 if ( tmp1 == NULL )
12295 return NULL;
12296 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12297 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12298 size = arg3;
12299 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12300 for ( i = 0; i < arg2; i++ )
12301 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12302 }
12303 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12304 if (!SWIG_IsOK(ecode5)) {
12305 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12306 }
12307 arg5 = (PLFLT)(val5);
12308 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12309 if (!SWIG_IsOK(ecode6)) {
12310 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12311 }
12312 arg6 = (PLFLT)(val6);
12313 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12314 if (!SWIG_IsOK(ecode7)) {
12315 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12316 }
12317 arg7 = (PLFLT)(val7);
12318 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12319 if (!SWIG_IsOK(ecode8)) {
12320 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12321 }
12322 arg8 = (PLFLT)(val8);
12323 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12324 if (!SWIG_IsOK(ecode9)) {
12325 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12326 }
12327 arg9 = (PLFLT)(val9);
12328 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12329 if (!SWIG_IsOK(ecode10)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12331 }
12332 arg10 = (PLFLT)(val10);
12333 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12334 if (!SWIG_IsOK(ecode11)) {
12335 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12336 }
12337 arg11 = (PLINT)(val11);
12338 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12339 if (!SWIG_IsOK(ecode12)) {
12340 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12341 }
12342 arg12 = (PLFLT)(val12);
12343 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12344 if (!SWIG_IsOK(ecode13)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12346 }
12347 arg13 = (PLFLT)(val13);
12348 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12349 if (!SWIG_IsOK(ecode14)) {
12350 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12351 }
12352 arg14 = (PLINT)(val14);
12353 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12354 if (!SWIG_IsOK(ecode15)) {
12355 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12356 }
12357 arg15 = (PLFLT)(val15);
12358 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12359 if (!SWIG_IsOK(ecode16)) {
12360 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12361 }
12362 arg16 = (PLINT)(val16);
12363 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12364 if (!SWIG_IsOK(ecode17)) {
12365 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12366 }
12367 arg17 = (PLFLT)(val17);
12368 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12369 if (!SWIG_IsOK(ecode19)) {
12370 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12371 }
12372 arg19 = (PLBOOL)(val19);
12373 if (swig_obj[15]) {
12374 {
12375 // it must be a callable or None
12376 if ( swig_obj[15] == Py_None )
12377 {
12378 arg20 = NULL;
12379 }
12380 else
12381 {
12382 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12383 {
12384 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12385 return NULL;
12386 }
12387 arg20 = marshal_pltr( swig_obj[15] );
12388 }
12389 }
12390 }
12391 if (swig_obj[16]) {
12392 {
12393 if ( swig_obj[16] == Py_None )
12394 arg21 = NULL;
12395 else
12396 {
12397 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12398 }
12399 }
12400 }
12401 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12402 resultobj = SWIG_Py_Void();
12403 {
12404 Py_CLEAR( tmp1 );
12405 free( arg1 );
12406 }
12407 {
12408 cleanup_pltr();
12409 }
12410 {
12412 }
12413 return resultobj;
12414fail:
12415 {
12416 Py_CLEAR( tmp1 );
12417 free( arg1 );
12418 }
12419 {
12420 cleanup_pltr();
12421 }
12422 {
12424 }
12425 return NULL;
12426}
12427
12428
12429SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12430 PyObject *resultobj = 0;
12431 label_func arg1 = (label_func) 0 ;
12432 PLPointer arg2 = (PLPointer) 0 ;
12433 int res2 ;
12434 PyObject *swig_obj[2] ;
12435
12436 (void)self;
12437 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12438 {
12439 // Release reference to previous function if applicable
12440 if ( python_label )
12441 {
12442 Py_CLEAR( python_label );
12443 python_label = 0;
12444 }
12445 // it must be a callable or None
12446 if ( swig_obj[0] == Py_None )
12447 {
12448 arg1 = NULL;
12449 }
12450 else
12451 {
12452 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12453 {
12454 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12455 return NULL;
12456 }
12457 // hold a reference to it
12458 Py_XINCREF( (PyObject *) swig_obj[0] );
12459 python_label = (PyObject *) swig_obj[0];
12460 // this function handles calling the python function
12461 arg1 = do_label_callback;
12462 }
12463 }
12464 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12465 if (!SWIG_IsOK(res2)) {
12466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12467 }
12468 plslabelfunc(arg1,arg2);
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471fail:
12472 return NULL;
12473}
12474
12475
12476SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12477 PyObject *resultobj = 0;
12478 PLFLT arg1 ;
12479 PLFLT arg2 ;
12480 double val1 ;
12481 int ecode1 = 0 ;
12482 double val2 ;
12483 int ecode2 = 0 ;
12484 PyObject *swig_obj[2] ;
12485
12486 (void)self;
12487 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12488 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12489 if (!SWIG_IsOK(ecode1)) {
12490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12491 }
12492 arg1 = (PLFLT)(val1);
12493 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12494 if (!SWIG_IsOK(ecode2)) {
12495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12496 }
12497 arg2 = (PLFLT)(val2);
12498 plsmaj(arg1,arg2);
12499 resultobj = SWIG_Py_Void();
12500 return resultobj;
12501fail:
12502 return NULL;
12503}
12504
12505
12506SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12507 PyObject *resultobj = 0;
12508 PLINT arg1 ;
12509 PLINT arg2 ;
12510 void *arg3 = (void *) 0 ;
12511 int val1 ;
12512 int ecode1 = 0 ;
12513 int val2 ;
12514 int ecode2 = 0 ;
12515 PyObject *swig_obj[3] ;
12516
12517 (void)self;
12518 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12519 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12520 if (!SWIG_IsOK(ecode1)) {
12521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12522 }
12523 arg1 = (PLINT)(val1);
12524 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12525 if (!SWIG_IsOK(ecode2)) {
12526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12527 }
12528 arg2 = (PLINT)(val2);
12529 {
12530 int res; void *buf = 0;
12531#ifndef Py_LIMITED_API
12532 Py_buffer view;
12533 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12534#else
12535#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12536#pragma GCC diagnostic push
12537#pragma GCC diagnostic ignored "-Wdeprecated"
12538#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12539#elif defined(_MSC_VER)
12540#pragma warning(push)
12541#pragma warning(disable: 4996)
12542#endif
12543 Py_ssize_t size;
12544 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12545#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12546#pragma GCC diagnostic pop
12547#elif defined(_MSC_VER)
12548#pragma warning(pop)
12549#endif
12550#endif
12551 if (res < 0) {
12552 PyErr_Clear();
12553 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12554 }
12555#ifndef Py_LIMITED_API
12556 buf = view.buf;
12557 PyBuffer_Release(&view);
12558#endif
12559 arg3 = (void *) buf;
12560 }
12561 plsmem(arg1,arg2,arg3);
12562 resultobj = SWIG_Py_Void();
12563 return resultobj;
12564fail:
12565 return NULL;
12566}
12567
12568
12569SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12570 PyObject *resultobj = 0;
12571 PLINT arg1 ;
12572 PLINT arg2 ;
12573 void *arg3 = (void *) 0 ;
12574 int val1 ;
12575 int ecode1 = 0 ;
12576 int val2 ;
12577 int ecode2 = 0 ;
12578 PyObject *swig_obj[3] ;
12579
12580 (void)self;
12581 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12582 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12583 if (!SWIG_IsOK(ecode1)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12585 }
12586 arg1 = (PLINT)(val1);
12587 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12588 if (!SWIG_IsOK(ecode2)) {
12589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12590 }
12591 arg2 = (PLINT)(val2);
12592 {
12593 int res; void *buf = 0;
12594#ifndef Py_LIMITED_API
12595 Py_buffer view;
12596 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12597#else
12598#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12599#pragma GCC diagnostic push
12600#pragma GCC diagnostic ignored "-Wdeprecated"
12601#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12602#elif defined(_MSC_VER)
12603#pragma warning(push)
12604#pragma warning(disable: 4996)
12605#endif
12606 Py_ssize_t size;
12607 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12608#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12609#pragma GCC diagnostic pop
12610#elif defined(_MSC_VER)
12611#pragma warning(pop)
12612#endif
12613#endif
12614 if (res < 0) {
12615 PyErr_Clear();
12616 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12617 }
12618#ifndef Py_LIMITED_API
12619 buf = view.buf;
12620 PyBuffer_Release(&view);
12621#endif
12622 arg3 = (void *) buf;
12623 }
12624 plsmema(arg1,arg2,arg3);
12625 resultobj = SWIG_Py_Void();
12626 return resultobj;
12627fail:
12628 return NULL;
12629}
12630
12631
12632SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12633 PyObject *resultobj = 0;
12634 PLFLT arg1 ;
12635 PLFLT arg2 ;
12636 double val1 ;
12637 int ecode1 = 0 ;
12638 double val2 ;
12639 int ecode2 = 0 ;
12640 PyObject *swig_obj[2] ;
12641
12642 (void)self;
12643 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12644 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12645 if (!SWIG_IsOK(ecode1)) {
12646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12647 }
12648 arg1 = (PLFLT)(val1);
12649 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12650 if (!SWIG_IsOK(ecode2)) {
12651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12652 }
12653 arg2 = (PLFLT)(val2);
12654 plsmin(arg1,arg2);
12655 resultobj = SWIG_Py_Void();
12656 return resultobj;
12657fail:
12658 return NULL;
12659}
12660
12661
12662SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12663 PyObject *resultobj = 0;
12664 PLINT arg1 ;
12665 int val1 ;
12666 int ecode1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 (void)self;
12670 if (!args) SWIG_fail;
12671 swig_obj[0] = args;
12672 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12673 if (!SWIG_IsOK(ecode1)) {
12674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12675 }
12676 arg1 = (PLINT)(val1);
12677 plsori(arg1);
12678 resultobj = SWIG_Py_Void();
12679 return resultobj;
12680fail:
12681 return NULL;
12682}
12683
12684
12685SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12686 PyObject *resultobj = 0;
12687 PLFLT arg1 ;
12688 PLFLT arg2 ;
12689 PLINT arg3 ;
12690 PLINT arg4 ;
12691 PLINT arg5 ;
12692 PLINT arg6 ;
12693 double val1 ;
12694 int ecode1 = 0 ;
12695 double val2 ;
12696 int ecode2 = 0 ;
12697 int val3 ;
12698 int ecode3 = 0 ;
12699 int val4 ;
12700 int ecode4 = 0 ;
12701 int val5 ;
12702 int ecode5 = 0 ;
12703 int val6 ;
12704 int ecode6 = 0 ;
12705 PyObject *swig_obj[6] ;
12706
12707 (void)self;
12708 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12709 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12710 if (!SWIG_IsOK(ecode1)) {
12711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12712 }
12713 arg1 = (PLFLT)(val1);
12714 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12715 if (!SWIG_IsOK(ecode2)) {
12716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12717 }
12718 arg2 = (PLFLT)(val2);
12719 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12720 if (!SWIG_IsOK(ecode3)) {
12721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12722 }
12723 arg3 = (PLINT)(val3);
12724 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12725 if (!SWIG_IsOK(ecode4)) {
12726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12727 }
12728 arg4 = (PLINT)(val4);
12729 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12730 if (!SWIG_IsOK(ecode5)) {
12731 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12732 }
12733 arg5 = (PLINT)(val5);
12734 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12735 if (!SWIG_IsOK(ecode6)) {
12736 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12737 }
12738 arg6 = (PLINT)(val6);
12739 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12740 resultobj = SWIG_Py_Void();
12741 return resultobj;
12742fail:
12743 return NULL;
12744}
12745
12746
12747SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12748 PyObject *resultobj = 0;
12749 char *arg1 = (char *) 0 ;
12750 int res1 ;
12751 char *buf1 = 0 ;
12752 int alloc1 = 0 ;
12753 PyObject *swig_obj[1] ;
12754
12755 (void)self;
12756 if (!args) SWIG_fail;
12757 swig_obj[0] = args;
12758 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12759 if (!SWIG_IsOK(res1)) {
12760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12761 }
12762 arg1 = (char *)(buf1);
12763 plspal0((char const *)arg1);
12764 resultobj = SWIG_Py_Void();
12765 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12766 return resultobj;
12767fail:
12768 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12769 return NULL;
12770}
12771
12772
12773SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12774 PyObject *resultobj = 0;
12775 char *arg1 = (char *) 0 ;
12776 PLBOOL arg2 ;
12777 int res1 ;
12778 char *buf1 = 0 ;
12779 int alloc1 = 0 ;
12780 int val2 ;
12781 int ecode2 = 0 ;
12782 PyObject *swig_obj[2] ;
12783
12784 (void)self;
12785 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12786 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12787 if (!SWIG_IsOK(res1)) {
12788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12789 }
12790 arg1 = (char *)(buf1);
12791 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12792 if (!SWIG_IsOK(ecode2)) {
12793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12794 }
12795 arg2 = (PLBOOL)(val2);
12796 plspal1((char const *)arg1,arg2);
12797 resultobj = SWIG_Py_Void();
12798 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12799 return resultobj;
12800fail:
12801 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12802 return NULL;
12803}
12804
12805
12806SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12807 PyObject *resultobj = 0;
12808 PLBOOL arg1 ;
12809 int val1 ;
12810 int ecode1 = 0 ;
12811 PyObject *swig_obj[1] ;
12812
12813 (void)self;
12814 if (!args) SWIG_fail;
12815 swig_obj[0] = args;
12816 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12817 if (!SWIG_IsOK(ecode1)) {
12818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12819 }
12820 arg1 = (PLBOOL)(val1);
12821 plspause(arg1);
12822 resultobj = SWIG_Py_Void();
12823 return resultobj;
12824fail:
12825 return NULL;
12826}
12827
12828
12829SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12830 PyObject *resultobj = 0;
12831 PLINT arg1 ;
12832 int val1 ;
12833 int ecode1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 (void)self;
12837 if (!args) SWIG_fail;
12838 swig_obj[0] = args;
12839 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12840 if (!SWIG_IsOK(ecode1)) {
12841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12842 }
12843 arg1 = (PLINT)(val1);
12844 plsstrm(arg1);
12845 resultobj = SWIG_Py_Void();
12846 return resultobj;
12847fail:
12848 return NULL;
12849}
12850
12851
12852SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12853 PyObject *resultobj = 0;
12854 PLINT arg1 ;
12855 PLINT arg2 ;
12856 int val1 ;
12857 int ecode1 = 0 ;
12858 int val2 ;
12859 int ecode2 = 0 ;
12860 PyObject *swig_obj[2] ;
12861
12862 (void)self;
12863 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12864 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12865 if (!SWIG_IsOK(ecode1)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12867 }
12868 arg1 = (PLINT)(val1);
12869 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12870 if (!SWIG_IsOK(ecode2)) {
12871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12872 }
12873 arg2 = (PLINT)(val2);
12874 plssub(arg1,arg2);
12875 resultobj = SWIG_Py_Void();
12876 return resultobj;
12877fail:
12878 return NULL;
12879}
12880
12881
12882SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12883 PyObject *resultobj = 0;
12884 PLFLT arg1 ;
12885 PLFLT arg2 ;
12886 double val1 ;
12887 int ecode1 = 0 ;
12888 double val2 ;
12889 int ecode2 = 0 ;
12890 PyObject *swig_obj[2] ;
12891
12892 (void)self;
12893 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12894 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12895 if (!SWIG_IsOK(ecode1)) {
12896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12897 }
12898 arg1 = (PLFLT)(val1);
12899 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12900 if (!SWIG_IsOK(ecode2)) {
12901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12902 }
12903 arg2 = (PLFLT)(val2);
12904 plssym(arg1,arg2);
12905 resultobj = SWIG_Py_Void();
12906 return resultobj;
12907fail:
12908 return NULL;
12909}
12910
12911
12912SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12913 PyObject *resultobj = 0;
12914 PLINT arg1 ;
12915 PLINT arg2 ;
12916 int val1 ;
12917 int ecode1 = 0 ;
12918 int val2 ;
12919 int ecode2 = 0 ;
12920 PyObject *swig_obj[2] ;
12921
12922 (void)self;
12923 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12924 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12925 if (!SWIG_IsOK(ecode1)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12927 }
12928 arg1 = (PLINT)(val1);
12929 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12930 if (!SWIG_IsOK(ecode2)) {
12931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12932 }
12933 arg2 = (PLINT)(val2);
12934 plstar(arg1,arg2);
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937fail:
12938 return NULL;
12939}
12940
12941
12942SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12943 PyObject *resultobj = 0;
12944 char *arg1 = (char *) 0 ;
12945 PLINT arg2 ;
12946 PLINT arg3 ;
12947 int res1 ;
12948 char *buf1 = 0 ;
12949 int alloc1 = 0 ;
12950 int val2 ;
12951 int ecode2 = 0 ;
12952 int val3 ;
12953 int ecode3 = 0 ;
12954 PyObject *swig_obj[3] ;
12955
12956 (void)self;
12957 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12958 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12959 if (!SWIG_IsOK(res1)) {
12960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12961 }
12962 arg1 = (char *)(buf1);
12963 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12964 if (!SWIG_IsOK(ecode2)) {
12965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12966 }
12967 arg2 = (PLINT)(val2);
12968 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12969 if (!SWIG_IsOK(ecode3)) {
12970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12971 }
12972 arg3 = (PLINT)(val3);
12973 plstart((char const *)arg1,arg2,arg3);
12974 resultobj = SWIG_Py_Void();
12975 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12976 return resultobj;
12977fail:
12978 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12979 return NULL;
12980}
12981
12982
12983SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12984 PyObject *resultobj = 0;
12985 ct_func arg1 = (ct_func) 0 ;
12986 PLPointer arg2 = (PLPointer) 0 ;
12987 int res2 ;
12988 PyObject *swig_obj[2] ;
12989
12990 {
12991 python_ct = 0;
12992 arg1 = NULL;
12993 }
12994 (void)self;
12995 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12996 if (swig_obj[0]) {
12997 {
12998 if ( python_ct )
12999 cleanup_ct();
13000 // it must be a callable or none
13001 if ( swig_obj[0] == Py_None )
13002 {
13003 arg1 = NULL;
13004 }
13005 else
13006 {
13007 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13008 {
13009 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
13010 return NULL;
13011 }
13012 arg1 = marshal_ct( swig_obj[0] );
13013 }
13014 }
13015 }
13016 if (swig_obj[1]) {
13017 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
13018 if (!SWIG_IsOK(res2)) {
13019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
13020 }
13021 }
13022 plstransform(arg1,arg2);
13023 resultobj = SWIG_Py_Void();
13024 return resultobj;
13025fail:
13026 return NULL;
13027}
13028
13029
13030SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
13031 PyObject *resultobj = 0;
13032 PLINT arg1 ;
13033 PLFLT *arg2 = (PLFLT *) 0 ;
13034 PLFLT *arg3 = (PLFLT *) 0 ;
13035 char *arg4 = (char *) 0 ;
13036 PyArrayObject *tmp1 = NULL ;
13037 PyArrayObject *tmp3 = NULL ;
13038 int res4 ;
13039 char *buf4 = 0 ;
13040 int alloc4 = 0 ;
13041 PyObject *swig_obj[3] ;
13042
13043 (void)self;
13044 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13045 {
13046 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13047 if ( tmp1 == NULL )
13048 return NULL;
13049 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13050 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13051 }
13052 {
13053 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13054 if ( tmp3 == NULL )
13055 return NULL;
13056 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13057 {
13058 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13059 return NULL;
13060 }
13061 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13062 }
13063 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13064 if (!SWIG_IsOK(res4)) {
13065 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13066 }
13067 arg4 = (char *)(buf4);
13068 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13069 resultobj = SWIG_Py_Void();
13070 {
13071 Py_CLEAR( tmp1 );
13072 }
13073 {
13074 Py_CLEAR( tmp3 );
13075 }
13076 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13077 return resultobj;
13078fail:
13079 {
13080 Py_CLEAR( tmp1 );
13081 }
13082 {
13083 Py_CLEAR( tmp3 );
13084 }
13085 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13086 return NULL;
13087}
13088
13089
13090SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13091 PyObject *resultobj = 0;
13092 PLINT arg1 ;
13093 PLFLT *arg2 = (PLFLT *) 0 ;
13094 PLFLT *arg3 = (PLFLT *) 0 ;
13095 PLFLT *arg4 = (PLFLT *) 0 ;
13096 char *arg5 = (char *) 0 ;
13097 PyArrayObject *tmp1 = NULL ;
13098 PyArrayObject *tmp3 = NULL ;
13099 PyArrayObject *tmp4 = NULL ;
13100 int res5 ;
13101 char *buf5 = 0 ;
13102 int alloc5 = 0 ;
13103 PyObject *swig_obj[4] ;
13104
13105 (void)self;
13106 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13107 {
13108 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13109 if ( tmp1 == NULL )
13110 return NULL;
13111 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13112 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13113 }
13114 {
13115 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13116 if ( tmp3 == NULL )
13117 return NULL;
13118 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13119 {
13120 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13121 return NULL;
13122 }
13123 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13124 }
13125 {
13126 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13127 if ( tmp4 == NULL )
13128 return NULL;
13129 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13130 {
13131 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13132 return NULL;
13133 }
13134 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13135 }
13136 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13137 if (!SWIG_IsOK(res5)) {
13138 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13139 }
13140 arg5 = (char *)(buf5);
13141 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13142 resultobj = SWIG_Py_Void();
13143 {
13144 Py_CLEAR( tmp1 );
13145 }
13146 {
13147 Py_CLEAR( tmp3 );
13148 }
13149 {
13150 Py_CLEAR( tmp4 );
13151 }
13152 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13153 return resultobj;
13154fail:
13155 {
13156 Py_CLEAR( tmp1 );
13157 }
13158 {
13159 Py_CLEAR( tmp3 );
13160 }
13161 {
13162 Py_CLEAR( tmp4 );
13163 }
13164 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13165 return NULL;
13166}
13167
13168
13169SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13170 PyObject *resultobj = 0;
13171 PLINT arg1 ;
13172 PLINT arg2 ;
13173 PLFLT arg3 ;
13174 PLFLT arg4 ;
13175 int val1 ;
13176 int ecode1 = 0 ;
13177 int val2 ;
13178 int ecode2 = 0 ;
13179 double val3 ;
13180 int ecode3 = 0 ;
13181 double val4 ;
13182 int ecode4 = 0 ;
13183 PyObject *swig_obj[4] ;
13184
13185 (void)self;
13186 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13187 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13188 if (!SWIG_IsOK(ecode1)) {
13189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13190 }
13191 arg1 = (PLINT)(val1);
13192 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13193 if (!SWIG_IsOK(ecode2)) {
13194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13195 }
13196 arg2 = (PLINT)(val2);
13197 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13198 if (!SWIG_IsOK(ecode3)) {
13199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13200 }
13201 arg3 = (PLFLT)(val3);
13202 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13203 if (!SWIG_IsOK(ecode4)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13205 }
13206 arg4 = (PLFLT)(val4);
13207 plstripa(arg1,arg2,arg3,arg4);
13208 resultobj = SWIG_Py_Void();
13209 return resultobj;
13210fail:
13211 return NULL;
13212}
13213
13214
13215SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13216 PyObject *resultobj = 0;
13217 PLINT *arg1 = (PLINT *) 0 ;
13218 char *arg2 = (char *) 0 ;
13219 char *arg3 = (char *) 0 ;
13220 PLFLT arg4 ;
13221 PLFLT arg5 ;
13222 PLFLT arg6 ;
13223 PLFLT arg7 ;
13224 PLFLT arg8 ;
13225 PLFLT arg9 ;
13226 PLFLT arg10 ;
13227 PLBOOL arg11 ;
13228 PLBOOL arg12 ;
13229 PLINT arg13 ;
13230 PLINT arg14 ;
13231 PLINT *arg15 = (PLINT *) 0 ;
13232 PLINT *arg16 = (PLINT *) 0 ;
13233 char **arg17 = (char **) (char **)0 ;
13234 char *arg18 = (char *) 0 ;
13235 char *arg19 = (char *) 0 ;
13236 char *arg20 = (char *) 0 ;
13237 PLINT temp1 ;
13238 int res1 = SWIG_TMPOBJ ;
13239 int res2 ;
13240 char *buf2 = 0 ;
13241 int alloc2 = 0 ;
13242 int res3 ;
13243 char *buf3 = 0 ;
13244 int alloc3 = 0 ;
13245 double val4 ;
13246 int ecode4 = 0 ;
13247 double val5 ;
13248 int ecode5 = 0 ;
13249 double val6 ;
13250 int ecode6 = 0 ;
13251 double val7 ;
13252 int ecode7 = 0 ;
13253 double val8 ;
13254 int ecode8 = 0 ;
13255 double val9 ;
13256 int ecode9 = 0 ;
13257 double val10 ;
13258 int ecode10 = 0 ;
13259 int val11 ;
13260 int ecode11 = 0 ;
13261 int val12 ;
13262 int ecode12 = 0 ;
13263 int val13 ;
13264 int ecode13 = 0 ;
13265 int val14 ;
13266 int ecode14 = 0 ;
13267 PyArrayObject *tmp15 = NULL ;
13268 PyArrayObject *tmp16 = NULL ;
13269 char **tmp17 = NULL ;
13270 int res18 ;
13271 char *buf18 = 0 ;
13272 int alloc18 = 0 ;
13273 int res19 ;
13274 char *buf19 = 0 ;
13275 int alloc19 = 0 ;
13276 int res20 ;
13277 char *buf20 = 0 ;
13278 int alloc20 = 0 ;
13279 PyObject *swig_obj[19] ;
13280
13281 arg1 = &temp1;
13282 (void)self;
13283 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13284 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13285 if (!SWIG_IsOK(res2)) {
13286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13287 }
13288 arg2 = (char *)(buf2);
13289 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13290 if (!SWIG_IsOK(res3)) {
13291 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13292 }
13293 arg3 = (char *)(buf3);
13294 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13295 if (!SWIG_IsOK(ecode4)) {
13296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13297 }
13298 arg4 = (PLFLT)(val4);
13299 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13300 if (!SWIG_IsOK(ecode5)) {
13301 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13302 }
13303 arg5 = (PLFLT)(val5);
13304 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13305 if (!SWIG_IsOK(ecode6)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13307 }
13308 arg6 = (PLFLT)(val6);
13309 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13310 if (!SWIG_IsOK(ecode7)) {
13311 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13312 }
13313 arg7 = (PLFLT)(val7);
13314 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13315 if (!SWIG_IsOK(ecode8)) {
13316 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13317 }
13318 arg8 = (PLFLT)(val8);
13319 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13320 if (!SWIG_IsOK(ecode9)) {
13321 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13322 }
13323 arg9 = (PLFLT)(val9);
13324 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13325 if (!SWIG_IsOK(ecode10)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13327 }
13328 arg10 = (PLFLT)(val10);
13329 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13330 if (!SWIG_IsOK(ecode11)) {
13331 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13332 }
13333 arg11 = (PLBOOL)(val11);
13334 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13335 if (!SWIG_IsOK(ecode12)) {
13336 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13337 }
13338 arg12 = (PLBOOL)(val12);
13339 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13340 if (!SWIG_IsOK(ecode13)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13342 }
13343 arg13 = (PLINT)(val13);
13344 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13345 if (!SWIG_IsOK(ecode14)) {
13346 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13347 }
13348 arg14 = (PLINT)(val14);
13349 {
13350 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13351 if ( tmp15 == NULL )
13352 return NULL;
13353 Alen = PyArray_DIMS( tmp15 )[0];
13354 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13355 }
13356 {
13357 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13358 if ( tmp16 == NULL )
13359 return NULL;
13360 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13361 {
13362 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13363 return NULL;
13364 }
13365 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13366 }
13367 {
13368 int i;
13369 PyObject *elt, *unicode_string;
13370
13371 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13372 {
13373 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13374 return NULL;
13375 }
13376 if ( Alen != 4 )
13377 {
13378 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13379 return NULL;
13380 }
13381 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13382 if ( tmp17 == NULL )
13383 return NULL;
13384 arg17 = tmp17;
13385 for ( i = 0; i < 4; i++ )
13386 {
13387 arg17[i] = NULL;
13388 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13389 if ( PyString_Check( elt ) )
13390 {
13391 arg17[i] = PyString_AsString( elt );
13392 }
13393 else if ( PyUnicode_Check( elt ) )
13394 {
13395 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13396 arg17[i] = PyBytes_AS_STRING( unicode_string );
13397 }
13398 if ( arg17[i] == NULL )
13399 {
13400 free( tmp17 );
13401 return NULL;
13402 }
13403 }
13404 }
13405 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13406 if (!SWIG_IsOK(res18)) {
13407 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13408 }
13409 arg18 = (char *)(buf18);
13410 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13411 if (!SWIG_IsOK(res19)) {
13412 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13413 }
13414 arg19 = (char *)(buf19);
13415 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13416 if (!SWIG_IsOK(res20)) {
13417 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13418 }
13419 arg20 = (char *)(buf20);
13420 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);
13421 resultobj = SWIG_Py_Void();
13422 if (SWIG_IsTmpObj(res1)) {
13423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
13424 } else {
13425 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
13427 }
13428 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13429 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13430 {
13431 Py_CLEAR( tmp15 );
13432 }
13433 {
13434 Py_CLEAR( tmp16 );
13435 }
13436 {
13437 free( tmp17 );
13438 }
13439 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13440 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13441 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13442 return resultobj;
13443fail:
13444 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13445 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13446 {
13447 Py_CLEAR( tmp15 );
13448 }
13449 {
13450 Py_CLEAR( tmp16 );
13451 }
13452 {
13453 free( tmp17 );
13454 }
13455 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13456 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13457 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13458 return NULL;
13459}
13460
13461
13462SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13463 PyObject *resultobj = 0;
13464 PLINT arg1 ;
13465 int val1 ;
13466 int ecode1 = 0 ;
13467 PyObject *swig_obj[1] ;
13468
13469 (void)self;
13470 if (!args) SWIG_fail;
13471 swig_obj[0] = args;
13472 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13473 if (!SWIG_IsOK(ecode1)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13475 }
13476 arg1 = (PLINT)(val1);
13477 plstripd(arg1);
13478 resultobj = SWIG_Py_Void();
13479 return resultobj;
13480fail:
13481 return NULL;
13482}
13483
13484
13485SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13486 PyObject *resultobj = 0;
13487 PLINT arg1 ;
13488 PLINT *arg2 = (PLINT *) 0 ;
13489 PLINT *arg3 = (PLINT *) 0 ;
13490 PyArrayObject *tmp1 = NULL ;
13491 PyArrayObject *tmp3 = NULL ;
13492 PyObject *swig_obj[2] ;
13493
13494 (void)self;
13495 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13496 {
13497 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13498 if ( tmp1 == NULL )
13499 return NULL;
13500 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13501 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13502 }
13503 {
13504 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13505 if ( tmp3 == NULL )
13506 return NULL;
13507 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13508 {
13509 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13510 return NULL;
13511 }
13512 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13513 }
13514 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13515 resultobj = SWIG_Py_Void();
13516 {
13517 Py_CLEAR( tmp1 );
13518 }
13519 {
13520 Py_CLEAR( tmp3 );
13521 }
13522 return resultobj;
13523fail:
13524 {
13525 Py_CLEAR( tmp1 );
13526 }
13527 {
13528 Py_CLEAR( tmp3 );
13529 }
13530 return NULL;
13531}
13532
13533
13534SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13535 PyObject *resultobj = 0;
13536 PLFLT *arg1 = (PLFLT *) 0 ;
13537 PLFLT *arg2 = (PLFLT *) 0 ;
13538 PLINT arg3 ;
13539 PLBOOL arg4 ;
13540 PyArrayObject *tmp1 = NULL ;
13541 PyArrayObject *tmp2 = NULL ;
13542 int val4 ;
13543 int ecode4 = 0 ;
13544 PyObject *swig_obj[3] ;
13545
13546 (void)self;
13547 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13548 {
13549 if ( swig_obj[0] != Py_None )
13550 {
13551 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13552 if ( tmp1 == NULL )
13553 return NULL;
13554 Alen = PyArray_DIMS( tmp1 )[0];
13555 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13556 }
13557 else
13558 {
13559 arg1 = NULL;
13560 Alen = 0;
13561 }
13562 }
13563 {
13564 if ( swig_obj[1] != Py_None )
13565 {
13566 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13567 if ( tmp2 == NULL )
13568 return NULL;
13569 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13570 {
13571 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13572 return NULL;
13573 }
13574 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13575 arg3 = PyArray_DIMS( tmp2 )[0];
13576 }
13577 else
13578 {
13579 arg2 = NULL;
13580 arg3 = 0;
13581 }
13582 }
13583 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13584 if (!SWIG_IsOK(ecode4)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13586 }
13587 arg4 = (PLBOOL)(val4);
13588 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13589 resultobj = SWIG_Py_Void();
13590 {
13591 Py_CLEAR( tmp1 );
13592 }
13593 {
13594 Py_CLEAR( tmp2 );
13595 }
13596 return resultobj;
13597fail:
13598 {
13599 Py_CLEAR( tmp1 );
13600 }
13601 {
13602 Py_CLEAR( tmp2 );
13603 }
13604 return NULL;
13605}
13606
13607
13608SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13609 PyObject *resultobj = 0;
13610 PLFLT arg1 ;
13611 PLFLT arg2 ;
13612 PLFLT arg3 ;
13613 PLFLT arg4 ;
13614 double val1 ;
13615 int ecode1 = 0 ;
13616 double val2 ;
13617 int ecode2 = 0 ;
13618 double val3 ;
13619 int ecode3 = 0 ;
13620 double val4 ;
13621 int ecode4 = 0 ;
13622 PyObject *swig_obj[4] ;
13623
13624 (void)self;
13625 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13626 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13627 if (!SWIG_IsOK(ecode1)) {
13628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13629 }
13630 arg1 = (PLFLT)(val1);
13631 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13632 if (!SWIG_IsOK(ecode2)) {
13633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13634 }
13635 arg2 = (PLFLT)(val2);
13636 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13637 if (!SWIG_IsOK(ecode3)) {
13638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13639 }
13640 arg3 = (PLFLT)(val3);
13641 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13642 if (!SWIG_IsOK(ecode4)) {
13643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13644 }
13645 arg4 = (PLFLT)(val4);
13646 plsvpa(arg1,arg2,arg3,arg4);
13647 resultobj = SWIG_Py_Void();
13648 return resultobj;
13649fail:
13650 return NULL;
13651}
13652
13653
13654SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13655 PyObject *resultobj = 0;
13656 PLINT arg1 ;
13657 PLINT arg2 ;
13658 int val1 ;
13659 int ecode1 = 0 ;
13660 int val2 ;
13661 int ecode2 = 0 ;
13662 PyObject *swig_obj[2] ;
13663
13664 (void)self;
13665 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13666 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13667 if (!SWIG_IsOK(ecode1)) {
13668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13669 }
13670 arg1 = (PLINT)(val1);
13671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13672 if (!SWIG_IsOK(ecode2)) {
13673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13674 }
13675 arg2 = (PLINT)(val2);
13676 plsxax(arg1,arg2);
13677 resultobj = SWIG_Py_Void();
13678 return resultobj;
13679fail:
13680 return NULL;
13681}
13682
13683
13684SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13685 PyObject *resultobj = 0;
13686 PLINT arg1 ;
13687 PLINT arg2 ;
13688 int val1 ;
13689 int ecode1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 PyObject *swig_obj[2] ;
13693
13694 (void)self;
13695 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13696 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13697 if (!SWIG_IsOK(ecode1)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13699 }
13700 arg1 = (PLINT)(val1);
13701 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13702 if (!SWIG_IsOK(ecode2)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13704 }
13705 arg2 = (PLINT)(val2);
13706 plsyax(arg1,arg2);
13707 resultobj = SWIG_Py_Void();
13708 return resultobj;
13709fail:
13710 return NULL;
13711}
13712
13713
13714SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13715 PyObject *resultobj = 0;
13716 PLINT arg1 ;
13717 PLFLT *arg2 = (PLFLT *) 0 ;
13718 PLFLT *arg3 = (PLFLT *) 0 ;
13719 PLINT arg4 ;
13720 PyArrayObject *tmp1 = NULL ;
13721 PyArrayObject *tmp3 = NULL ;
13722 int val4 ;
13723 int ecode4 = 0 ;
13724 PyObject *swig_obj[3] ;
13725
13726 (void)self;
13727 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13728 {
13729 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13730 if ( tmp1 == NULL )
13731 return NULL;
13732 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13733 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13734 }
13735 {
13736 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13737 if ( tmp3 == NULL )
13738 return NULL;
13739 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13740 {
13741 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13742 return NULL;
13743 }
13744 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13745 }
13746 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13747 if (!SWIG_IsOK(ecode4)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13749 }
13750 arg4 = (PLINT)(val4);
13751 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13752 resultobj = SWIG_Py_Void();
13753 {
13754 Py_CLEAR( tmp1 );
13755 }
13756 {
13757 Py_CLEAR( tmp3 );
13758 }
13759 return resultobj;
13760fail:
13761 {
13762 Py_CLEAR( tmp1 );
13763 }
13764 {
13765 Py_CLEAR( tmp3 );
13766 }
13767 return NULL;
13768}
13769
13770
13771SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13772 PyObject *resultobj = 0;
13773 PLINT arg1 ;
13774 PLINT arg2 ;
13775 int val1 ;
13776 int ecode1 = 0 ;
13777 int val2 ;
13778 int ecode2 = 0 ;
13779 PyObject *swig_obj[2] ;
13780
13781 (void)self;
13782 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13783 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13784 if (!SWIG_IsOK(ecode1)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13786 }
13787 arg1 = (PLINT)(val1);
13788 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13791 }
13792 arg2 = (PLINT)(val2);
13793 plszax(arg1,arg2);
13794 resultobj = SWIG_Py_Void();
13795 return resultobj;
13796fail:
13797 return NULL;
13798}
13799
13800
13801SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13802 PyObject *resultobj = 0;
13803
13804 (void)self;
13805 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13806 pltext();
13807 resultobj = SWIG_Py_Void();
13808 return resultobj;
13809fail:
13810 return NULL;
13811}
13812
13813
13814SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13815 PyObject *resultobj = 0;
13816 char *arg1 = (char *) 0 ;
13817 int res1 ;
13818 char *buf1 = 0 ;
13819 int alloc1 = 0 ;
13820 PyObject *swig_obj[1] ;
13821
13822 (void)self;
13823 if (!args) SWIG_fail;
13824 swig_obj[0] = args;
13825 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13826 if (!SWIG_IsOK(res1)) {
13827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13828 }
13829 arg1 = (char *)(buf1);
13830 pltimefmt((char const *)arg1);
13831 resultobj = SWIG_Py_Void();
13832 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13833 return resultobj;
13834fail:
13835 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13836 return NULL;
13837}
13838
13839
13840SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13841 PyObject *resultobj = 0;
13842 PLFLT arg1 ;
13843 double val1 ;
13844 int ecode1 = 0 ;
13845 PyObject *swig_obj[1] ;
13846
13847 (void)self;
13848 if (!args) SWIG_fail;
13849 swig_obj[0] = args;
13850 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13851 if (!SWIG_IsOK(ecode1)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13853 }
13854 arg1 = (PLFLT)(val1);
13855 plvasp(arg1);
13856 resultobj = SWIG_Py_Void();
13857 return resultobj;
13858fail:
13859 return NULL;
13860}
13861
13862
13863SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13864 PyObject *resultobj = 0;
13865 PLFLT **arg1 = (PLFLT **) 0 ;
13866 PLFLT **arg2 = (PLFLT **) 0 ;
13867 PLINT arg3 ;
13868 PLINT arg4 ;
13869 PLFLT arg5 ;
13870 pltr_func arg6 = (pltr_func) 0 ;
13871 PLPointer arg7 = (PLPointer) 0 ;
13872 PyArrayObject *tmp1 = NULL ;
13873 PyArrayObject *tmp2 = NULL ;
13874 double val5 ;
13875 int ecode5 = 0 ;
13876 PyObject *swig_obj[5] ;
13877
13878 {
13879 python_pltr = 0;
13880 arg6 = NULL;
13881 }
13882 {
13883 arg7 = NULL;
13884 }
13885 (void)self;
13886 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13887 {
13888 int i, size;
13889 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13890 if ( tmp1 == NULL )
13891 return NULL;
13892 Xlen = PyArray_DIMS( tmp1 )[0];
13893 Ylen = PyArray_DIMS( tmp1 )[1];
13894 size = Ylen;
13895 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13896 for ( i = 0; i < Xlen; i++ )
13897 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13898 }
13899 {
13900 int i, size;
13901 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13902 if ( tmp2 == NULL )
13903 return NULL;
13904 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13905 {
13906 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13907 return NULL;
13908 }
13909 arg3 = PyArray_DIMS( tmp2 )[0];
13910 arg4 = PyArray_DIMS( tmp2 )[1];
13911 size = arg4;
13912 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13913 for ( i = 0; i < arg3; i++ )
13914 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13915 }
13916 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13917 if (!SWIG_IsOK(ecode5)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13919 }
13920 arg5 = (PLFLT)(val5);
13921 if (swig_obj[3]) {
13922 {
13923 // it must be a callable or None
13924 if ( swig_obj[3] == Py_None )
13925 {
13926 arg6 = NULL;
13927 }
13928 else
13929 {
13930 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13931 {
13932 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13933 return NULL;
13934 }
13935 arg6 = marshal_pltr( swig_obj[3] );
13936 }
13937 }
13938 }
13939 if (swig_obj[4]) {
13940 {
13941 if ( swig_obj[4] == Py_None )
13942 arg7 = NULL;
13943 else
13944 {
13945 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13946 }
13947 }
13948 }
13949 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13950 resultobj = SWIG_Py_Void();
13951 {
13952 Py_CLEAR( tmp1 );
13953 free( arg1 );
13954 }
13955 {
13956 Py_CLEAR( tmp2 );
13957 free( arg2 );
13958 }
13959 {
13960 cleanup_pltr();
13961 }
13962 {
13964 }
13965 return resultobj;
13966fail:
13967 {
13968 Py_CLEAR( tmp1 );
13969 free( arg1 );
13970 }
13971 {
13972 Py_CLEAR( tmp2 );
13973 free( arg2 );
13974 }
13975 {
13976 cleanup_pltr();
13977 }
13978 {
13980 }
13981 return NULL;
13982}
13983
13984
13985SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13986 PyObject *resultobj = 0;
13987 PLFLT arg1 ;
13988 PLFLT arg2 ;
13989 PLFLT arg3 ;
13990 PLFLT arg4 ;
13991 PLFLT arg5 ;
13992 double val1 ;
13993 int ecode1 = 0 ;
13994 double val2 ;
13995 int ecode2 = 0 ;
13996 double val3 ;
13997 int ecode3 = 0 ;
13998 double val4 ;
13999 int ecode4 = 0 ;
14000 double val5 ;
14001 int ecode5 = 0 ;
14002 PyObject *swig_obj[5] ;
14003
14004 (void)self;
14005 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
14006 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14007 if (!SWIG_IsOK(ecode1)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
14009 }
14010 arg1 = (PLFLT)(val1);
14011 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14012 if (!SWIG_IsOK(ecode2)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
14014 }
14015 arg2 = (PLFLT)(val2);
14016 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14017 if (!SWIG_IsOK(ecode3)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
14019 }
14020 arg3 = (PLFLT)(val3);
14021 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14022 if (!SWIG_IsOK(ecode4)) {
14023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
14024 }
14025 arg4 = (PLFLT)(val4);
14026 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14027 if (!SWIG_IsOK(ecode5)) {
14028 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
14029 }
14030 arg5 = (PLFLT)(val5);
14031 plvpas(arg1,arg2,arg3,arg4,arg5);
14032 resultobj = SWIG_Py_Void();
14033 return resultobj;
14034fail:
14035 return NULL;
14036}
14037
14038
14039SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
14040 PyObject *resultobj = 0;
14041 PLFLT arg1 ;
14042 PLFLT arg2 ;
14043 PLFLT arg3 ;
14044 PLFLT arg4 ;
14045 double val1 ;
14046 int ecode1 = 0 ;
14047 double val2 ;
14048 int ecode2 = 0 ;
14049 double val3 ;
14050 int ecode3 = 0 ;
14051 double val4 ;
14052 int ecode4 = 0 ;
14053 PyObject *swig_obj[4] ;
14054
14055 (void)self;
14056 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14057 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14058 if (!SWIG_IsOK(ecode1)) {
14059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14060 }
14061 arg1 = (PLFLT)(val1);
14062 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14063 if (!SWIG_IsOK(ecode2)) {
14064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14065 }
14066 arg2 = (PLFLT)(val2);
14067 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14068 if (!SWIG_IsOK(ecode3)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14070 }
14071 arg3 = (PLFLT)(val3);
14072 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14073 if (!SWIG_IsOK(ecode4)) {
14074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14075 }
14076 arg4 = (PLFLT)(val4);
14077 plvpor(arg1,arg2,arg3,arg4);
14078 resultobj = SWIG_Py_Void();
14079 return resultobj;
14080fail:
14081 return NULL;
14082}
14083
14084
14085SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14086 PyObject *resultobj = 0;
14087
14088 (void)self;
14089 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14090 plvsta();
14091 resultobj = SWIG_Py_Void();
14092 return resultobj;
14093fail:
14094 return NULL;
14095}
14096
14097
14098SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14099 PyObject *resultobj = 0;
14100 PLFLT arg1 ;
14101 PLFLT arg2 ;
14102 PLFLT arg3 ;
14103 PLFLT arg4 ;
14104 PLFLT arg5 ;
14105 PLFLT arg6 ;
14106 PLFLT arg7 ;
14107 PLFLT arg8 ;
14108 PLFLT arg9 ;
14109 PLFLT arg10 ;
14110 PLFLT arg11 ;
14111 double val1 ;
14112 int ecode1 = 0 ;
14113 double val2 ;
14114 int ecode2 = 0 ;
14115 double val3 ;
14116 int ecode3 = 0 ;
14117 double val4 ;
14118 int ecode4 = 0 ;
14119 double val5 ;
14120 int ecode5 = 0 ;
14121 double val6 ;
14122 int ecode6 = 0 ;
14123 double val7 ;
14124 int ecode7 = 0 ;
14125 double val8 ;
14126 int ecode8 = 0 ;
14127 double val9 ;
14128 int ecode9 = 0 ;
14129 double val10 ;
14130 int ecode10 = 0 ;
14131 double val11 ;
14132 int ecode11 = 0 ;
14133 PyObject *swig_obj[11] ;
14134
14135 (void)self;
14136 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14137 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14138 if (!SWIG_IsOK(ecode1)) {
14139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14140 }
14141 arg1 = (PLFLT)(val1);
14142 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14143 if (!SWIG_IsOK(ecode2)) {
14144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14145 }
14146 arg2 = (PLFLT)(val2);
14147 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14148 if (!SWIG_IsOK(ecode3)) {
14149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14150 }
14151 arg3 = (PLFLT)(val3);
14152 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14153 if (!SWIG_IsOK(ecode4)) {
14154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14155 }
14156 arg4 = (PLFLT)(val4);
14157 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14158 if (!SWIG_IsOK(ecode5)) {
14159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14160 }
14161 arg5 = (PLFLT)(val5);
14162 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14163 if (!SWIG_IsOK(ecode6)) {
14164 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14165 }
14166 arg6 = (PLFLT)(val6);
14167 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14168 if (!SWIG_IsOK(ecode7)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14170 }
14171 arg7 = (PLFLT)(val7);
14172 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14173 if (!SWIG_IsOK(ecode8)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14175 }
14176 arg8 = (PLFLT)(val8);
14177 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14178 if (!SWIG_IsOK(ecode9)) {
14179 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14180 }
14181 arg9 = (PLFLT)(val9);
14182 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14183 if (!SWIG_IsOK(ecode10)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14185 }
14186 arg10 = (PLFLT)(val10);
14187 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14188 if (!SWIG_IsOK(ecode11)) {
14189 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14190 }
14191 arg11 = (PLFLT)(val11);
14192 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14193 resultobj = SWIG_Py_Void();
14194 return resultobj;
14195fail:
14196 return NULL;
14197}
14198
14199
14200SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14201 PyObject *resultobj = 0;
14202 PLFLT arg1 ;
14203 double val1 ;
14204 int ecode1 = 0 ;
14205 PyObject *swig_obj[1] ;
14206
14207 (void)self;
14208 if (!args) SWIG_fail;
14209 swig_obj[0] = args;
14210 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14211 if (!SWIG_IsOK(ecode1)) {
14212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14213 }
14214 arg1 = (PLFLT)(val1);
14215 plwidth(arg1);
14216 resultobj = SWIG_Py_Void();
14217 return resultobj;
14218fail:
14219 return NULL;
14220}
14221
14222
14223SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14224 PyObject *resultobj = 0;
14225 PLFLT arg1 ;
14226 PLFLT arg2 ;
14227 PLFLT arg3 ;
14228 PLFLT arg4 ;
14229 double val1 ;
14230 int ecode1 = 0 ;
14231 double val2 ;
14232 int ecode2 = 0 ;
14233 double val3 ;
14234 int ecode3 = 0 ;
14235 double val4 ;
14236 int ecode4 = 0 ;
14237 PyObject *swig_obj[4] ;
14238
14239 (void)self;
14240 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14241 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14242 if (!SWIG_IsOK(ecode1)) {
14243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14244 }
14245 arg1 = (PLFLT)(val1);
14246 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14247 if (!SWIG_IsOK(ecode2)) {
14248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14249 }
14250 arg2 = (PLFLT)(val2);
14251 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14252 if (!SWIG_IsOK(ecode3)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14254 }
14255 arg3 = (PLFLT)(val3);
14256 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14257 if (!SWIG_IsOK(ecode4)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14259 }
14260 arg4 = (PLFLT)(val4);
14261 plwind(arg1,arg2,arg3,arg4);
14262 resultobj = SWIG_Py_Void();
14263 return resultobj;
14264fail:
14265 return NULL;
14266}
14267
14268
14269SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14270 PyObject *resultobj = 0;
14271 PLBOOL arg1 ;
14272 PLBOOL *arg2 = (PLBOOL *) 0 ;
14273 int val1 ;
14274 int ecode1 = 0 ;
14275 PLBOOL temp2 ;
14276 int res2 = SWIG_TMPOBJ ;
14277 PyObject *swig_obj[1] ;
14278
14279 arg2 = &temp2;
14280 (void)self;
14281 if (!args) SWIG_fail;
14282 swig_obj[0] = args;
14283 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14284 if (!SWIG_IsOK(ecode1)) {
14285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14286 }
14287 arg1 = (PLBOOL)(val1);
14288 plxormod(arg1,arg2);
14289 resultobj = SWIG_Py_Void();
14290 if (SWIG_IsTmpObj(res2)) {
14291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
14292 } else {
14293 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
14295 }
14296 return resultobj;
14297fail:
14298 return NULL;
14299}
14300
14301
14302SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14303 PyObject *resultobj = 0;
14304 mapform_func arg1 = (mapform_func) 0 ;
14305 char *arg2 = (char *) 0 ;
14306 PLFLT arg3 ;
14307 PLFLT arg4 ;
14308 PLFLT arg5 ;
14309 PLFLT arg6 ;
14310 int res2 ;
14311 char *buf2 = 0 ;
14312 int alloc2 = 0 ;
14313 double val3 ;
14314 int ecode3 = 0 ;
14315 double val4 ;
14316 int ecode4 = 0 ;
14317 double val5 ;
14318 int ecode5 = 0 ;
14319 double val6 ;
14320 int ecode6 = 0 ;
14321 PyObject *swig_obj[6] ;
14322
14323 (void)self;
14324 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14325 {
14326 // it must be a callable or none
14327 if ( swig_obj[0] == Py_None )
14328 {
14329 arg1 = NULL;
14330 }
14331 else
14332 {
14333 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14334 {
14335 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14336 return NULL;
14337 }
14338 arg1 = marshal_mapform( swig_obj[0] );
14339 }
14340 }
14341 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14342 if (!SWIG_IsOK(res2)) {
14343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14344 }
14345 arg2 = (char *)(buf2);
14346 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14347 if (!SWIG_IsOK(ecode3)) {
14348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14349 }
14350 arg3 = (PLFLT)(val3);
14351 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14352 if (!SWIG_IsOK(ecode4)) {
14353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14354 }
14355 arg4 = (PLFLT)(val4);
14356 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14357 if (!SWIG_IsOK(ecode5)) {
14358 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14359 }
14360 arg5 = (PLFLT)(val5);
14361 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14362 if (!SWIG_IsOK(ecode6)) {
14363 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14364 }
14365 arg6 = (PLFLT)(val6);
14366 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14367 resultobj = SWIG_Py_Void();
14368 {
14370 }
14371 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14372 return resultobj;
14373fail:
14374 {
14376 }
14377 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14378 return NULL;
14379}
14380
14381
14382SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14383 PyObject *resultobj = 0;
14384 mapform_func arg1 = (mapform_func) 0 ;
14385 char *arg2 = (char *) 0 ;
14386 PLFLT arg3 ;
14387 PLFLT arg4 ;
14388 PLFLT arg5 ;
14389 PLFLT arg6 ;
14390 PLINT *arg7 = (PLINT *) 0 ;
14391 PLINT arg8 ;
14392 int res2 ;
14393 char *buf2 = 0 ;
14394 int alloc2 = 0 ;
14395 double val3 ;
14396 int ecode3 = 0 ;
14397 double val4 ;
14398 int ecode4 = 0 ;
14399 double val5 ;
14400 int ecode5 = 0 ;
14401 double val6 ;
14402 int ecode6 = 0 ;
14403 PyArrayObject *tmp7 = NULL ;
14404 PyObject *swig_obj[7] ;
14405
14406 (void)self;
14407 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14408 {
14409 // it must be a callable or none
14410 if ( swig_obj[0] == Py_None )
14411 {
14412 arg1 = NULL;
14413 }
14414 else
14415 {
14416 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14417 {
14418 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14419 return NULL;
14420 }
14421 arg1 = marshal_mapform( swig_obj[0] );
14422 }
14423 }
14424 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14425 if (!SWIG_IsOK(res2)) {
14426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14427 }
14428 arg2 = (char *)(buf2);
14429 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14430 if (!SWIG_IsOK(ecode3)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14432 }
14433 arg3 = (PLFLT)(val3);
14434 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14435 if (!SWIG_IsOK(ecode4)) {
14436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14437 }
14438 arg4 = (PLFLT)(val4);
14439 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14440 if (!SWIG_IsOK(ecode5)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14442 }
14443 arg5 = (PLFLT)(val5);
14444 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14445 if (!SWIG_IsOK(ecode6)) {
14446 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14447 }
14448 arg6 = (PLFLT)(val6);
14449 {
14450 if ( swig_obj[6] != Py_None )
14451 {
14452 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14453 if ( tmp7 == NULL )
14454 return NULL;
14455 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14456 arg8 = PyArray_DIMS( tmp7 )[0];
14457 }
14458 else
14459 {
14460 arg7 = NULL;
14461 arg8 = 0;
14462 }
14463 }
14464 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14465 resultobj = SWIG_Py_Void();
14466 {
14468 }
14469 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14470 {
14471 Py_CLEAR( tmp7 );
14472 }
14473 return resultobj;
14474fail:
14475 {
14477 }
14478 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14479 {
14480 Py_CLEAR( tmp7 );
14481 }
14482 return NULL;
14483}
14484
14485
14486SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14487 PyObject *resultobj = 0;
14488 mapform_func arg1 = (mapform_func) 0 ;
14489 char *arg2 = (char *) 0 ;
14490 char *arg3 = (char *) 0 ;
14491 PLFLT arg4 ;
14492 PLFLT arg5 ;
14493 PLFLT arg6 ;
14494 PLFLT arg7 ;
14495 PLINT *arg8 = (PLINT *) 0 ;
14496 PLINT arg9 ;
14497 int res2 ;
14498 char *buf2 = 0 ;
14499 int alloc2 = 0 ;
14500 int res3 ;
14501 char *buf3 = 0 ;
14502 int alloc3 = 0 ;
14503 double val4 ;
14504 int ecode4 = 0 ;
14505 double val5 ;
14506 int ecode5 = 0 ;
14507 double val6 ;
14508 int ecode6 = 0 ;
14509 double val7 ;
14510 int ecode7 = 0 ;
14511 PyArrayObject *tmp8 = NULL ;
14512 PyObject *swig_obj[8] ;
14513
14514 (void)self;
14515 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14516 {
14517 // it must be a callable or none
14518 if ( swig_obj[0] == Py_None )
14519 {
14520 arg1 = NULL;
14521 }
14522 else
14523 {
14524 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14525 {
14526 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14527 return NULL;
14528 }
14529 arg1 = marshal_mapform( swig_obj[0] );
14530 }
14531 }
14532 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14533 if (!SWIG_IsOK(res2)) {
14534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14535 }
14536 arg2 = (char *)(buf2);
14537 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14538 if (!SWIG_IsOK(res3)) {
14539 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14540 }
14541 arg3 = (char *)(buf3);
14542 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14543 if (!SWIG_IsOK(ecode4)) {
14544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14545 }
14546 arg4 = (PLFLT)(val4);
14547 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14548 if (!SWIG_IsOK(ecode5)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14550 }
14551 arg5 = (PLFLT)(val5);
14552 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14553 if (!SWIG_IsOK(ecode6)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14555 }
14556 arg6 = (PLFLT)(val6);
14557 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14558 if (!SWIG_IsOK(ecode7)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14560 }
14561 arg7 = (PLFLT)(val7);
14562 {
14563 if ( swig_obj[7] != Py_None )
14564 {
14565 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14566 if ( tmp8 == NULL )
14567 return NULL;
14568 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14569 arg9 = PyArray_DIMS( tmp8 )[0];
14570 }
14571 else
14572 {
14573 arg8 = NULL;
14574 arg9 = 0;
14575 }
14576 }
14577 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14578 resultobj = SWIG_Py_Void();
14579 {
14581 }
14582 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14583 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14584 {
14585 Py_CLEAR( tmp8 );
14586 }
14587 return resultobj;
14588fail:
14589 {
14591 }
14592 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14593 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14594 {
14595 Py_CLEAR( tmp8 );
14596 }
14597 return NULL;
14598}
14599
14600
14601SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14602 PyObject *resultobj = 0;
14603 mapform_func arg1 = (mapform_func) 0 ;
14604 char *arg2 = (char *) 0 ;
14605 PLFLT arg3 ;
14606 PLFLT arg4 ;
14607 PLFLT arg5 ;
14608 char *arg6 = (char *) 0 ;
14609 PLFLT arg7 ;
14610 PLFLT arg8 ;
14611 PLFLT arg9 ;
14612 PLFLT arg10 ;
14613 PLINT arg11 ;
14614 int res2 ;
14615 char *buf2 = 0 ;
14616 int alloc2 = 0 ;
14617 double val3 ;
14618 int ecode3 = 0 ;
14619 double val4 ;
14620 int ecode4 = 0 ;
14621 double val5 ;
14622 int ecode5 = 0 ;
14623 int res6 ;
14624 char *buf6 = 0 ;
14625 int alloc6 = 0 ;
14626 double val7 ;
14627 int ecode7 = 0 ;
14628 double val8 ;
14629 int ecode8 = 0 ;
14630 double val9 ;
14631 int ecode9 = 0 ;
14632 double val10 ;
14633 int ecode10 = 0 ;
14634 int val11 ;
14635 int ecode11 = 0 ;
14636 PyObject *swig_obj[11] ;
14637
14638 (void)self;
14639 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14640 {
14641 // it must be a callable or none
14642 if ( swig_obj[0] == Py_None )
14643 {
14644 arg1 = NULL;
14645 }
14646 else
14647 {
14648 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14649 {
14650 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14651 return NULL;
14652 }
14653 arg1 = marshal_mapform( swig_obj[0] );
14654 }
14655 }
14656 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14657 if (!SWIG_IsOK(res2)) {
14658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14659 }
14660 arg2 = (char *)(buf2);
14661 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14662 if (!SWIG_IsOK(ecode3)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14664 }
14665 arg3 = (PLFLT)(val3);
14666 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14667 if (!SWIG_IsOK(ecode4)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14669 }
14670 arg4 = (PLFLT)(val4);
14671 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14672 if (!SWIG_IsOK(ecode5)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14674 }
14675 arg5 = (PLFLT)(val5);
14676 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14677 if (!SWIG_IsOK(res6)) {
14678 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14679 }
14680 arg6 = (char *)(buf6);
14681 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14682 if (!SWIG_IsOK(ecode7)) {
14683 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14684 }
14685 arg7 = (PLFLT)(val7);
14686 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14687 if (!SWIG_IsOK(ecode8)) {
14688 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14689 }
14690 arg8 = (PLFLT)(val8);
14691 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14692 if (!SWIG_IsOK(ecode9)) {
14693 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14694 }
14695 arg9 = (PLFLT)(val9);
14696 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14697 if (!SWIG_IsOK(ecode10)) {
14698 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14699 }
14700 arg10 = (PLFLT)(val10);
14701 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14702 if (!SWIG_IsOK(ecode11)) {
14703 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14704 }
14705 arg11 = (PLINT)(val11);
14706 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14707 resultobj = SWIG_Py_Void();
14708 {
14710 }
14711 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14712 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14713 return resultobj;
14714fail:
14715 {
14717 }
14718 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14719 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14720 return NULL;
14721}
14722
14723
14724SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14725 PyObject *resultobj = 0;
14726 mapform_func arg1 = (mapform_func) 0 ;
14727 char *arg2 = (char *) 0 ;
14728 PLFLT arg3 ;
14729 PLFLT arg4 ;
14730 PLFLT arg5 ;
14731 PLFLT arg6 ;
14732 PLINT *arg7 = (PLINT *) 0 ;
14733 PLINT arg8 ;
14734 int res2 ;
14735 char *buf2 = 0 ;
14736 int alloc2 = 0 ;
14737 double val3 ;
14738 int ecode3 = 0 ;
14739 double val4 ;
14740 int ecode4 = 0 ;
14741 double val5 ;
14742 int ecode5 = 0 ;
14743 double val6 ;
14744 int ecode6 = 0 ;
14745 PyArrayObject *tmp7 = NULL ;
14746 PyObject *swig_obj[7] ;
14747
14748 (void)self;
14749 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14750 {
14751 // it must be a callable or none
14752 if ( swig_obj[0] == Py_None )
14753 {
14754 arg1 = NULL;
14755 }
14756 else
14757 {
14758 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14759 {
14760 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14761 return NULL;
14762 }
14763 arg1 = marshal_mapform( swig_obj[0] );
14764 }
14765 }
14766 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14767 if (!SWIG_IsOK(res2)) {
14768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14769 }
14770 arg2 = (char *)(buf2);
14771 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14772 if (!SWIG_IsOK(ecode3)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14774 }
14775 arg3 = (PLFLT)(val3);
14776 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14777 if (!SWIG_IsOK(ecode4)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14779 }
14780 arg4 = (PLFLT)(val4);
14781 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14782 if (!SWIG_IsOK(ecode5)) {
14783 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14784 }
14785 arg5 = (PLFLT)(val5);
14786 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14787 if (!SWIG_IsOK(ecode6)) {
14788 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14789 }
14790 arg6 = (PLFLT)(val6);
14791 {
14792 if ( swig_obj[6] != Py_None )
14793 {
14794 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14795 if ( tmp7 == NULL )
14796 return NULL;
14797 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14798 arg8 = PyArray_DIMS( tmp7 )[0];
14799 }
14800 else
14801 {
14802 arg7 = NULL;
14803 arg8 = 0;
14804 }
14805 }
14806 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14807 resultobj = SWIG_Py_Void();
14808 {
14810 }
14811 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14812 {
14813 Py_CLEAR( tmp7 );
14814 }
14815 return resultobj;
14816fail:
14817 {
14819 }
14820 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14821 {
14822 Py_CLEAR( tmp7 );
14823 }
14824 return NULL;
14825}
14826
14827
14828SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14829 PyObject *resultobj = 0;
14830 mapform_func arg1 = (mapform_func) 0 ;
14831 PLFLT arg2 ;
14832 PLFLT arg3 ;
14833 PLFLT arg4 ;
14834 PLFLT arg5 ;
14835 PLFLT arg6 ;
14836 PLFLT arg7 ;
14837 double val2 ;
14838 int ecode2 = 0 ;
14839 double val3 ;
14840 int ecode3 = 0 ;
14841 double val4 ;
14842 int ecode4 = 0 ;
14843 double val5 ;
14844 int ecode5 = 0 ;
14845 double val6 ;
14846 int ecode6 = 0 ;
14847 double val7 ;
14848 int ecode7 = 0 ;
14849 PyObject *swig_obj[7] ;
14850
14851 (void)self;
14852 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14853 {
14854 // it must be a callable or none
14855 if ( swig_obj[0] == Py_None )
14856 {
14857 arg1 = NULL;
14858 }
14859 else
14860 {
14861 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14862 {
14863 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14864 return NULL;
14865 }
14866 arg1 = marshal_mapform( swig_obj[0] );
14867 }
14868 }
14869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14870 if (!SWIG_IsOK(ecode2)) {
14871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14872 }
14873 arg2 = (PLFLT)(val2);
14874 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14875 if (!SWIG_IsOK(ecode3)) {
14876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14877 }
14878 arg3 = (PLFLT)(val3);
14879 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14880 if (!SWIG_IsOK(ecode4)) {
14881 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14882 }
14883 arg4 = (PLFLT)(val4);
14884 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14885 if (!SWIG_IsOK(ecode5)) {
14886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14887 }
14888 arg5 = (PLFLT)(val5);
14889 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14890 if (!SWIG_IsOK(ecode6)) {
14891 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14892 }
14893 arg6 = (PLFLT)(val6);
14894 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14895 if (!SWIG_IsOK(ecode7)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14897 }
14898 arg7 = (PLFLT)(val7);
14899 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14900 resultobj = SWIG_Py_Void();
14901 {
14903 }
14904 return resultobj;
14905fail:
14906 {
14908 }
14909 return NULL;
14910}
14911
14912
14913SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14914 PyObject *resultobj = 0;
14915 PLFLT **arg1 = (PLFLT **) 0 ;
14916 PLINT arg2 ;
14917 PLINT arg3 ;
14918 PLFLT arg4 ;
14919 PLFLT arg5 ;
14920 PLFLT arg6 ;
14921 PLFLT arg7 ;
14922 PLFLT arg8 ;
14923 PLFLT arg9 ;
14924 PLFLT arg10 ;
14925 PLFLT arg11 ;
14926 PLFLT arg12 ;
14927 PLFLT arg13 ;
14928 PyArrayObject *tmp1 = NULL ;
14929 double val4 ;
14930 int ecode4 = 0 ;
14931 double val5 ;
14932 int ecode5 = 0 ;
14933 double val6 ;
14934 int ecode6 = 0 ;
14935 double val7 ;
14936 int ecode7 = 0 ;
14937 double val8 ;
14938 int ecode8 = 0 ;
14939 double val9 ;
14940 int ecode9 = 0 ;
14941 double val10 ;
14942 int ecode10 = 0 ;
14943 double val11 ;
14944 int ecode11 = 0 ;
14945 double val12 ;
14946 int ecode12 = 0 ;
14947 double val13 ;
14948 int ecode13 = 0 ;
14949 PyObject *swig_obj[11] ;
14950
14951 (void)self;
14952 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14953 {
14954 int i, size;
14955 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14956 if ( tmp1 == NULL )
14957 return NULL;
14958 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14959 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14960 size = arg3;
14961 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14962 for ( i = 0; i < arg2; i++ )
14963 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14964 }
14965 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14966 if (!SWIG_IsOK(ecode4)) {
14967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14968 }
14969 arg4 = (PLFLT)(val4);
14970 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14971 if (!SWIG_IsOK(ecode5)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14973 }
14974 arg5 = (PLFLT)(val5);
14975 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14976 if (!SWIG_IsOK(ecode6)) {
14977 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14978 }
14979 arg6 = (PLFLT)(val6);
14980 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14981 if (!SWIG_IsOK(ecode7)) {
14982 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14983 }
14984 arg7 = (PLFLT)(val7);
14985 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14986 if (!SWIG_IsOK(ecode8)) {
14987 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14988 }
14989 arg8 = (PLFLT)(val8);
14990 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14991 if (!SWIG_IsOK(ecode9)) {
14992 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14993 }
14994 arg9 = (PLFLT)(val9);
14995 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14996 if (!SWIG_IsOK(ecode10)) {
14997 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14998 }
14999 arg10 = (PLFLT)(val10);
15000 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15001 if (!SWIG_IsOK(ecode11)) {
15002 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
15003 }
15004 arg11 = (PLFLT)(val11);
15005 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
15006 if (!SWIG_IsOK(ecode12)) {
15007 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
15008 }
15009 arg12 = (PLFLT)(val12);
15010 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
15011 if (!SWIG_IsOK(ecode13)) {
15012 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
15013 }
15014 arg13 = (PLFLT)(val13);
15015 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15016 resultobj = SWIG_Py_Void();
15017 {
15018 Py_CLEAR( tmp1 );
15019 free( arg1 );
15020 }
15021 return resultobj;
15022fail:
15023 {
15024 Py_CLEAR( tmp1 );
15025 free( arg1 );
15026 }
15027 return NULL;
15028}
15029
15030
15031SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
15032 PyObject *resultobj = 0;
15033 PLFLT **arg1 = (PLFLT **) 0 ;
15034 PLINT arg2 ;
15035 PLINT arg3 ;
15036 PLFLT arg4 ;
15037 PLFLT arg5 ;
15038 PLFLT arg6 ;
15039 PLFLT arg7 ;
15040 PLFLT arg8 ;
15041 PLFLT arg9 ;
15042 PLFLT arg10 ;
15043 PLFLT arg11 ;
15044 pltr_func arg12 = (pltr_func) 0 ;
15045 PLPointer arg13 = (PLPointer) 0 ;
15046 PyArrayObject *tmp1 = NULL ;
15047 double val4 ;
15048 int ecode4 = 0 ;
15049 double val5 ;
15050 int ecode5 = 0 ;
15051 double val6 ;
15052 int ecode6 = 0 ;
15053 double val7 ;
15054 int ecode7 = 0 ;
15055 double val8 ;
15056 int ecode8 = 0 ;
15057 double val9 ;
15058 int ecode9 = 0 ;
15059 double val10 ;
15060 int ecode10 = 0 ;
15061 double val11 ;
15062 int ecode11 = 0 ;
15063 PyObject *swig_obj[11] ;
15064
15065 {
15066 python_pltr = 0;
15067 arg12 = NULL;
15068 }
15069 {
15070 arg13 = NULL;
15071 }
15072 (void)self;
15073 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15074 {
15075 int i, size;
15076 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15077 if ( tmp1 == NULL )
15078 return NULL;
15079 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15080 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15081 size = arg3;
15082 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15083 for ( i = 0; i < arg2; i++ )
15084 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15085 }
15086 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15087 if (!SWIG_IsOK(ecode4)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15089 }
15090 arg4 = (PLFLT)(val4);
15091 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15092 if (!SWIG_IsOK(ecode5)) {
15093 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15094 }
15095 arg5 = (PLFLT)(val5);
15096 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15097 if (!SWIG_IsOK(ecode6)) {
15098 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15099 }
15100 arg6 = (PLFLT)(val6);
15101 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15102 if (!SWIG_IsOK(ecode7)) {
15103 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15104 }
15105 arg7 = (PLFLT)(val7);
15106 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15107 if (!SWIG_IsOK(ecode8)) {
15108 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15109 }
15110 arg8 = (PLFLT)(val8);
15111 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15112 if (!SWIG_IsOK(ecode9)) {
15113 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15114 }
15115 arg9 = (PLFLT)(val9);
15116 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15117 if (!SWIG_IsOK(ecode10)) {
15118 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15119 }
15120 arg10 = (PLFLT)(val10);
15121 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15122 if (!SWIG_IsOK(ecode11)) {
15123 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15124 }
15125 arg11 = (PLFLT)(val11);
15126 if (swig_obj[9]) {
15127 {
15128 // it must be a callable or None
15129 if ( swig_obj[9] == Py_None )
15130 {
15131 arg12 = NULL;
15132 }
15133 else
15134 {
15135 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15136 {
15137 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15138 return NULL;
15139 }
15140 arg12 = marshal_pltr( swig_obj[9] );
15141 }
15142 }
15143 }
15144 if (swig_obj[10]) {
15145 {
15146 if ( swig_obj[10] == Py_None )
15147 arg13 = NULL;
15148 else
15149 {
15150 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15151 }
15152 }
15153 }
15154 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15155 resultobj = SWIG_Py_Void();
15156 {
15157 Py_CLEAR( tmp1 );
15158 free( arg1 );
15159 }
15160 {
15161 cleanup_pltr();
15162 }
15163 {
15165 }
15166 return resultobj;
15167fail:
15168 {
15169 Py_CLEAR( tmp1 );
15170 free( arg1 );
15171 }
15172 {
15173 cleanup_pltr();
15174 }
15175 {
15177 }
15178 return NULL;
15179}
15180
15181
15182SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15183 PyObject *resultobj = 0;
15184
15185 (void)self;
15186 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15187 plClearOpts();
15188 resultobj = SWIG_Py_Void();
15189 return resultobj;
15190fail:
15191 return NULL;
15192}
15193
15194
15195SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15196 PyObject *resultobj = 0;
15197
15198 (void)self;
15199 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15200 plResetOpts();
15201 resultobj = SWIG_Py_Void();
15202 return resultobj;
15203fail:
15204 return NULL;
15205}
15206
15207
15208SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15209 PyObject *resultobj = 0;
15210 char *arg1 = (char *) 0 ;
15211 char *arg2 = (char *) 0 ;
15212 int res1 ;
15213 char *buf1 = 0 ;
15214 int alloc1 = 0 ;
15215 int res2 ;
15216 char *buf2 = 0 ;
15217 int alloc2 = 0 ;
15218 PyObject *swig_obj[2] ;
15219
15220 (void)self;
15221 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15222 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15223 if (!SWIG_IsOK(res1)) {
15224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15225 }
15226 arg1 = (char *)(buf1);
15227 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15228 if (!SWIG_IsOK(res2)) {
15229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15230 }
15231 arg2 = (char *)(buf2);
15232 plSetUsage((char const *)arg1,(char const *)arg2);
15233 resultobj = SWIG_Py_Void();
15234 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15235 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15236 return resultobj;
15237fail:
15238 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15239 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15240 return NULL;
15241}
15242
15243
15244SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15245 PyObject *resultobj = 0;
15246
15247 (void)self;
15248 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15249 plOptUsage();
15250 resultobj = SWIG_Py_Void();
15251 return resultobj;
15252fail:
15253 return NULL;
15254}
15255
15256
15257SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15258 PyObject *resultobj = 0;
15259 PLFLT **arg1 = (PLFLT **) 0 ;
15260 PLINT arg2 ;
15261 PLINT arg3 ;
15262 PLFLT *arg4 = (PLFLT *) 0 ;
15263 PLFLT *arg5 = (PLFLT *) 0 ;
15264 PyArrayObject *tmp1 = NULL ;
15265 PLFLT temp4 ;
15266 int res4 = SWIG_TMPOBJ ;
15267 PLFLT temp5 ;
15268 int res5 = SWIG_TMPOBJ ;
15269 PyObject *swig_obj[1] ;
15270
15271 arg4 = &temp4;
15272 arg5 = &temp5;
15273 (void)self;
15274 if (!args) SWIG_fail;
15275 swig_obj[0] = args;
15276 {
15277 int i, size;
15278 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15279 if ( tmp1 == NULL )
15280 return NULL;
15281 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15282 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15283 size = arg3;
15284 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15285 for ( i = 0; i < arg2; i++ )
15286 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15287 }
15288 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15289 resultobj = SWIG_Py_Void();
15290 if (SWIG_IsTmpObj(res4)) {
15291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
15292 } else {
15293 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
15295 }
15296 if (SWIG_IsTmpObj(res5)) {
15297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
15298 } else {
15299 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
15301 }
15302 {
15303 Py_CLEAR( tmp1 );
15304 free( arg1 );
15305 }
15306 return resultobj;
15307fail:
15308 {
15309 Py_CLEAR( tmp1 );
15310 free( arg1 );
15311 }
15312 return NULL;
15313}
15314
15315
15316SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15317 PyObject *resultobj = 0;
15318 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 PyObject *swig_obj[1] ;
15322 PLINT result;
15323
15324 (void)self;
15325 if (!args) SWIG_fail;
15326 swig_obj[0] = args;
15327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15328 if (!SWIG_IsOK(res1)) {
15329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15330 }
15331 arg1 = (PLGraphicsIn *)(argp1);
15332 result = (PLINT)plGetCursor(arg1);
15333 resultobj = SWIG_From_int((int)(result));
15334 return resultobj;
15335fail:
15336 return NULL;
15337}
15338
15339
15340static PyMethodDef SwigMethods[] = {
15341 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15342 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15343 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15344 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15345 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15346 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15347 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15348 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15349 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15350 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15351 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15352 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15353 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15354 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15355 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15356 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15357 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15358 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15359 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15360 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15361 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15362 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15363 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15364 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15365 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15366 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15367 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15368 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15369 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15370 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15371 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15372 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15373 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15374 "Set format of numerical label for contours\n"
15375 "\n"
15376 "DESCRIPTION:\n"
15377 "\n"
15378 " Set format of numerical label for contours.\n"
15379 "\n"
15380 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15381 "\n"
15382 " This function is used example 9.\n"
15383 "\n"
15384 "\n"
15385 "\n"
15386 "SYNOPSIS:\n"
15387 "\n"
15388 "pl_setcontlabelformat(lexp, sigdig)\n"
15389 "\n"
15390 "ARGUMENTS:\n"
15391 "\n"
15392 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15393 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15394 " format is used. Default value of lexp is 4.\n"
15395 "\n"
15396 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15397 " value is 2.\n"
15398 "\n"
15399 ""},
15400 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15401 "Set parameters of contour labelling other than format of numerical label\n"
15402 "\n"
15403 "DESCRIPTION:\n"
15404 "\n"
15405 " Set parameters of contour labelling other than those handled by\n"
15406 " pl_setcontlabelformat.\n"
15407 "\n"
15408 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15409 "\n"
15410 " This function is used in example 9.\n"
15411 "\n"
15412 "\n"
15413 "\n"
15414 "SYNOPSIS:\n"
15415 "\n"
15416 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15417 "\n"
15418 "ARGUMENTS:\n"
15419 "\n"
15420 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15421 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15422 "\n"
15423 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15424 " Default value is 0.3.\n"
15425 "\n"
15426 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15427 " Default value is 0.1.\n"
15428 "\n"
15429 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15430 " contour labels on. Default is off (0).\n"
15431 "\n"
15432 ""},
15433 { "pladv", _wrap_pladv, METH_O, "\n"
15434 "Advance the (sub-)page\n"
15435 "\n"
15436 "DESCRIPTION:\n"
15437 "\n"
15438 " Advances to the next subpage if sub=0, performing a page advance if\n"
15439 " there are no remaining subpages on the current page. If subpages\n"
15440 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15441 " PLplot switches to the specified subpage. Note that this allows you\n"
15442 " to overwrite a plot on the specified subpage; if this is not what you\n"
15443 " intended, use pleop followed by plbop to first advance the page. This\n"
15444 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15445 " is not used, pladv must be called after initializing PLplot but before\n"
15446 " defining the viewport.\n"
15447 "\n"
15448 " Redacted form: pladv(page)\n"
15449 "\n"
15450 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15451 " 29, and 31.\n"
15452 "\n"
15453 "\n"
15454 "\n"
15455 "SYNOPSIS:\n"
15456 "\n"
15457 "pladv(page)\n"
15458 "\n"
15459 "ARGUMENTS:\n"
15460 "\n"
15461 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15462 " in the top left corner and increasing along the rows) to which to\n"
15463 " advance. Set to zero to advance to the next subpage (or to the\n"
15464 " next page if subpages are not being used).\n"
15465 "\n"
15466 ""},
15467 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15468 "Draw a circular or elliptical arc\n"
15469 "\n"
15470 "DESCRIPTION:\n"
15471 "\n"
15472 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15473 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15474 "\n"
15475 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15476 " fill)\n"
15477 "\n"
15478 "\n"
15479 " This function is used in examples 3 and 27.\n"
15480 "\n"
15481 "\n"
15482 "\n"
15483 "SYNOPSIS:\n"
15484 "\n"
15485 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15486 "\n"
15487 "ARGUMENTS:\n"
15488 "\n"
15489 " x (PLFLT, input) : X coordinate of arc center.\n"
15490 "\n"
15491 " y (PLFLT, input) : Y coordinate of arc center.\n"
15492 "\n"
15493 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15494 "\n"
15495 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15496 "\n"
15497 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15498 " semimajor axis.\n"
15499 "\n"
15500 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15501 " semimajor axis.\n"
15502 "\n"
15503 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15504 " X-axis.\n"
15505 "\n"
15506 " fill (PLBOOL, input) : Draw a filled arc.\n"
15507 "\n"
15508 ""},
15509 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15510 "Draw a box with axes, etc. with arbitrary origin\n"
15511 "\n"
15512 "DESCRIPTION:\n"
15513 "\n"
15514 " Draws a box around the currently defined viewport with arbitrary\n"
15515 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15516 " world coordinate values appropriate to the window. Thus plaxes should\n"
15517 " only be called after defining both viewport and window. The ascii\n"
15518 " character strings xopt and yopt specify how the box should be drawn as\n"
15519 " described below. If ticks and/or subticks are to be drawn for a\n"
15520 " particular axis, the tick intervals and number of subintervals may be\n"
15521 " specified explicitly, or they may be defaulted by setting the\n"
15522 " appropriate arguments to zero.\n"
15523 "\n"
15524 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15525 " ytick, nysub)\n"
15526 "\n"
15527 "\n"
15528 " This function is not used in any examples.\n"
15529 "\n"
15530 "\n"
15531 "\n"
15532 "SYNOPSIS:\n"
15533 "\n"
15534 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15535 "\n"
15536 "ARGUMENTS:\n"
15537 "\n"
15538 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15539 "\n"
15540 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15541 "\n"
15542 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15543 " options for the x axis. The string can include any combination of\n"
15544 " the following letters (upper or lower case) in any order: a: Draws\n"
15545 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15546 " (x=0).\n"
15547 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15548 " c: Draws top (X) or right (Y) edge of frame.\n"
15549 " d: Plot labels as date / time. Values are assumed to be\n"
15550 " seconds since the epoch (as used by gmtime).\n"
15551 " f: Always use fixed point numeric labels.\n"
15552 " g: Draws a grid at the major tick interval.\n"
15553 " h: Draws a grid at the minor tick interval.\n"
15554 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15555 " inwards.\n"
15556 " l: Labels axis logarithmically. This only affects the labels,\n"
15557 " not the data, and so it is necessary to compute the logarithms\n"
15558 " of data points before passing them to any of the drawing\n"
15559 " routines.\n"
15560 " m: Writes numeric labels at major tick intervals in the\n"
15561 " unconventional location (above box for X, right of box for Y).\n"
15562 " n: Writes numeric labels at major tick intervals in the\n"
15563 " conventional location (below box for X, left of box for Y).\n"
15564 " o: Use custom labelling function to generate axis label text.\n"
15565 " The custom labelling function can be defined with the\n"
15566 " plslabelfunc command.\n"
15567 " s: Enables subticks between major ticks, only valid if t is\n"
15568 " also specified.\n"
15569 " t: Draws major ticks.\n"
15570 " u: Exactly like \"b\" except don't draw edge line.\n"
15571 " w: Exactly like \"c\" except don't draw edge line.\n"
15572 " x: Exactly like \"t\" (including the side effect of the\n"
15573 " numerical labels for the major ticks) except exclude drawing\n"
15574 " the major and minor tick marks.\n"
15575 "\n"
15576 "\n"
15577 " xtick (PLFLT, input) : World coordinate interval between major\n"
15578 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15579 " generates a suitable tick interval.\n"
15580 "\n"
15581 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15582 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15583 " generates a suitable minor tick interval.\n"
15584 "\n"
15585 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15586 " options for the y axis. The string can include any combination of\n"
15587 " the letters defined above for xopt, and in addition may contain:\n"
15588 " v: Write numeric labels for the y axis parallel to the base of the\n"
15589 " graph, rather than parallel to the axis.\n"
15590 "\n"
15591 "\n"
15592 " ytick (PLFLT, input) : World coordinate interval between major\n"
15593 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15594 " generates a suitable tick interval.\n"
15595 "\n"
15596 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15597 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15598 " generates a suitable minor tick interval.\n"
15599 "\n"
15600 ""},
15601 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15602 "Plot a histogram from binned data\n"
15603 "\n"
15604 "DESCRIPTION:\n"
15605 "\n"
15606 " Plots a histogram consisting of nbin bins. The value associated with\n"
15607 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15608 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15609 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15610 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15611 " placed midway between the values in the x vector. Also see plhist for\n"
15612 " drawing histograms from unbinned data.\n"
15613 "\n"
15614 " Redacted form: General: plbin(x, y, opt)\n"
15615 " Python: plbin(nbin, x, y, opt)\n"
15616 "\n"
15617 "\n"
15618 " This function is not used in any examples.\n"
15619 "\n"
15620 "\n"
15621 "\n"
15622 "SYNOPSIS:\n"
15623 "\n"
15624 "plbin(nbin, x, y, opt)\n"
15625 "\n"
15626 "ARGUMENTS:\n"
15627 "\n"
15628 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15629 " and y vectors.)\n"
15630 "\n"
15631 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15632 " with bins. These must form a strictly increasing sequence.\n"
15633 "\n"
15634 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15635 " proportional to the number of points in each bin. This is a PLFLT\n"
15636 " (instead of PLINT) vector so as to allow histograms of\n"
15637 " probabilities, etc.\n"
15638 "\n"
15639 " opt (PLINT, input) : Is a combination of several flags:\n"
15640 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15641 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15642 " zero height are simply drawn.\n"
15643 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15644 " between the x values. If the values in x are equally spaced,\n"
15645 " the values are the center values of the bins.\n"
15646 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15647 " size as the ones inside.\n"
15648 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15649 " (there is a gap for such bins).\n"
15650 "\n"
15651 ""},
15652 { "plbtime", _wrap_plbtime, METH_O, "\n"
15653 "Calculate broken-down time from continuous time for the current stream\n"
15654 "\n"
15655 "DESCRIPTION:\n"
15656 "\n"
15657 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15658 " continuous time, ctime for the current stream. This function is the\n"
15659 " inverse of plctime.\n"
15660 "\n"
15661 " The PLplot definition of broken-down time is a calendar time that\n"
15662 " completely ignores all time zone offsets, i.e., it is the user's\n"
15663 " responsibility to apply those offsets (if so desired) before using the\n"
15664 " PLplot time API. By default broken-down time is defined using the\n"
15665 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15666 " continuous time is defined as the number of seconds since the Unix\n"
15667 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15668 " broken-down and continuous time are possible, see plconfigtime.\n"
15669 "\n"
15670 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15671 " ctime)\n"
15672 "\n"
15673 "\n"
15674 " This function is used in example 29.\n"
15675 "\n"
15676 "\n"
15677 "\n"
15678 "SYNOPSIS:\n"
15679 "\n"
15680 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15681 "\n"
15682 "ARGUMENTS:\n"
15683 "\n"
15684 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15685 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15686 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15687 " BCE, etc.)\n"
15688 "\n"
15689 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15690 " the year in the range from 0 (January) to 11 (December).\n"
15691 "\n"
15692 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15693 " month in the range from 1 to 31.\n"
15694 "\n"
15695 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15696 " day in the range from 0 to 23.\n"
15697 "\n"
15698 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15699 " hour in the range from 0 to 59\n"
15700 "\n"
15701 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15702 " minute in range from 0. to 60.\n"
15703 "\n"
15704 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15705 " time is calculated.\n"
15706 "\n"
15707 ""},
15708 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15709 "Begin a new page\n"
15710 "\n"
15711 "DESCRIPTION:\n"
15712 "\n"
15713 " Begins a new page. For a file driver, the output file is opened if\n"
15714 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15715 " page break is desired at a particular point when plotting to subpages.\n"
15716 " Another use for pleop and plbop is when plotting pages to different\n"
15717 " files, since you can manually set the file name by calling plsfnam\n"
15718 " after the call to pleop. (In fact some drivers may only support a\n"
15719 " single page per file, making this a necessity.) One way to handle\n"
15720 " this case automatically is to page advance via pladv, but enable\n"
15721 " familying (see plsfam) with a small limit on the file size so that a\n"
15722 " new family member file will be created on each page break.\n"
15723 "\n"
15724 " Redacted form: plbop()\n"
15725 "\n"
15726 " This function is used in examples 2 and 20.\n"
15727 "\n"
15728 "\n"
15729 "\n"
15730 "SYNOPSIS:\n"
15731 "\n"
15732 "plbop()\n"
15733 "\n"
15734 ""},
15735 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15736 "Draw a box with axes, etc\n"
15737 "\n"
15738 "DESCRIPTION:\n"
15739 "\n"
15740 " Draws a box around the currently defined viewport, and labels it with\n"
15741 " world coordinate values appropriate to the window. Thus plbox should\n"
15742 " only be called after defining both viewport and window. The ascii\n"
15743 " character strings xopt and yopt specify how the box should be drawn as\n"
15744 " described below. If ticks and/or subticks are to be drawn for a\n"
15745 " particular axis, the tick intervals and number of subintervals may be\n"
15746 " specified explicitly, or they may be defaulted by setting the\n"
15747 " appropriate arguments to zero.\n"
15748 "\n"
15749 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15750 "\n"
15751 "\n"
15752 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15753 " and 29.\n"
15754 "\n"
15755 "\n"
15756 "\n"
15757 "SYNOPSIS:\n"
15758 "\n"
15759 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15760 "\n"
15761 "ARGUMENTS:\n"
15762 "\n"
15763 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15764 " options for the x axis. The string can include any combination of\n"
15765 " the following letters (upper or lower case) in any order: a: Draws\n"
15766 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15767 " (x=0).\n"
15768 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15769 " c: Draws top (X) or right (Y) edge of frame.\n"
15770 " d: Plot labels as date / time. Values are assumed to be\n"
15771 " seconds since the epoch (as used by gmtime).\n"
15772 " f: Always use fixed point numeric labels.\n"
15773 " g: Draws a grid at the major tick interval.\n"
15774 " h: Draws a grid at the minor tick interval.\n"
15775 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15776 " inwards.\n"
15777 " l: Labels axis logarithmically. This only affects the labels,\n"
15778 " not the data, and so it is necessary to compute the logarithms\n"
15779 " of data points before passing them to any of the drawing\n"
15780 " routines.\n"
15781 " m: Writes numeric labels at major tick intervals in the\n"
15782 " unconventional location (above box for X, right of box for Y).\n"
15783 " n: Writes numeric labels at major tick intervals in the\n"
15784 " conventional location (below box for X, left of box for Y).\n"
15785 " o: Use custom labelling function to generate axis label text.\n"
15786 " The custom labelling function can be defined with the\n"
15787 " plslabelfunc command.\n"
15788 " s: Enables subticks between major ticks, only valid if t is\n"
15789 " also specified.\n"
15790 " t: Draws major ticks.\n"
15791 " u: Exactly like \"b\" except don't draw edge line.\n"
15792 " w: Exactly like \"c\" except don't draw edge line.\n"
15793 " x: Exactly like \"t\" (including the side effect of the\n"
15794 " numerical labels for the major ticks) except exclude drawing\n"
15795 " the major and minor tick marks.\n"
15796 "\n"
15797 "\n"
15798 " xtick (PLFLT, input) : World coordinate interval between major\n"
15799 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15800 " generates a suitable tick interval.\n"
15801 "\n"
15802 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15803 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15804 " generates a suitable minor tick interval.\n"
15805 "\n"
15806 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15807 " options for the y axis. The string can include any combination of\n"
15808 " the letters defined above for xopt, and in addition may contain:\n"
15809 " v: Write numeric labels for the y axis parallel to the base of the\n"
15810 " graph, rather than parallel to the axis.\n"
15811 "\n"
15812 "\n"
15813 " ytick (PLFLT, input) : World coordinate interval between major\n"
15814 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15815 " generates a suitable tick interval.\n"
15816 "\n"
15817 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15818 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15819 " generates a suitable minor tick interval.\n"
15820 "\n"
15821 ""},
15822 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15823 "Draw a box with axes, etc, in 3-d\n"
15824 "\n"
15825 "DESCRIPTION:\n"
15826 "\n"
15827 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15828 " plot. For a more complete description of three-dimensional plotting\n"
15829 " see the PLplot documentation.\n"
15830 "\n"
15831 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15832 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15833 "\n"
15834 "\n"
15835 " This function is used in examples 8, 11, 18, and 21.\n"
15836 "\n"
15837 "\n"
15838 "\n"
15839 "SYNOPSIS:\n"
15840 "\n"
15841 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15842 "\n"
15843 "ARGUMENTS:\n"
15844 "\n"
15845 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15846 " options for the x axis. The string can include any combination of\n"
15847 " the following letters (upper or lower case) in any order: b: Draws\n"
15848 " axis at base, at height z=\n"
15849 " zmin where zmin is defined by call to plw3d. This character must be\n"
15850 " specified in order to use any of the other options.\n"
15851 " d: Plot labels as date / time. Values are assumed to be\n"
15852 " seconds since the epoch (as used by gmtime).\n"
15853 " f: Always use fixed point numeric labels.\n"
15854 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15855 " than upwards.\n"
15856 " l: Labels axis logarithmically. This only affects the labels,\n"
15857 " not the data, and so it is necessary to compute the logarithms\n"
15858 " of data points before passing them to any of the drawing\n"
15859 " routines.\n"
15860 " n: Writes numeric labels at major tick intervals.\n"
15861 " o: Use custom labelling function to generate axis label text.\n"
15862 " The custom labelling function can be defined with the\n"
15863 " plslabelfunc command.\n"
15864 " s: Enables subticks between major ticks, only valid if t is\n"
15865 " also specified.\n"
15866 " t: Draws major ticks.\n"
15867 " u: If this is specified, the text label for the axis is\n"
15868 " written under the axis.\n"
15869 "\n"
15870 "\n"
15871 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15872 " the text label for the x axis. It is only drawn if u is in the\n"
15873 " xopt string.\n"
15874 "\n"
15875 " xtick (PLFLT, input) : World coordinate interval between major\n"
15876 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15877 " generates a suitable tick interval.\n"
15878 "\n"
15879 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15880 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15881 " generates a suitable minor tick interval.\n"
15882 "\n"
15883 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15884 " options for the y axis. The string is interpreted in the same way\n"
15885 " as xopt.\n"
15886 "\n"
15887 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15888 " the text label for the y axis. It is only drawn if u is in the\n"
15889 " yopt string.\n"
15890 "\n"
15891 " ytick (PLFLT, input) : World coordinate interval between major\n"
15892 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15893 " generates a suitable tick interval.\n"
15894 "\n"
15895 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15896 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15897 " generates a suitable minor tick interval.\n"
15898 "\n"
15899 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15900 " options for the z axis. The string can include any combination of\n"
15901 " the following letters (upper or lower case) in any order: b: Draws\n"
15902 " z axis to the left of the surface plot.\n"
15903 " c: Draws z axis to the right of the surface plot.\n"
15904 " d: Draws grid lines parallel to the x-y plane behind the\n"
15905 " figure. These lines are not drawn until after plot3d or\n"
15906 " plmesh are called because of the need for hidden line removal.\n"
15907 " e: Plot labels as date / time. Values are assumed to be\n"
15908 " seconds since the epoch (as used by gmtime). Note this\n"
15909 " suboption is interpreted the same as the d suboption for xopt\n"
15910 " and yopt, but it has to be identified as e for zopt since d\n"
15911 " has already been used for the different purpose above.\n"
15912 " f: Always use fixed point numeric labels.\n"
15913 " i: Inverts tick marks, so they are drawn away from the center.\n"
15914 " l: Labels axis logarithmically. This only affects the labels,\n"
15915 " not the data, and so it is necessary to compute the logarithms\n"
15916 " of data points before passing them to any of the drawing\n"
15917 " routines.\n"
15918 " m: Writes numeric labels at major tick intervals on the\n"
15919 " right-hand z axis.\n"
15920 " n: Writes numeric labels at major tick intervals on the\n"
15921 " left-hand z axis.\n"
15922 " o: Use custom labelling function to generate axis label text.\n"
15923 " The custom labelling function can be defined with the\n"
15924 " plslabelfunc command.\n"
15925 " s: Enables subticks between major ticks, only valid if t is\n"
15926 " also specified.\n"
15927 " t: Draws major ticks.\n"
15928 " u: If this is specified, the text label is written beside the\n"
15929 " left-hand axis.\n"
15930 " v: If this is specified, the text label is written beside the\n"
15931 " right-hand axis.\n"
15932 "\n"
15933 "\n"
15934 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15935 " the text label for the z axis. It is only drawn if u or v are in\n"
15936 " the zopt string.\n"
15937 "\n"
15938 " ztick (PLFLT, input) : World coordinate interval between major\n"
15939 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15940 " generates a suitable tick interval.\n"
15941 "\n"
15942 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15943 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15944 " generates a suitable minor tick interval.\n"
15945 "\n"
15946 ""},
15947 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15948 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15949 "\n"
15950 "DESCRIPTION:\n"
15951 "\n"
15952 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15953 " from relative device coordinates, rx and ry.\n"
15954 "\n"
15955 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15956 "\n"
15957 "\n"
15958 " This function is used in example 31.\n"
15959 "\n"
15960 "\n"
15961 "\n"
15962 "SYNOPSIS:\n"
15963 "\n"
15964 "plcalc_world(rx, ry, wx, wy, window)\n"
15965 "\n"
15966 "ARGUMENTS:\n"
15967 "\n"
15968 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15969 " the x coordinate.\n"
15970 "\n"
15971 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15972 " the y coordinate.\n"
15973 "\n"
15974 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15975 " coordinate corresponding to the relative device coordinates rx and\n"
15976 " ry.\n"
15977 "\n"
15978 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15979 " coordinate corresponding to the relative device coordinates rx and\n"
15980 " ry.\n"
15981 "\n"
15982 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15983 " defined window index that corresponds to the input relative device\n"
15984 " coordinates (and the returned world coordinates). To give some\n"
15985 " background on the window index, for each page the initial window\n"
15986 " index is set to zero, and each time plwind is called within the\n"
15987 " page, world and device coordinates are stored for the window and\n"
15988 " the window index is incremented. Thus, for a simple page layout\n"
15989 " with non-overlapping viewports and one window per viewport, window\n"
15990 " corresponds to the viewport index (in the order which the\n"
15991 " viewport/windows were created) of the only viewport/window\n"
15992 " corresponding to rx and ry. However, for more complicated layouts\n"
15993 " with potentially overlapping viewports and possibly more than one\n"
15994 " window (set of world coordinates) per viewport, window and the\n"
15995 " corresponding output world coordinates corresponds to the last\n"
15996 " window created that fulfills the criterion that the relative\n"
15997 " device coordinates are inside it. Finally, in all cases where the\n"
15998 " input relative device coordinates are not inside any\n"
15999 " viewport/window, then the returned value of the last defined\n"
16000 " window index is set to -1.\n"
16001 "\n"
16002 ""},
16003 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
16004 "Clear current (sub)page\n"
16005 "\n"
16006 "DESCRIPTION:\n"
16007 "\n"
16008 " Clears the current page, effectively erasing everything that have been\n"
16009 " drawn. This command only works with interactive drivers; if the\n"
16010 " driver does not support this, the page is filled with the background\n"
16011 " color in use. If the current page is divided into subpages, only the\n"
16012 " current subpage is erased. The nth subpage can be selected with\n"
16013 " pladv(n).\n"
16014 "\n"
16015 " Redacted form: General: plclear()\n"
16016 "\n"
16017 "\n"
16018 " This function is not used in any examples.\n"
16019 "\n"
16020 "\n"
16021 "\n"
16022 "SYNOPSIS:\n"
16023 "\n"
16024 "plclear()\n"
16025 "\n"
16026 ""},
16027 { "plcol0", _wrap_plcol0, METH_O, "\n"
16028 "Set color, cmap0\n"
16029 "\n"
16030 "DESCRIPTION:\n"
16031 "\n"
16032 " Sets the color index for cmap0 (see the PLplot documentation).\n"
16033 "\n"
16034 " Redacted form: plcol0(icol0)\n"
16035 "\n"
16036 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16037 "\n"
16038 "\n"
16039 "\n"
16040 "SYNOPSIS:\n"
16041 "\n"
16042 "plcol0(icol0)\n"
16043 "\n"
16044 "ARGUMENTS:\n"
16045 "\n"
16046 " icol0 (PLINT, input) : Integer representing the color. The\n"
16047 " defaults at present are (these may change):\n"
16048 " 0 black (default background)\n"
16049 " 1 red (default foreground)\n"
16050 " 2 yellow\n"
16051 " 3 green\n"
16052 " 4 aquamarine\n"
16053 " 5 pink\n"
16054 " 6 wheat\n"
16055 " 7 grey\n"
16056 " 8 brown\n"
16057 " 9 blue\n"
16058 " 10 BlueViolet\n"
16059 " 11 cyan\n"
16060 " 12 turquoise\n"
16061 " 13 magenta\n"
16062 " 14 salmon\n"
16063 " 15 white\n"
16064 "\n"
16065 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16066 " change an individual color in the cmap0 color palette.\n"
16067 "\n"
16068 ""},
16069 { "plcol1", _wrap_plcol1, METH_O, "\n"
16070 "Set color, cmap1\n"
16071 "\n"
16072 "DESCRIPTION:\n"
16073 "\n"
16074 " Sets the color for cmap1 (see the PLplot documentation).\n"
16075 "\n"
16076 " Redacted form: plcol1(col1)\n"
16077 "\n"
16078 " This function is used in examples 12 and 21.\n"
16079 "\n"
16080 "\n"
16081 "\n"
16082 "SYNOPSIS:\n"
16083 "\n"
16084 "plcol1(col1)\n"
16085 "\n"
16086 "ARGUMENTS:\n"
16087 "\n"
16088 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16089 " is mapped to color using the continuous cmap1 palette which by\n"
16090 " default ranges from blue to the background color to red. The\n"
16091 " cmap1 palette can also be straightforwardly changed by the user\n"
16092 " with plscmap1 or plscmap1l.\n"
16093 "\n"
16094 ""},
16095 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16096 "Configure the transformation between continuous and broken-down time for the current stream\n"
16097 "\n"
16098 "DESCRIPTION:\n"
16099 "\n"
16100 " Configure the transformation between continuous and broken-down time\n"
16101 " for the current stream. This transformation is used by both plbtime\n"
16102 " and plctime.\n"
16103 "\n"
16104 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16105 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16106 "\n"
16107 "\n"
16108 " This function is used in example 29.\n"
16109 "\n"
16110 "\n"
16111 "\n"
16112 "SYNOPSIS:\n"
16113 "\n"
16114 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16115 "\n"
16116 "ARGUMENTS:\n"
16117 "\n"
16118 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16119 " As a special case, if\n"
16120 " scale is 0., then all other arguments are ignored, and the result (the\n"
16121 " default used by PLplot) is the equivalent of a call to\n"
16122 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16123 " That is, for this special case broken-down time is calculated with\n"
16124 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16125 " and the continuous time is defined as the number of seconds since\n"
16126 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16127 "\n"
16128 " offset1 (PLFLT, input) : If\n"
16129 " ifbtime_offset is true, the parameters\n"
16130 " offset1 and\n"
16131 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16132 " (with units in days) specify the epoch of the continuous time\n"
16133 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16134 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16135 " are used to specify the origin to allow users (by specifying\n"
16136 " offset1 as an integer that can be exactly represented by a\n"
16137 " floating-point variable and specifying\n"
16138 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16139 " the numerical errors of the continuous time representation.\n"
16140 "\n"
16141 " offset2 (PLFLT, input) : See documentation of\n"
16142 " offset1.\n"
16143 "\n"
16144 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16145 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16146 " calendar is used for broken-down time rather than the proleptic\n"
16147 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16148 " have been historically used to define UTC are inserted into the\n"
16149 " broken-down time. Other possibilities for additional control bits\n"
16150 " for ccontrol exist such as making the historical time corrections\n"
16151 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16152 " making the (slightly non-constant) corrections from international\n"
16153 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16154 " (TT). But those additional possibilities have not been\n"
16155 " implemented yet in the qsastime library (one of the PLplot utility\n"
16156 " libraries).\n"
16157 "\n"
16158 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16159 " epoch of the continuous time scale is specified by the user. If\n"
16160 " ifbtime_offset is false, then\n"
16161 " offset1 and\n"
16162 " offset2 are used to specify the epoch, and the following broken-down\n"
16163 " time parameters are completely ignored. If\n"
16164 " ifbtime_offset is true, then\n"
16165 " offset1 and\n"
16166 " offset2 are completely ignored, and the following broken-down time\n"
16167 " parameters are used to specify the epoch.\n"
16168 "\n"
16169 " year (PLINT, input) : Year of epoch.\n"
16170 "\n"
16171 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16172 " 11 (December).\n"
16173 "\n"
16174 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16175 "\n"
16176 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16177 "\n"
16178 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16179 "\n"
16180 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16181 "\n"
16182 ""},
16183 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16184 "Contour plot\n"
16185 "\n"
16186 "DESCRIPTION:\n"
16187 "\n"
16188 " Draws a contour plot of the data in f[\n"
16189 " nx][\n"
16190 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16191 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16192 " where all these index ranges are interpreted as one-based for\n"
16193 " historical reasons. A transformation routine pointed to by pltr with\n"
16194 " a generic pointer pltr_data for additional data required by the\n"
16195 " transformation routine is used to map indices within the matrix to the\n"
16196 " world coordinates.\n"
16197 "\n"
16198 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16199 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16200 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16201 " vectors; or xg and yg matrices.\n"
16202 "\n"
16203 " This function is used in examples 9, 14, 16, and 22.\n"
16204 "\n"
16205 "\n"
16206 "\n"
16207 "SYNOPSIS:\n"
16208 "\n"
16209 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16210 "\n"
16211 "ARGUMENTS:\n"
16212 "\n"
16213 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16214 "\n"
16215 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16216 "\n"
16217 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16218 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16219 " zero-based for historical backwards-compatibility reasons.\n"
16220 "\n"
16221 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16222 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16223 " zero-based for historical backwards-compatibility reasons.\n"
16224 "\n"
16225 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16226 " which to draw contours.\n"
16227 "\n"
16228 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16229 "\n"
16230 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16231 " defines the transformation between the zero-based indices of the\n"
16232 " matrix f and the world coordinates.For the C case, transformation\n"
16233 " functions are provided in the PLplot library: pltr0 for the\n"
16234 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16235 " respectively defined by vectors and matrices. In addition, C\n"
16236 " callback routines for the transformation can be supplied by the\n"
16237 " user such as the mypltr function in examples/c/x09c.c which\n"
16238 " provides a general linear transformation between index coordinates\n"
16239 " and world coordinates.For languages other than C you should\n"
16240 " consult the PLplot documentation for the details concerning how\n"
16241 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16242 " general, a particular pattern of callback-associated arguments\n"
16243 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16244 " yg matrices are respectively interfaced to a linear-transformation\n"
16245 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16246 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16247 " the PLplot documentation) support native language callbacks for\n"
16248 " handling index to world-coordinate transformations. Examples of\n"
16249 " these various approaches are given in examples/<language>x09*,\n"
16250 " examples/<language>x16*, examples/<language>x20*,\n"
16251 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16252 " supported languages.\n"
16253 "\n"
16254 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16255 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16256 " that is externally supplied.\n"
16257 "\n"
16258 ""},
16259 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16260 "Calculate continuous time from broken-down time for the current stream\n"
16261 "\n"
16262 "DESCRIPTION:\n"
16263 "\n"
16264 " Calculate continuous time, ctime, from broken-down time for the\n"
16265 " current stream. The broken-down\n"
16266 " time is specified by the following parameters: year, month, day, hour,\n"
16267 " min, and sec. This function is the inverse of plbtime.\n"
16268 "\n"
16269 " The PLplot definition of broken-down time is a calendar time that\n"
16270 " completely ignores all time zone offsets, i.e., it is the user's\n"
16271 " responsibility to apply those offsets (if so desired) before using the\n"
16272 " PLplot time API. By default broken-down time is defined using the\n"
16273 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16274 " continuous time is defined as the number of seconds since the Unix\n"
16275 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16276 " broken-down and continuous time are possible, see plconfigtime which\n"
16277 " specifies that transformation for the current stream.\n"
16278 "\n"
16279 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16280 " ctime)\n"
16281 "\n"
16282 "\n"
16283 " This function is used in example 29.\n"
16284 "\n"
16285 "\n"
16286 "\n"
16287 "SYNOPSIS:\n"
16288 "\n"
16289 "plctime(year, month, day, hour, min, sec, ctime)\n"
16290 "\n"
16291 "ARGUMENTS:\n"
16292 "\n"
16293 " year (PLINT, input) : Input year.\n"
16294 "\n"
16295 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16296 " (December).\n"
16297 "\n"
16298 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16299 "\n"
16300 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16301 "\n"
16302 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16303 "\n"
16304 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16305 "\n"
16306 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16307 " time calculated from the broken-down time specified by the\n"
16308 " previous parameters.\n"
16309 "\n"
16310 ""},
16311 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16312 "Copy state parameters from the reference stream to the current stream\n"
16313 "\n"
16314 "DESCRIPTION:\n"
16315 "\n"
16316 " Copies state parameters from the reference stream to the current\n"
16317 " stream. Tell driver interface to map device coordinates unless flags\n"
16318 " == 1.\n"
16319 "\n"
16320 " This function is used for making save files of selected plots (e.g.\n"
16321 " from the TK driver). After initializing, you can get a copy of the\n"
16322 " current plot to the specified device by switching to this stream and\n"
16323 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16324 " appropriate. The plot buffer must have previously been enabled (done\n"
16325 " automatically by some display drivers, such as X).\n"
16326 "\n"
16327 " Redacted form: plcpstrm(iplsr, flags)\n"
16328 "\n"
16329 " This function is used in example 1,20.\n"
16330 "\n"
16331 "\n"
16332 "\n"
16333 "SYNOPSIS:\n"
16334 "\n"
16335 "plcpstrm(iplsr, flags)\n"
16336 "\n"
16337 "ARGUMENTS:\n"
16338 "\n"
16339 " iplsr (PLINT, input) : Number of reference stream.\n"
16340 "\n"
16341 " flags (PLBOOL, input) : If flags is set to true the device\n"
16342 " coordinates are not copied from the reference to current stream.\n"
16343 "\n"
16344 ""},
16345 { "plend", _wrap_plend, METH_NOARGS, "\n"
16346 "End plotting session\n"
16347 "\n"
16348 "DESCRIPTION:\n"
16349 "\n"
16350 " Ends a plotting session, tidies up all the output files, switches\n"
16351 " interactive devices back into text mode and frees up any memory that\n"
16352 " was allocated. Must be called before end of program.\n"
16353 "\n"
16354 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16355 " wait state after a call to plend or other functions which trigger the\n"
16356 " end of a plot page. To avoid this, use the plspause function.\n"
16357 "\n"
16358 " Redacted form: plend()\n"
16359 "\n"
16360 " This function is used in all of the examples.\n"
16361 "\n"
16362 "\n"
16363 "\n"
16364 "SYNOPSIS:\n"
16365 "\n"
16366 "plend()\n"
16367 "\n"
16368 ""},
16369 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16370 "End plotting session for current stream\n"
16371 "\n"
16372 "DESCRIPTION:\n"
16373 "\n"
16374 " Ends a plotting session for the current output stream only. See\n"
16375 " plsstrm for more info.\n"
16376 "\n"
16377 " Redacted form: plend1()\n"
16378 "\n"
16379 " This function is used in examples 1 and 20.\n"
16380 "\n"
16381 "\n"
16382 "\n"
16383 "SYNOPSIS:\n"
16384 "\n"
16385 "plend1()\n"
16386 "\n"
16387 ""},
16388 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16389 "Set up standard window and draw box\n"
16390 "\n"
16391 "DESCRIPTION:\n"
16392 "\n"
16393 " Sets up plotter environment for simple graphs by calling pladv and\n"
16394 " setting up viewport and window to sensible default values. plenv\n"
16395 " leaves a standard margin (left-hand margin of eight character heights,\n"
16396 " and a margin around the other three sides of five character heights)\n"
16397 " around most graphs for axis labels and a title. When these defaults\n"
16398 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16399 " plvasp for setting up the viewport, plwind for defining the window,\n"
16400 " and plbox for drawing the box.\n"
16401 "\n"
16402 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16403 "\n"
16404 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16405 "\n"
16406 "\n"
16407 "\n"
16408 "SYNOPSIS:\n"
16409 "\n"
16410 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16411 "\n"
16412 "ARGUMENTS:\n"
16413 "\n"
16414 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16415 " world coordinates).\n"
16416 "\n"
16417 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16418 " world coordinates).\n"
16419 "\n"
16420 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16421 " coordinates).\n"
16422 "\n"
16423 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16424 " coordinates).\n"
16425 "\n"
16426 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16427 " scales will not be set, the user must set up the scale before\n"
16428 " calling plenv using plsvpa, plvasp or other.\n"
16429 " 0: the x and y axes are scaled independently to use as much of\n"
16430 " the screen as possible.\n"
16431 " 1: the scales of the x and y axes are made equal.\n"
16432 " 2: the axis of the x and y axes are made equal, and the plot\n"
16433 " box will be square.\n"
16434 "\n"
16435 "\n"
16436 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16437 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16438 " -1: draw box only.\n"
16439 " 0: draw box, ticks, and numeric tick labels.\n"
16440 " 1: also draw coordinate axes at x=0 and y=0.\n"
16441 " 2: also draw a grid at major tick positions in both\n"
16442 " coordinates.\n"
16443 " 3: also draw a grid at minor tick positions in both\n"
16444 " coordinates.\n"
16445 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16446 " have to be converted to logarithms separately.)\n"
16447 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16448 " have to be converted to logarithms separately.)\n"
16449 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16450 " have to be converted to logarithms separately.)\n"
16451 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16452 " have to be converted to logarithms separately.)\n"
16453 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16454 " have to be converted to logarithms separately.)\n"
16455 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16456 " have to be converted to logarithms separately.)\n"
16457 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16458 " have to be converted to logarithms separately.)\n"
16459 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16460 " have to be converted to logarithms separately.)\n"
16461 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16462 " and y data have to be converted to logarithms separately.)\n"
16463 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16464 " and y data have to be converted to logarithms separately.)\n"
16465 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16466 " and y data have to be converted to logarithms separately.)\n"
16467 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16468 " and y data have to be converted to logarithms separately.)\n"
16469 " 40: same as 0 except date / time x labels.\n"
16470 " 41: same as 1 except date / time x labels.\n"
16471 " 42: same as 2 except date / time x labels.\n"
16472 " 43: same as 3 except date / time x labels.\n"
16473 " 50: same as 0 except date / time y labels.\n"
16474 " 51: same as 1 except date / time y labels.\n"
16475 " 52: same as 2 except date / time y labels.\n"
16476 " 53: same as 3 except date / time y labels.\n"
16477 " 60: same as 0 except date / time x and y labels.\n"
16478 " 61: same as 1 except date / time x and y labels.\n"
16479 " 62: same as 2 except date / time x and y labels.\n"
16480 " 63: same as 3 except date / time x and y labels.\n"
16481 " 70: same as 0 except custom x and y labels.\n"
16482 " 71: same as 1 except custom x and y labels.\n"
16483 " 72: same as 2 except custom x and y labels.\n"
16484 " 73: same as 3 except custom x and y labels.\n"
16485 "\n"
16486 ""},
16487 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16488 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16489 "\n"
16490 "DESCRIPTION:\n"
16491 "\n"
16492 " Sets up plotter environment for simple graphs by calling pladv and\n"
16493 " setting up viewport and window to sensible default values. plenv0\n"
16494 " leaves a standard margin (left-hand margin of eight character heights,\n"
16495 " and a margin around the other three sides of five character heights)\n"
16496 " around most graphs for axis labels and a title. When these defaults\n"
16497 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16498 " plvasp for setting up the viewport, plwind for defining the window,\n"
16499 " and plbox for drawing the box.\n"
16500 "\n"
16501 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16502 "\n"
16503 " This function is used in example 21.\n"
16504 "\n"
16505 "\n"
16506 "\n"
16507 "SYNOPSIS:\n"
16508 "\n"
16509 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16510 "\n"
16511 "ARGUMENTS:\n"
16512 "\n"
16513 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16514 " world coordinates).\n"
16515 "\n"
16516 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16517 " world coordinates).\n"
16518 "\n"
16519 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16520 " coordinates).\n"
16521 "\n"
16522 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16523 " coordinates).\n"
16524 "\n"
16525 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16526 " scales will not be set, the user must set up the scale before\n"
16527 " calling plenv0 using plsvpa, plvasp or other.\n"
16528 " 0: the x and y axes are scaled independently to use as much of\n"
16529 " the screen as possible.\n"
16530 " 1: the scales of the x and y axes are made equal.\n"
16531 " 2: the axis of the x and y axes are made equal, and the plot\n"
16532 " box will be square.\n"
16533 "\n"
16534 "\n"
16535 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16536 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16537 " -1: draw box only.\n"
16538 " 0: draw box, ticks, and numeric tick labels.\n"
16539 " 1: also draw coordinate axes at x=0 and y=0.\n"
16540 " 2: also draw a grid at major tick positions in both\n"
16541 " coordinates.\n"
16542 " 3: also draw a grid at minor tick positions in both\n"
16543 " coordinates.\n"
16544 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16545 " have to be converted to logarithms separately.)\n"
16546 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16547 " have to be converted to logarithms separately.)\n"
16548 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16549 " have to be converted to logarithms separately.)\n"
16550 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16551 " have to be converted to logarithms separately.)\n"
16552 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16553 " have to be converted to logarithms separately.)\n"
16554 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16555 " have to be converted to logarithms separately.)\n"
16556 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16557 " have to be converted to logarithms separately.)\n"
16558 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16559 " have to be converted to logarithms separately.)\n"
16560 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16561 " and y data have to be converted to logarithms separately.)\n"
16562 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16563 " and y data have to be converted to logarithms separately.)\n"
16564 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16565 " and y data have to be converted to logarithms separately.)\n"
16566 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16567 " and y data have to be converted to logarithms separately.)\n"
16568 " 40: same as 0 except date / time x labels.\n"
16569 " 41: same as 1 except date / time x labels.\n"
16570 " 42: same as 2 except date / time x labels.\n"
16571 " 43: same as 3 except date / time x labels.\n"
16572 " 50: same as 0 except date / time y labels.\n"
16573 " 51: same as 1 except date / time y labels.\n"
16574 " 52: same as 2 except date / time y labels.\n"
16575 " 53: same as 3 except date / time y labels.\n"
16576 " 60: same as 0 except date / time x and y labels.\n"
16577 " 61: same as 1 except date / time x and y labels.\n"
16578 " 62: same as 2 except date / time x and y labels.\n"
16579 " 63: same as 3 except date / time x and y labels.\n"
16580 " 70: same as 0 except custom x and y labels.\n"
16581 " 71: same as 1 except custom x and y labels.\n"
16582 " 72: same as 2 except custom x and y labels.\n"
16583 " 73: same as 3 except custom x and y labels.\n"
16584 "\n"
16585 ""},
16586 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16587 "Eject current page\n"
16588 "\n"
16589 "DESCRIPTION:\n"
16590 "\n"
16591 " Clears the graphics screen of an interactive device, or ejects a page\n"
16592 " on a plotter. See plbop for more information.\n"
16593 "\n"
16594 " Redacted form: pleop()\n"
16595 "\n"
16596 " This function is used in example 2,14.\n"
16597 "\n"
16598 "\n"
16599 "\n"
16600 "SYNOPSIS:\n"
16601 "\n"
16602 "pleop()\n"
16603 "\n"
16604 ""},
16605 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16606 "Draw error bars in x direction\n"
16607 "\n"
16608 "DESCRIPTION:\n"
16609 "\n"
16610 " Draws a set of n error bars in x direction, the i'th error bar\n"
16611 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16612 " of the error bars are of length equal to the minor tick length\n"
16613 " (settable using plsmin).\n"
16614 "\n"
16615 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16616 "\n"
16617 "\n"
16618 " This function is used in example 29.\n"
16619 "\n"
16620 "\n"
16621 "\n"
16622 "SYNOPSIS:\n"
16623 "\n"
16624 "plerrx(n, xmin, xmax, y)\n"
16625 "\n"
16626 "ARGUMENTS:\n"
16627 "\n"
16628 " n (PLINT, input) : Number of error bars to draw.\n"
16629 "\n"
16630 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16631 " of the left-hand endpoints of the error bars.\n"
16632 "\n"
16633 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16634 " of the right-hand endpoints of the error bars.\n"
16635 "\n"
16636 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16637 " the error bars.\n"
16638 "\n"
16639 ""},
16640 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16641 "Draw error bars in the y direction\n"
16642 "\n"
16643 "DESCRIPTION:\n"
16644 "\n"
16645 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16646 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16647 " of the error bars are of length equal to the minor tick length\n"
16648 " (settable using plsmin).\n"
16649 "\n"
16650 " Redacted form: General: plerry(x, ymin, ymax)\n"
16651 "\n"
16652 "\n"
16653 " This function is used in example 29.\n"
16654 "\n"
16655 "\n"
16656 "\n"
16657 "SYNOPSIS:\n"
16658 "\n"
16659 "plerry(n, x, ymin, ymax)\n"
16660 "\n"
16661 "ARGUMENTS:\n"
16662 "\n"
16663 " n (PLINT, input) : Number of error bars to draw.\n"
16664 "\n"
16665 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16666 " the error bars.\n"
16667 "\n"
16668 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16669 " of the lower endpoints of the error bars.\n"
16670 "\n"
16671 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16672 " of the upper endpoints of the error bars.\n"
16673 "\n"
16674 ""},
16675 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16676 "Advance to the next family file on the next new page\n"
16677 "\n"
16678 "DESCRIPTION:\n"
16679 "\n"
16680 " Advance to the next family file on the next new page.\n"
16681 "\n"
16682 " Redacted form: plfamadv()\n"
16683 "\n"
16684 " This function is not used in any examples.\n"
16685 "\n"
16686 "\n"
16687 "\n"
16688 "SYNOPSIS:\n"
16689 "\n"
16690 "plfamadv()\n"
16691 "\n"
16692 ""},
16693 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16694 "Draw filled polygon\n"
16695 "\n"
16696 "DESCRIPTION:\n"
16697 "\n"
16698 " Fills the polygon defined by the n points (\n"
16699 " x[i],\n"
16700 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16701 " style is a solid fill. The routine will automatically close the\n"
16702 " polygon between the last and first vertices. If multiple closed\n"
16703 " polygons are passed in x and y then plfill will fill in between them.\n"
16704 "\n"
16705 " Redacted form: plfill(x,y)\n"
16706 "\n"
16707 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16708 "\n"
16709 "\n"
16710 "\n"
16711 "SYNOPSIS:\n"
16712 "\n"
16713 "plfill(n, x, y)\n"
16714 "\n"
16715 "ARGUMENTS:\n"
16716 "\n"
16717 " n (PLINT, input) : Number of vertices in polygon.\n"
16718 "\n"
16719 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16720 " vertices.\n"
16721 "\n"
16722 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16723 " vertices.\n"
16724 "\n"
16725 ""},
16726 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16727 "Draw filled polygon in 3D\n"
16728 "\n"
16729 "DESCRIPTION:\n"
16730 "\n"
16731 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16732 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16733 " will automatically close the polygon between the last and first\n"
16734 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16735 " plfill3 will fill in between them.\n"
16736 "\n"
16737 " Redacted form: General: plfill3(x, y, z)\n"
16738 "\n"
16739 "\n"
16740 " This function is used in example 15.\n"
16741 "\n"
16742 "\n"
16743 "\n"
16744 "SYNOPSIS:\n"
16745 "\n"
16746 "plfill3(n, x, y, z)\n"
16747 "\n"
16748 "ARGUMENTS:\n"
16749 "\n"
16750 " n (PLINT, input) : Number of vertices in polygon.\n"
16751 "\n"
16752 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16753 " vertices.\n"
16754 "\n"
16755 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16756 " vertices.\n"
16757 "\n"
16758 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16759 " vertices.\n"
16760 "\n"
16761 ""},
16762 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16763 "Draw linear gradient inside polygon\n"
16764 "\n"
16765 "DESCRIPTION:\n"
16766 "\n"
16767 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16768 " points (\n"
16769 " x[i],\n"
16770 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16771 " polygon coordinates and the gradient angle are all expressed in world\n"
16772 " coordinates. The angle from the x axis for both the rotated\n"
16773 " coordinate system and the gradient vector is specified by angle. The\n"
16774 " magnitude of the gradient vector is the difference between the maximum\n"
16775 " and minimum values of x for the vertices in the rotated coordinate\n"
16776 " system. The origin of the gradient vector can be interpreted as being\n"
16777 " anywhere on the line corresponding to the minimum x value for the\n"
16778 " vertices in the rotated coordinate system. The distance along the\n"
16779 " gradient vector is linearly transformed to the independent variable of\n"
16780 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16781 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16782 " color corresponding to the independent variable of cmap1. For more\n"
16783 " information about cmap1 (see the PLplot documentation).\n"
16784 "\n"
16785 " Redacted form: plgradient(x,y,angle)\n"
16786 "\n"
16787 " This function is used in examples 25 and 30.\n"
16788 "\n"
16789 "\n"
16790 "\n"
16791 "SYNOPSIS:\n"
16792 "\n"
16793 "plgradient(n, x, y, angle)\n"
16794 "\n"
16795 "ARGUMENTS:\n"
16796 "\n"
16797 " n (PLINT, input) : Number of vertices in polygon.\n"
16798 "\n"
16799 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16800 " vertices.\n"
16801 "\n"
16802 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16803 " vertices.\n"
16804 "\n"
16805 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16806 " axis.\n"
16807 "\n"
16808 ""},
16809 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16810 "Flushes the output stream\n"
16811 "\n"
16812 "DESCRIPTION:\n"
16813 "\n"
16814 " Flushes the output stream. Use sparingly, if at all.\n"
16815 "\n"
16816 " Redacted form: plflush()\n"
16817 "\n"
16818 " This function is used in examples 1 and 14.\n"
16819 "\n"
16820 "\n"
16821 "\n"
16822 "SYNOPSIS:\n"
16823 "\n"
16824 "plflush()\n"
16825 "\n"
16826 ""},
16827 { "plfont", _wrap_plfont, METH_O, "\n"
16828 "Set font\n"
16829 "\n"
16830 "DESCRIPTION:\n"
16831 "\n"
16832 " Sets the font used for subsequent text and symbols. For devices that\n"
16833 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16834 " fonts with extended character set are loaded (see plfontld). For\n"
16835 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16836 " this routine calls the plsfci routine with argument set up\n"
16837 " appropriately for the various cases below. However, this method of\n"
16838 " specifying the font for unicode-aware devices is deprecated, and the\n"
16839 " much more flexible method of calling plsfont directly is recommended\n"
16840 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16841 "\n"
16842 " Redacted form: plfont(ifont)\n"
16843 "\n"
16844 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16845 "\n"
16846 "\n"
16847 "\n"
16848 "SYNOPSIS:\n"
16849 "\n"
16850 "plfont(ifont)\n"
16851 "\n"
16852 "ARGUMENTS:\n"
16853 "\n"
16854 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16855 " (simplest and fastest)\n"
16856 " 2: Serif font\n"
16857 " 3: Italic font\n"
16858 " 4: Script font\n"
16859 "\n"
16860 ""},
16861 { "plfontld", _wrap_plfontld, METH_O, "\n"
16862 "Load Hershey fonts\n"
16863 "\n"
16864 "DESCRIPTION:\n"
16865 "\n"
16866 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16867 " be called before or after initializing PLplot. If not explicitly\n"
16868 " called before PLplot initialization, then by default that\n"
16869 " initialization loads Hershey fonts with the extended character set.\n"
16870 " This routine only has a practical effect for devices that still use\n"
16871 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16872 " system fonts instead of Hershey fonts).\n"
16873 "\n"
16874 " Redacted form: plfontld(fnt)\n"
16875 "\n"
16876 " This function is used in examples 1 and 7.\n"
16877 "\n"
16878 "\n"
16879 "\n"
16880 "SYNOPSIS:\n"
16881 "\n"
16882 "plfontld(fnt)\n"
16883 "\n"
16884 "ARGUMENTS:\n"
16885 "\n"
16886 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16887 " A zero value specifies Hershey fonts with the standard character\n"
16888 " set and a non-zero value (the default assumed if plfontld is never\n"
16889 " called) specifies Hershey fonts with the extended character set.\n"
16890 "\n"
16891 ""},
16892 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16893 "Get character default height and current (scaled) height\n"
16894 "\n"
16895 "DESCRIPTION:\n"
16896 "\n"
16897 " Get character default height and current (scaled) height.\n"
16898 "\n"
16899 " Redacted form: plgchr(p_def, p_ht)\n"
16900 "\n"
16901 " This function is used in example 23.\n"
16902 "\n"
16903 "\n"
16904 "\n"
16905 "SYNOPSIS:\n"
16906 "\n"
16907 "plgchr(p_def, p_ht)\n"
16908 "\n"
16909 "ARGUMENTS:\n"
16910 "\n"
16911 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16912 " character height (mm).\n"
16913 "\n"
16914 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16915 " character height (mm).\n"
16916 "\n"
16917 ""},
16918 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16919 "Returns 8-bit RGB values for given color index from cmap0\n"
16920 "\n"
16921 "DESCRIPTION:\n"
16922 "\n"
16923 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16924 " PLplot documentation). Values are negative if an invalid color id is\n"
16925 " given.\n"
16926 "\n"
16927 " Redacted form: plgcol0(icol0, r, g, b)\n"
16928 "\n"
16929 " This function is used in example 2.\n"
16930 "\n"
16931 "\n"
16932 "\n"
16933 "SYNOPSIS:\n"
16934 "\n"
16935 "plgcol0(icol0, r, g, b)\n"
16936 "\n"
16937 "ARGUMENTS:\n"
16938 "\n"
16939 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16940 "\n"
16941 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16942 " value.\n"
16943 "\n"
16944 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16945 " value.\n"
16946 "\n"
16947 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16948 " value.\n"
16949 "\n"
16950 ""},
16951 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16952 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16953 "\n"
16954 "DESCRIPTION:\n"
16955 "\n"
16956 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16957 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16958 " Values are negative if an invalid color id is given.\n"
16959 "\n"
16960 " Redacted form: plgcola(r, g, b)\n"
16961 "\n"
16962 " This function is used in example 30.\n"
16963 "\n"
16964 "\n"
16965 "\n"
16966 "SYNOPSIS:\n"
16967 "\n"
16968 "plgcol0a(icol0, r, g, b, alpha)\n"
16969 "\n"
16970 "ARGUMENTS:\n"
16971 "\n"
16972 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16973 "\n"
16974 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16975 " in the range from 0 to 255.\n"
16976 "\n"
16977 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16978 " in the range from 0 to 255.\n"
16979 "\n"
16980 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16981 " in the range from 0 to 255.\n"
16982 "\n"
16983 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16984 " transparency in the range from (0.0-1.0).\n"
16985 "\n"
16986 ""},
16987 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16988 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16989 "\n"
16990 "DESCRIPTION:\n"
16991 "\n"
16992 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16993 "\n"
16994 " Redacted form: plgcolbg(r, g, b)\n"
16995 "\n"
16996 " This function is used in example 31.\n"
16997 "\n"
16998 "\n"
16999 "\n"
17000 "SYNOPSIS:\n"
17001 "\n"
17002 "plgcolbg(r, g, b)\n"
17003 "\n"
17004 "ARGUMENTS:\n"
17005 "\n"
17006 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17007 " in the range from 0 to 255.\n"
17008 "\n"
17009 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17010 " in the range from 0 to 255.\n"
17011 "\n"
17012 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17013 " in the range from 0 to 255.\n"
17014 "\n"
17015 ""},
17016 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
17017 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
17018 "\n"
17019 "DESCRIPTION:\n"
17020 "\n"
17021 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17022 " alpha transparency value.\n"
17023 "\n"
17024 " This function is used in example 31.\n"
17025 "\n"
17026 "\n"
17027 "\n"
17028 "SYNOPSIS:\n"
17029 "\n"
17030 "plgcolbga(r, g, b, alpha)\n"
17031 "\n"
17032 "ARGUMENTS:\n"
17033 "\n"
17034 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17035 " in the range from 0 to 255.\n"
17036 "\n"
17037 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17038 " in the range from 0 to 255.\n"
17039 "\n"
17040 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17041 " in the range from 0 to 255.\n"
17042 "\n"
17043 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17044 " transparency in the range (0.0-1.0).\n"
17045 "\n"
17046 ""},
17047 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17048 "Get the current device-compression setting\n"
17049 "\n"
17050 "DESCRIPTION:\n"
17051 "\n"
17052 " Get the current device-compression setting. This parameter is only\n"
17053 " used for drivers that provide compression.\n"
17054 "\n"
17055 " Redacted form: plgcompression(compression)\n"
17056 "\n"
17057 " This function is used in example 31.\n"
17058 "\n"
17059 "\n"
17060 "\n"
17061 "SYNOPSIS:\n"
17062 "\n"
17063 "plgcompression(compression)\n"
17064 "\n"
17065 "ARGUMENTS:\n"
17066 "\n"
17067 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17068 " compression setting for the current device.\n"
17069 "\n"
17070 ""},
17071 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17072 "Get the current device (keyword) name\n"
17073 "\n"
17074 "DESCRIPTION:\n"
17075 "\n"
17076 " Get the current device (keyword) name. Note: you must have allocated\n"
17077 " space for this (80 characters is safe).\n"
17078 "\n"
17079 " Redacted form: plgdev(p_dev)\n"
17080 "\n"
17081 " This function is used in example 14.\n"
17082 "\n"
17083 "\n"
17084 "\n"
17085 "SYNOPSIS:\n"
17086 "\n"
17087 "plgdev(p_dev)\n"
17088 "\n"
17089 "ARGUMENTS:\n"
17090 "\n"
17091 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17092 " (with preallocated length of 80 characters or more) containing the\n"
17093 " device (keyword) name.\n"
17094 "\n"
17095 ""},
17096 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17097 "Get parameters that define current device-space window\n"
17098 "\n"
17099 "DESCRIPTION:\n"
17100 "\n"
17101 " Get relative margin width, aspect ratio, and relative justification\n"
17102 " that define current device-space window. If plsdidev has not been\n"
17103 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17104 " p_jy will all be 0.\n"
17105 "\n"
17106 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17107 "\n"
17108 " This function is used in example 31.\n"
17109 "\n"
17110 "\n"
17111 "\n"
17112 "SYNOPSIS:\n"
17113 "\n"
17114 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17115 "\n"
17116 "ARGUMENTS:\n"
17117 "\n"
17118 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17119 " margin width.\n"
17120 "\n"
17121 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17122 " ratio.\n"
17123 "\n"
17124 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17125 " justification in x.\n"
17126 "\n"
17127 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17128 " justification in y.\n"
17129 "\n"
17130 ""},
17131 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17132 "Get plot orientation\n"
17133 "\n"
17134 "DESCRIPTION:\n"
17135 "\n"
17136 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17137 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17138 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17139 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17140 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17141 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17142 " not been called the default value pointed to by p_rot will be 0.\n"
17143 "\n"
17144 " Redacted form: plgdiori(p_rot)\n"
17145 "\n"
17146 " This function is not used in any examples.\n"
17147 "\n"
17148 "\n"
17149 "\n"
17150 "SYNOPSIS:\n"
17151 "\n"
17152 "plgdiori(p_rot)\n"
17153 "\n"
17154 "ARGUMENTS:\n"
17155 "\n"
17156 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17157 " parameter.\n"
17158 "\n"
17159 ""},
17160 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17161 "Get parameters that define current plot-space window\n"
17162 "\n"
17163 "DESCRIPTION:\n"
17164 "\n"
17165 " Get relative minima and maxima that define current plot-space window.\n"
17166 " If plsdiplt has not been called the default values pointed to by\n"
17167 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17168 "\n"
17169 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17170 "\n"
17171 " This function is used in example 31.\n"
17172 "\n"
17173 "\n"
17174 "\n"
17175 "SYNOPSIS:\n"
17176 "\n"
17177 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17178 "\n"
17179 "ARGUMENTS:\n"
17180 "\n"
17181 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17182 " minimum in x.\n"
17183 "\n"
17184 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17185 " minimum in y.\n"
17186 "\n"
17187 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17188 " maximum in x.\n"
17189 "\n"
17190 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17191 " maximum in y.\n"
17192 "\n"
17193 ""},
17194 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17195 "Get family file parameters\n"
17196 "\n"
17197 "DESCRIPTION:\n"
17198 "\n"
17199 " Gets information about current family file, if familying is enabled.\n"
17200 " See the PLplot documentation for more information.\n"
17201 "\n"
17202 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17203 "\n"
17204 " This function is used in examples 14 and 31.\n"
17205 "\n"
17206 "\n"
17207 "\n"
17208 "SYNOPSIS:\n"
17209 "\n"
17210 "plgfam(p_fam, p_num, p_bmax)\n"
17211 "\n"
17212 "ARGUMENTS:\n"
17213 "\n"
17214 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17215 " family flag value. If nonzero, familying is enabled for the\n"
17216 " current device.\n"
17217 "\n"
17218 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17219 " family file number.\n"
17220 "\n"
17221 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17222 " file size (in bytes) for a family file.\n"
17223 "\n"
17224 ""},
17225 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17226 "Get FCI (font characterization integer)\n"
17227 "\n"
17228 "DESCRIPTION:\n"
17229 "\n"
17230 " Gets information about the current font using the FCI approach. See\n"
17231 " the PLplot documentation for more information.\n"
17232 "\n"
17233 " Redacted form: plgfci(p_fci)\n"
17234 "\n"
17235 " This function is used in example 23.\n"
17236 "\n"
17237 "\n"
17238 "\n"
17239 "SYNOPSIS:\n"
17240 "\n"
17241 "plgfci(p_fci)\n"
17242 "\n"
17243 "ARGUMENTS:\n"
17244 "\n"
17245 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17246 " FCI value.\n"
17247 "\n"
17248 ""},
17249 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17250 "Get output file name\n"
17251 "\n"
17252 "DESCRIPTION:\n"
17253 "\n"
17254 " Gets the current output file name, if applicable.\n"
17255 "\n"
17256 " Redacted form: plgfnam(fnam)\n"
17257 "\n"
17258 " This function is used in example 31.\n"
17259 "\n"
17260 "\n"
17261 "\n"
17262 "SYNOPSIS:\n"
17263 "\n"
17264 "plgfnam(fnam)\n"
17265 "\n"
17266 "ARGUMENTS:\n"
17267 "\n"
17268 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17269 " (with preallocated length of 80 characters or more) containing the\n"
17270 " file name.\n"
17271 "\n"
17272 ""},
17273 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17274 "Get family, style and weight of the current font\n"
17275 "\n"
17276 "DESCRIPTION:\n"
17277 "\n"
17278 " Gets information about current font. See the PLplot documentation for\n"
17279 " more information on font selection.\n"
17280 "\n"
17281 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17282 "\n"
17283 " This function is used in example 23.\n"
17284 "\n"
17285 "\n"
17286 "\n"
17287 "SYNOPSIS:\n"
17288 "\n"
17289 "plgfont(p_family, p_style, p_weight)\n"
17290 "\n"
17291 "ARGUMENTS:\n"
17292 "\n"
17293 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17294 " font family. The available values are given by the PL_FCI_*\n"
17295 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17296 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17297 " p_family is NULL then the font family is not returned.\n"
17298 "\n"
17299 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17300 " font style. The available values are given by the PL_FCI_*\n"
17301 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17302 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17303 " style is not returned.\n"
17304 "\n"
17305 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17306 " font weight. The available values are given by the PL_FCI_*\n"
17307 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17308 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17309 " returned.\n"
17310 "\n"
17311 ""},
17312 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17313 "Get the (current) run level\n"
17314 "\n"
17315 "DESCRIPTION:\n"
17316 "\n"
17317 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17318 " 1, initialized\n"
17319 " 2, viewport defined\n"
17320 " 3, world coordinates defined\n"
17321 "\n"
17322 "\n"
17323 " Redacted form: plglevel(p_level)\n"
17324 "\n"
17325 " This function is used in example 31.\n"
17326 "\n"
17327 "\n"
17328 "\n"
17329 "SYNOPSIS:\n"
17330 "\n"
17331 "plglevel(p_level)\n"
17332 "\n"
17333 "ARGUMENTS:\n"
17334 "\n"
17335 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17336 " level.\n"
17337 "\n"
17338 ""},
17339 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17340 "Get page parameters\n"
17341 "\n"
17342 "DESCRIPTION:\n"
17343 "\n"
17344 " Gets the current page configuration. The length and offset values are\n"
17345 " expressed in units that are specific to the current driver. For\n"
17346 " instance: screen drivers will usually interpret them as number of\n"
17347 " pixels, whereas printer drivers will usually use mm.\n"
17348 "\n"
17349 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17350 "\n"
17351 " This function is used in examples 14 and 31.\n"
17352 "\n"
17353 "\n"
17354 "\n"
17355 "SYNOPSIS:\n"
17356 "\n"
17357 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17358 "\n"
17359 "ARGUMENTS:\n"
17360 "\n"
17361 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17362 " pixels/inch (DPI) in x.\n"
17363 "\n"
17364 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17365 " pixels/inch (DPI) in y.\n"
17366 "\n"
17367 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17368 " length.\n"
17369 "\n"
17370 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17371 " length.\n"
17372 "\n"
17373 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17374 " offset.\n"
17375 "\n"
17376 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17377 " offset.\n"
17378 "\n"
17379 ""},
17380 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17381 "Switch to graphics screen\n"
17382 "\n"
17383 "DESCRIPTION:\n"
17384 "\n"
17385 " Sets an interactive device to graphics mode, used in conjunction with\n"
17386 " pltext to allow graphics and text to be interspersed. On a device\n"
17387 " which supports separate text and graphics windows, this command causes\n"
17388 " control to be switched to the graphics window. If already in graphics\n"
17389 " mode, this command is ignored. It is also ignored on devices which\n"
17390 " only support a single window or use a different method for shifting\n"
17391 " focus. See also pltext.\n"
17392 "\n"
17393 " Redacted form: plgra()\n"
17394 "\n"
17395 " This function is used in example 1.\n"
17396 "\n"
17397 "\n"
17398 "\n"
17399 "SYNOPSIS:\n"
17400 "\n"
17401 "plgra()\n"
17402 "\n"
17403 ""},
17404 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17405 "Grid data from irregularly sampled data\n"
17406 "\n"
17407 "DESCRIPTION:\n"
17408 "\n"
17409 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17410 " require data organized as a grid, i.e., with x sample point values\n"
17411 " independent of y coordinate and vice versa. This function takes\n"
17412 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17413 " vectors; reads the desired grid location from the input vectors\n"
17414 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17415 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17416 " interpolate the data to the grid is specified with the argument type\n"
17417 " which can have one parameter specified in argument data.\n"
17418 "\n"
17419 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17420 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17421 "\n"
17422 "\n"
17423 " This function is used in example 21.\n"
17424 "\n"
17425 "\n"
17426 "\n"
17427 "SYNOPSIS:\n"
17428 "\n"
17429 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17430 "\n"
17431 "ARGUMENTS:\n"
17432 "\n"
17433 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17434 "\n"
17435 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17436 "\n"
17437 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17438 " y[i], z[i] represents one data sample coordinate.\n"
17439 "\n"
17440 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17441 " vectors.\n"
17442 "\n"
17443 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17444 " in the x direction. Usually xg has nptsx equally spaced values\n"
17445 " from the minimum to the maximum values of the x input vector.\n"
17446 "\n"
17447 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17448 "\n"
17449 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17450 " in the y direction. Similar to the xg parameter.\n"
17451 "\n"
17452 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17453 "\n"
17454 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17455 " where data lies in the grid specified by xg and yg. Therefore the\n"
17456 " zg matrix must be dimensioned\n"
17457 " nptsx by\n"
17458 " nptsy.\n"
17459 "\n"
17460 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17461 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17462 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17463 " GRID_NNI: Natural Neighbors Interpolation\n"
17464 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17465 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17466 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17467 " Weighted\n"
17468 " For details of the algorithms read the source file plgridd.c.\n"
17469 "\n"
17470 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17471 " which can be specified through this argument. Currently, for\n"
17472 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17473 " use, the lower the value, the noisier (more local) the\n"
17474 " approximation is.\n"
17475 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17476 " range [1. .. 2.]. High values enable the usage of very thin\n"
17477 " triangles for interpolation, possibly resulting in error in\n"
17478 " the approximation.\n"
17479 " GRID_NNI, only weights greater than data will be accepted. If\n"
17480 " 0, all weights will be accepted.\n"
17481 "\n"
17482 ""},
17483 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17484 "Get current subpage parameters\n"
17485 "\n"
17486 "DESCRIPTION:\n"
17487 "\n"
17488 " Gets the size of the current subpage in millimeters measured from the\n"
17489 " bottom left hand corner of the output device page or screen. Can be\n"
17490 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17491 " absolute coordinates (millimeters).\n"
17492 "\n"
17493 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17494 "\n"
17495 " This function is used in example 23.\n"
17496 "\n"
17497 "\n"
17498 "\n"
17499 "SYNOPSIS:\n"
17500 "\n"
17501 "plgspa(xmin, xmax, ymin, ymax)\n"
17502 "\n"
17503 "ARGUMENTS:\n"
17504 "\n"
17505 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17506 " the left hand edge of the subpage in millimeters.\n"
17507 "\n"
17508 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17509 " the right hand edge of the subpage in millimeters.\n"
17510 "\n"
17511 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17512 " the bottom edge of the subpage in millimeters.\n"
17513 "\n"
17514 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17515 " the top edge of the subpage in millimeters.\n"
17516 "\n"
17517 ""},
17518 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17519 "Get current stream number\n"
17520 "\n"
17521 "DESCRIPTION:\n"
17522 "\n"
17523 " Gets the number of the current output stream. See also plsstrm.\n"
17524 "\n"
17525 " Redacted form: plgstrm(p_strm)\n"
17526 "\n"
17527 " This function is used in example 1,20.\n"
17528 "\n"
17529 "\n"
17530 "\n"
17531 "SYNOPSIS:\n"
17532 "\n"
17533 "plgstrm(p_strm)\n"
17534 "\n"
17535 "ARGUMENTS:\n"
17536 "\n"
17537 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17538 " stream value.\n"
17539 "\n"
17540 ""},
17541 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17542 "Get the current library version number\n"
17543 "\n"
17544 "DESCRIPTION:\n"
17545 "\n"
17546 " Get the current library version number. Note: you must have allocated\n"
17547 " space for this (80 characters is safe).\n"
17548 "\n"
17549 " Redacted form: plgver(p_ver)\n"
17550 "\n"
17551 " This function is used in example 1.\n"
17552 "\n"
17553 "\n"
17554 "\n"
17555 "SYNOPSIS:\n"
17556 "\n"
17557 "plgver(p_ver)\n"
17558 "\n"
17559 "ARGUMENTS:\n"
17560 "\n"
17561 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17562 " (with preallocated length of 80 characters or more) containing the\n"
17563 " PLplot version number.\n"
17564 "\n"
17565 ""},
17566 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17567 "Get viewport limits in normalized device coordinates\n"
17568 "\n"
17569 "DESCRIPTION:\n"
17570 "\n"
17571 " Get viewport limits in normalized device coordinates.\n"
17572 "\n"
17573 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17574 "\n"
17575 "\n"
17576 " This function is used in example 31.\n"
17577 "\n"
17578 "\n"
17579 "\n"
17580 "SYNOPSIS:\n"
17581 "\n"
17582 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17583 "\n"
17584 "ARGUMENTS:\n"
17585 "\n"
17586 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17587 " viewport limit of the normalized device coordinate in x.\n"
17588 "\n"
17589 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17590 " viewport limit of the normalized device coordinate in x.\n"
17591 "\n"
17592 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17593 " viewport limit of the normalized device coordinate in y.\n"
17594 "\n"
17595 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17596 " viewport limit of the normalized device coordinate in y.\n"
17597 "\n"
17598 ""},
17599 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17600 "Get viewport limits in world coordinates\n"
17601 "\n"
17602 "DESCRIPTION:\n"
17603 "\n"
17604 " Get viewport limits in world coordinates.\n"
17605 "\n"
17606 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17607 "\n"
17608 "\n"
17609 " This function is used in example 31.\n"
17610 "\n"
17611 "\n"
17612 "\n"
17613 "SYNOPSIS:\n"
17614 "\n"
17615 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17616 "\n"
17617 "ARGUMENTS:\n"
17618 "\n"
17619 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17620 " viewport limit of the world coordinate in x.\n"
17621 "\n"
17622 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17623 " viewport limit of the world coordinate in x.\n"
17624 "\n"
17625 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17626 " viewport limit of the world coordinate in y.\n"
17627 "\n"
17628 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17629 " viewport limit of the world coordinate in y.\n"
17630 "\n"
17631 ""},
17632 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17633 "Get x axis parameters\n"
17634 "\n"
17635 "DESCRIPTION:\n"
17636 "\n"
17637 " Returns current values of the p_digmax and p_digits flags for the x\n"
17638 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17639 " should only be called after the call to plbox (or plbox3) is complete.\n"
17640 " See the PLplot documentation for more information.\n"
17641 "\n"
17642 " Redacted form: plgxax(p_digmax, p_digits)\n"
17643 "\n"
17644 " This function is used in example 31.\n"
17645 "\n"
17646 "\n"
17647 "\n"
17648 "SYNOPSIS:\n"
17649 "\n"
17650 "plgxax(p_digmax, p_digits)\n"
17651 "\n"
17652 "ARGUMENTS:\n"
17653 "\n"
17654 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17655 " number of digits for the x axis. If nonzero, the printed label\n"
17656 " has been switched to a floating-point representation when the\n"
17657 " number of digits exceeds this value.\n"
17658 "\n"
17659 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17660 " number of digits for the numeric labels (x axis) from the last\n"
17661 " plot.\n"
17662 "\n"
17663 ""},
17664 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17665 "Get y axis parameters\n"
17666 "\n"
17667 "DESCRIPTION:\n"
17668 "\n"
17669 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17670 " the description of plgxax for more detail.\n"
17671 "\n"
17672 " Redacted form: plgyax(p_digmax, p_digits)\n"
17673 "\n"
17674 " This function is used in example 31.\n"
17675 "\n"
17676 "\n"
17677 "\n"
17678 "SYNOPSIS:\n"
17679 "\n"
17680 "plgyax(p_digmax, p_digits)\n"
17681 "\n"
17682 "ARGUMENTS:\n"
17683 "\n"
17684 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17685 " number of digits for the y axis. If nonzero, the printed label\n"
17686 " has been switched to a floating-point representation when the\n"
17687 " number of digits exceeds this value.\n"
17688 "\n"
17689 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17690 " number of digits for the numeric labels (y axis) from the last\n"
17691 " plot.\n"
17692 "\n"
17693 ""},
17694 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17695 "Get z axis parameters\n"
17696 "\n"
17697 "DESCRIPTION:\n"
17698 "\n"
17699 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17700 " the description of plgxax for more detail.\n"
17701 "\n"
17702 " Redacted form: plgzax(p_digmax, p_digits)\n"
17703 "\n"
17704 " This function is used in example 31.\n"
17705 "\n"
17706 "\n"
17707 "\n"
17708 "SYNOPSIS:\n"
17709 "\n"
17710 "plgzax(p_digmax, p_digits)\n"
17711 "\n"
17712 "ARGUMENTS:\n"
17713 "\n"
17714 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17715 " number of digits for the z axis. If nonzero, the printed label\n"
17716 " has been switched to a floating-point representation when the\n"
17717 " number of digits exceeds this value.\n"
17718 "\n"
17719 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17720 " number of digits for the numeric labels (z axis) from the last\n"
17721 " plot.\n"
17722 "\n"
17723 ""},
17724 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17725 "Plot a histogram from unbinned data\n"
17726 "\n"
17727 "DESCRIPTION:\n"
17728 "\n"
17729 " Plots a histogram from n data points stored in the data vector. This\n"
17730 " routine bins the data into nbin bins equally spaced between datmin and\n"
17731 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17732 " opt allows, among other things, the histogram either to be plotted in\n"
17733 " an existing window or causes plhist to call plenv with suitable limits\n"
17734 " before plotting the histogram.\n"
17735 "\n"
17736 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17737 "\n"
17738 " This function is used in example 5.\n"
17739 "\n"
17740 "\n"
17741 "\n"
17742 "SYNOPSIS:\n"
17743 "\n"
17744 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17745 "\n"
17746 "ARGUMENTS:\n"
17747 "\n"
17748 " n (PLINT, input) : Number of data points.\n"
17749 "\n"
17750 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17751 " n data points.\n"
17752 "\n"
17753 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17754 "\n"
17755 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17756 "\n"
17757 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17758 " divide the interval xmin to xmax.\n"
17759 "\n"
17760 " opt (PLINT, input) : Is a combination of several flags:\n"
17761 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17762 " the histogram data, the outer bins are expanded to fill up the\n"
17763 " entire x-axis, data outside the given extremes are assigned to the\n"
17764 " outer bins and bins of zero height are simply drawn.\n"
17765 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17766 " to fit the histogram data, without this flag, plenv is called\n"
17767 " to set the world coordinates.\n"
17768 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17769 " extremes are not taken into account. This option should\n"
17770 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17771 " properly present the data.\n"
17772 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17773 " size as the ones inside.\n"
17774 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17775 " (there is a gap for such bins).\n"
17776 "\n"
17777 ""},
17778 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17779 "Convert HLS color to RGB\n"
17780 "\n"
17781 "DESCRIPTION:\n"
17782 "\n"
17783 " Convert HLS color coordinates to RGB.\n"
17784 "\n"
17785 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17786 "\n"
17787 "\n"
17788 " This function is used in example 2.\n"
17789 "\n"
17790 "\n"
17791 "\n"
17792 "SYNOPSIS:\n"
17793 "\n"
17794 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17795 "\n"
17796 "ARGUMENTS:\n"
17797 "\n"
17798 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17799 " cylinder.\n"
17800 "\n"
17801 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17802 " the axis of the color cylinder.\n"
17803 "\n"
17804 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17805 " the radius of the color cylinder.\n"
17806 "\n"
17807 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17808 " (0.0-1.0) of the color.\n"
17809 "\n"
17810 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17811 " intensity (0.0-1.0) of the color.\n"
17812 "\n"
17813 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17814 " intensity (0.0-1.0) of the color.\n"
17815 "\n"
17816 ""},
17817 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17818 "Initialize PLplot\n"
17819 "\n"
17820 "DESCRIPTION:\n"
17821 "\n"
17822 " Initializing the plotting package. The program prompts for the device\n"
17823 " keyword or number of the desired output device. Hitting a RETURN in\n"
17824 " response to the prompt is the same as selecting the first device.\n"
17825 " plinit will issue no prompt if either the device was specified\n"
17826 " previously (via command line flag, the plsetopt function, or the\n"
17827 " plsdev function), or if only one device is enabled when PLplot is\n"
17828 " installed. If subpages have been specified, the output device is\n"
17829 " divided into nx by ny subpages, each of which may be used\n"
17830 " independently. If plinit is called again during a program, the\n"
17831 " previously opened file will be closed. The subroutine pladv is used\n"
17832 " to advance from one subpage to the next.\n"
17833 "\n"
17834 " Redacted form: plinit()\n"
17835 "\n"
17836 " This function is used in all of the examples.\n"
17837 "\n"
17838 "\n"
17839 "\n"
17840 "SYNOPSIS:\n"
17841 "\n"
17842 "plinit()\n"
17843 "\n"
17844 ""},
17845 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17846 "Draw a line between two points\n"
17847 "\n"
17848 "DESCRIPTION:\n"
17849 "\n"
17850 " Joins the point (\n"
17851 " x1,\n"
17852 " y1) to (\n"
17853 " x2,\n"
17854 " y2).\n"
17855 "\n"
17856 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17857 "\n"
17858 " This function is used in examples 3 and 14.\n"
17859 "\n"
17860 "\n"
17861 "\n"
17862 "SYNOPSIS:\n"
17863 "\n"
17864 "pljoin(x1, y1, x2, y2)\n"
17865 "\n"
17866 "ARGUMENTS:\n"
17867 "\n"
17868 " x1 (PLFLT, input) : x coordinate of first point.\n"
17869 "\n"
17870 " y1 (PLFLT, input) : y coordinate of first point.\n"
17871 "\n"
17872 " x2 (PLFLT, input) : x coordinate of second point.\n"
17873 "\n"
17874 " y2 (PLFLT, input) : y coordinate of second point.\n"
17875 "\n"
17876 ""},
17877 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17878 "Simple routine to write labels\n"
17879 "\n"
17880 "DESCRIPTION:\n"
17881 "\n"
17882 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17883 "\n"
17884 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17885 "\n"
17886 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17887 "\n"
17888 "\n"
17889 "\n"
17890 "SYNOPSIS:\n"
17891 "\n"
17892 "pllab(xlabel, ylabel, tlabel)\n"
17893 "\n"
17894 "ARGUMENTS:\n"
17895 "\n"
17896 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17897 " the label for the x axis.\n"
17898 "\n"
17899 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17900 " the label for the y axis.\n"
17901 "\n"
17902 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17903 " the title of the plot.\n"
17904 "\n"
17905 ""},
17906 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17907 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17908 "\n"
17909 "DESCRIPTION:\n"
17910 "\n"
17911 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17912 " line, and/or line of symbols for each annotated legend entry. (See\n"
17913 " plcolorbar for similar functionality for creating continuous color\n"
17914 " bars.) The arguments of pllegend provide control over the location\n"
17915 " and size of the legend as well as the location and characteristics of\n"
17916 " the elements (most of which are optional) within that legend. The\n"
17917 " resulting legend is clipped at the boundaries of the current subpage.\n"
17918 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17919 " defined in the documentation of the position parameter.)\n"
17920 "\n"
17921 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17922 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17923 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17924 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17925 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17926 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17927 "\n"
17928 " This function is used in examples 4, 26, and 33.\n"
17929 "\n"
17930 "\n"
17931 "\n"
17932 "SYNOPSIS:\n"
17933 "\n"
17934 "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"
17935 "\n"
17936 "ARGUMENTS:\n"
17937 "\n"
17938 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17939 " legend width in adopted coordinates. This quantity is calculated\n"
17940 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17941 " the routine depending on nlegend and nrow), and the length\n"
17942 " (calculated internally) of the longest text string.\n"
17943 "\n"
17944 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17945 " legend height in adopted coordinates. This quantity is calculated\n"
17946 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17947 " the routine depending on nlegend and nrow).\n"
17948 "\n"
17949 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17950 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17951 " on the left of the legend and the plotted area on the right.\n"
17952 " Otherwise, put the text area on the right of the legend and the\n"
17953 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17954 " plot a (semitransparent) background for the legend. If the\n"
17955 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17956 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17957 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17958 " plot the resulting array of legend entries in row-major order.\n"
17959 " Otherwise, plot the legend entries in column-major order.\n"
17960 "\n"
17961 " position (PLINT, input) : position contains bits which control the\n"
17962 " overall position of the legend and the definition of the adopted\n"
17963 " coordinates used for positions just like what is done for the\n"
17964 " position argument for plcolorbar. However, note that the defaults\n"
17965 " for the position bits (see below) are different than the\n"
17966 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17967 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17968 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17969 " the 16 possible standard positions (the 4 corners and centers of\n"
17970 " the 4 sides for both the inside and outside cases) of the legend\n"
17971 " relative to the adopted coordinate system. The corner positions\n"
17972 " are specified by the appropriate combination of two of the\n"
17973 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17974 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17975 " value of one of those bits. The adopted coordinates are\n"
17976 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17977 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17978 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17979 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17980 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17981 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17982 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17983 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17984 "\n"
17985 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17986 " coordinates from the specified standard position of the legend.\n"
17987 " For positive x, the direction of motion away from the standard\n"
17988 " position is inward/outward from the standard corner positions or\n"
17989 " standard left or right positions if the\n"
17990 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17991 " For the standard top or bottom positions, the direction of motion\n"
17992 " is toward positive X.\n"
17993 "\n"
17994 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17995 " coordinates from the specified standard position of the legend.\n"
17996 " For positive y, the direction of motion away from the standard\n"
17997 " position is inward/outward from the standard corner positions or\n"
17998 " standard top or bottom positions if the\n"
17999 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
18000 " the standard left or right positions, the direction of motion is\n"
18001 " toward positive Y.\n"
18002 "\n"
18003 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
18004 " of the plot area (where the colored boxes, lines, and/or lines of\n"
18005 " symbols are drawn) of the legend.\n"
18006 "\n"
18007 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18008 " legend (PL_LEGEND_BACKGROUND).\n"
18009 "\n"
18010 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18011 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
18012 "\n"
18013 " bb_style (PLINT, input) : The pllsty style number for the\n"
18014 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
18015 "\n"
18016 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
18017 " render the\n"
18018 " nlegend legend entries. For internal transformations of\n"
18019 " nrow, see further remarks under\n"
18020 " nlegend.\n"
18021 "\n"
18022 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18023 " to render the\n"
18024 " nlegend legend entries. For internal transformations of\n"
18025 " ncolumn, see further remarks under\n"
18026 " nlegend.\n"
18027 "\n"
18028 " nlegend (PLINT, input) : Number of legend entries. The above\n"
18029 " nrow and\n"
18030 " ncolumn values are transformed internally to be consistent with\n"
18031 " nlegend. If either\n"
18032 " nrow or\n"
18033 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18034 " of\n"
18035 " nrow and\n"
18036 " ncolumn is less than\n"
18037 " nlegend, the smaller of the two (or\n"
18038 " nrow, if\n"
18039 " nrow ==\n"
18040 " ncolumn) is increased so the product is >=\n"
18041 " nlegend. Thus, for example, the common\n"
18042 " nrow = 0,\n"
18043 " ncolumn = 0 case is transformed internally to\n"
18044 " nrow =\n"
18045 " nlegend,\n"
18046 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18047 " column.\n"
18048 "\n"
18049 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18050 " nlegend values of options to control each individual plotted area\n"
18051 " corresponding to a legend entry. If the\n"
18052 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18053 " area. If the\n"
18054 " PL_LEGEND_COLOR_BOX,\n"
18055 " PL_LEGEND_LINE, and/or\n"
18056 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18057 " entry is plotted with a colored box; a line; and/or a line of\n"
18058 " symbols.\n"
18059 "\n"
18060 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18061 " area in units of character width.\n"
18062 "\n"
18063 " text_scale (PLFLT, input) : Character height scale for text\n"
18064 " annotations.\n"
18065 "\n"
18066 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18067 " character height from one legend entry to the next.\n"
18068 "\n"
18069 " text_justification (PLFLT, input) : Justification parameter used\n"
18070 " for text justification. The most common values of\n"
18071 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18072 " is left justified, centred, or right justified within the text\n"
18073 " area, but other values are allowed as well.\n"
18074 "\n"
18075 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18076 " nlegend cmap0 text colors.\n"
18077 "\n"
18078 " text (PLCHAR_MATRIX, input) : A vector of\n"
18079 " nlegend UTF-8 character strings containing the legend annotations.\n"
18080 "\n"
18081 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18082 " nlegend cmap0 colors for the discrete colored boxes (\n"
18083 " PL_LEGEND_COLOR_BOX).\n"
18084 "\n"
18085 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18086 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18087 " PL_LEGEND_COLOR_BOX).\n"
18088 "\n"
18089 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18090 " nlegend scales (units of fraction of character height) for the height\n"
18091 " of the discrete colored boxes (\n"
18092 " PL_LEGEND_COLOR_BOX).\n"
18093 "\n"
18094 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18095 " nlegend line widths for the patterns specified by box_patterns (\n"
18096 " PL_LEGEND_COLOR_BOX).\n"
18097 "\n"
18098 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18099 " nlegend cmap0 line colors (\n"
18100 " PL_LEGEND_LINE).\n"
18101 "\n"
18102 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18103 " nlegend line styles (plsty indices) (\n"
18104 " PL_LEGEND_LINE).\n"
18105 "\n"
18106 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18107 " nlegend line widths (\n"
18108 " PL_LEGEND_LINE).\n"
18109 "\n"
18110 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18111 " nlegend cmap0 symbol colors (\n"
18112 " PL_LEGEND_SYMBOL).\n"
18113 "\n"
18114 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18115 " nlegend scale values for the symbol height (\n"
18116 " PL_LEGEND_SYMBOL).\n"
18117 "\n"
18118 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18119 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18120 " area (\n"
18121 " PL_LEGEND_SYMBOL).\n"
18122 "\n"
18123 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18124 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18125 " PL_LEGEND_SYMBOL).\n"
18126 "\n"
18127 ""},
18128 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18129 "Plot color bar for image, shade or gradient plots\n"
18130 "\n"
18131 "DESCRIPTION:\n"
18132 "\n"
18133 " Routine for creating a continuous color bar for image, shade, or\n"
18134 " gradient plots. (See pllegend for similar functionality for creating\n"
18135 " legends with discrete elements). The arguments of plcolorbar provide\n"
18136 " control over the location and size of the color bar as well as the\n"
18137 " location and characteristics of the elements (most of which are\n"
18138 " optional) within that color bar. The resulting color bar is clipped\n"
18139 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18140 " system used for some of the parameters is defined in the documentation\n"
18141 " of the position parameter.)\n"
18142 "\n"
18143 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18144 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18145 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18146 " labels, axis_opts, ticks, sub_ticks, values)\n"
18147 "\n"
18148 " This function is used in examples 16 and 33.\n"
18149 "\n"
18150 "\n"
18151 "\n"
18152 "SYNOPSIS:\n"
18153 "\n"
18154 "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"
18155 "\n"
18156 "ARGUMENTS:\n"
18157 "\n"
18158 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18159 " labelled and decorated color bar width in adopted coordinates.\n"
18160 "\n"
18161 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18162 " labelled and decorated color bar height in adopted coordinates.\n"
18163 "\n"
18164 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18165 " color bar. The orientation (direction of the maximum value) of\n"
18166 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18167 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18168 " specified, the default orientation is toward the top if the\n"
18169 " colorbar is placed on the left or right of the viewport or toward\n"
18170 " the right if the colorbar is placed on the top or bottom of the\n"
18171 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18172 " (semitransparent) background for the color bar. If the\n"
18173 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18174 " color bar. The type of color bar must be specified with one of\n"
18175 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18176 " more than one of those bits is set only the first one in the above\n"
18177 " list is honored. The position of the (optional) label/title can be\n"
18178 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18179 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18180 " will be drawn. If more than one of this list of bits is specified,\n"
18181 " only the first one on the list is honored. End-caps for the color\n"
18182 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18183 " If a particular color bar cap option is not specified then no cap\n"
18184 " will be drawn for that end. As a special case for\n"
18185 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18186 " specified. If this option is provided then any tick marks and tick\n"
18187 " labels will be placed at the breaks between shaded segments. TODO:\n"
18188 " This should be expanded to support custom placement of tick marks\n"
18189 " and tick labels at custom value locations for any color bar type.\n"
18190 "\n"
18191 " position (PLINT, input) : position contains bits which control the\n"
18192 " overall position of the color bar and the definition of the\n"
18193 " adopted coordinates used for positions just like what is done for\n"
18194 " the position argument for pllegend. However, note that the\n"
18195 " defaults for the position bits (see below) are different than the\n"
18196 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18197 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18198 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18199 " the 16 possible standard positions (the 4 corners and centers of\n"
18200 " the 4 sides for both the inside and outside cases) of the color\n"
18201 " bar relative to the adopted coordinate system. The corner\n"
18202 " positions are specified by the appropriate combination of two of\n"
18203 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18204 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18205 " value of one of those bits. The adopted coordinates are\n"
18206 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18207 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18208 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18209 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18210 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18211 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18212 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18213 " PL_POSITION_VIEWPORT.\n"
18214 "\n"
18215 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18216 " coordinates from the specified standard position of the color bar.\n"
18217 " For positive x, the direction of motion away from the standard\n"
18218 " position is inward/outward from the standard corner positions or\n"
18219 " standard left or right positions if the\n"
18220 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18221 " For the standard top or bottom positions, the direction of motion\n"
18222 " is toward positive X.\n"
18223 "\n"
18224 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18225 " coordinates from the specified standard position of the color bar.\n"
18226 " For positive y, the direction of motion away from the standard\n"
18227 " position is inward/outward from the standard corner positions or\n"
18228 " standard top or bottom positions if the\n"
18229 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18230 " For the standard left or right positions, the direction of motion\n"
18231 " is toward positive Y.\n"
18232 "\n"
18233 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18234 " the X direction in adopted coordinates.\n"
18235 "\n"
18236 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18237 " the Y direction in adopted coordinates.\n"
18238 "\n"
18239 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18240 " color bar (PL_COLORBAR_BACKGROUND).\n"
18241 "\n"
18242 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18243 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18244 "\n"
18245 " bb_style (PLINT, input) : The pllsty style number for the\n"
18246 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18247 "\n"
18248 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18249 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18250 "\n"
18251 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18252 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18253 "\n"
18254 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18255 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18256 " it will be interpreted according to the design of plshades.\n"
18257 "\n"
18258 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18259 " plots. This is passed directly to plshades, so it will be\n"
18260 " interpreted according to the design of plshades.\n"
18261 "\n"
18262 " n_labels (PLINT, input) : Number of labels to place around the\n"
18263 " color bar.\n"
18264 "\n"
18265 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18266 " n_labels labels.\n"
18267 "\n"
18268 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18269 " n_labels UTF-8 character strings containing the labels for the color\n"
18270 " bar. Ignored if no label position is specified with one of the\n"
18271 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18272 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18273 " corresponding label_opts field.\n"
18274 "\n"
18275 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18276 " value must be greater than 0. It is typically 1 (numerical axis\n"
18277 " labels are provided for one of the long edges of the color bar),\n"
18278 " but it can be larger if multiple numerical axis labels for the\n"
18279 " long edges of the color bar are desired.\n"
18280 "\n"
18281 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18282 " n_axes ascii character strings containing options (interpreted as for\n"
18283 " plbox) for the color bar's axis definitions.\n"
18284 "\n"
18285 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18286 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18287 " color bar's axis definitions.\n"
18288 "\n"
18289 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18290 " number of subticks (interpreted as for plbox) for the color bar's\n"
18291 " axis definitions.\n"
18292 "\n"
18293 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18294 " elements in each of the n_axes rows of the values matrix.\n"
18295 "\n"
18296 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18297 " values for the data range represented by the color bar. For a row\n"
18298 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18299 " elements in the row is specified by n_values[i_axis]. For\n"
18300 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18301 " is 2, and the corresponding row elements of the values matrix are\n"
18302 " the minimum and maximum value represented by the colorbar. For\n"
18303 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18304 " of the values matrix is interpreted the same as the nlevel and\n"
18305 " clevel arguments of plshades.\n"
18306 "\n"
18307 ""},
18308 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18309 "Sets the 3D position of the light source\n"
18310 "\n"
18311 "DESCRIPTION:\n"
18312 "\n"
18313 " Sets the 3D position of the light source for use with plsurf3d and\n"
18314 " plsurf3dl\n"
18315 "\n"
18316 " Redacted form: pllightsource(x, y, z)\n"
18317 "\n"
18318 " This function is used in example 8.\n"
18319 "\n"
18320 "\n"
18321 "\n"
18322 "SYNOPSIS:\n"
18323 "\n"
18324 "pllightsource(x, y, z)\n"
18325 "\n"
18326 "ARGUMENTS:\n"
18327 "\n"
18328 " x (PLFLT, input) : X-coordinate of the light source.\n"
18329 "\n"
18330 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18331 "\n"
18332 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18333 "\n"
18334 ""},
18335 { "plline", _wrap_plline, METH_VARARGS, "\n"
18336 "Draw a line\n"
18337 "\n"
18338 "DESCRIPTION:\n"
18339 "\n"
18340 " Draws line defined by n points in x and y.\n"
18341 "\n"
18342 " Redacted form: plline(x, y)\n"
18343 "\n"
18344 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18345 " 25-27, and 29.\n"
18346 "\n"
18347 "\n"
18348 "\n"
18349 "SYNOPSIS:\n"
18350 "\n"
18351 "plline(n, x, y)\n"
18352 "\n"
18353 "ARGUMENTS:\n"
18354 "\n"
18355 " n (PLINT, input) : Number of points defining line.\n"
18356 "\n"
18357 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18358 " points.\n"
18359 "\n"
18360 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18361 " points.\n"
18362 "\n"
18363 ""},
18364 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18365 "Draw a line in 3 space\n"
18366 "\n"
18367 "DESCRIPTION:\n"
18368 "\n"
18369 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18370 " first set up the viewport, the 2d viewing window (in world\n"
18371 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18372 " more info.\n"
18373 "\n"
18374 " Redacted form: plline3(x, y, z)\n"
18375 "\n"
18376 " This function is used in example 18.\n"
18377 "\n"
18378 "\n"
18379 "\n"
18380 "SYNOPSIS:\n"
18381 "\n"
18382 "plline3(n, x, y, z)\n"
18383 "\n"
18384 "ARGUMENTS:\n"
18385 "\n"
18386 " n (PLINT, input) : Number of points defining line.\n"
18387 "\n"
18388 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18389 " points.\n"
18390 "\n"
18391 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18392 " points.\n"
18393 "\n"
18394 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18395 " points.\n"
18396 "\n"
18397 ""},
18398 { "pllsty", _wrap_pllsty, METH_O, "\n"
18399 "Select line style\n"
18400 "\n"
18401 "DESCRIPTION:\n"
18402 "\n"
18403 " This sets the line style according to one of eight predefined patterns\n"
18404 " (also see plstyl).\n"
18405 "\n"
18406 " Redacted form: pllsty(lin)\n"
18407 "\n"
18408 " This function is used in examples 9, 12, 22, and 25.\n"
18409 "\n"
18410 "\n"
18411 "\n"
18412 "SYNOPSIS:\n"
18413 "\n"
18414 "pllsty(lin)\n"
18415 "\n"
18416 "ARGUMENTS:\n"
18417 "\n"
18418 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18419 " a continuous line, line style 2 is a line with short dashes and\n"
18420 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18421 " 4 has long dashes and short gaps and so on.\n"
18422 "\n"
18423 ""},
18424 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18425 "Plot surface mesh\n"
18426 "\n"
18427 "DESCRIPTION:\n"
18428 "\n"
18429 " Plots a surface mesh within the environment set up by plw3d. The\n"
18430 " surface is defined by the matrix z[\n"
18431 " nx][\n"
18432 " ny] , the point z[i][j] being the value of the function at (\n"
18433 " x[i],\n"
18434 " y[j]). Note that the points in vectors x and y do not need to be\n"
18435 " equally spaced, but must be stored in ascending order. The parameter\n"
18436 " opt controls the way in which the surface is displayed. For further\n"
18437 " details see the PLplot documentation.\n"
18438 "\n"
18439 " Redacted form: plmesh(x, y, z, opt)\n"
18440 "\n"
18441 " This function is used in example 11.\n"
18442 "\n"
18443 "\n"
18444 "\n"
18445 "SYNOPSIS:\n"
18446 "\n"
18447 "plmesh(x, y, z, nx, ny, opt)\n"
18448 "\n"
18449 "ARGUMENTS:\n"
18450 "\n"
18451 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18452 " which the function is evaluated.\n"
18453 "\n"
18454 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18455 " which the function is evaluated.\n"
18456 "\n"
18457 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18458 " plot. Should have dimensions of\n"
18459 " nx by\n"
18460 " ny.\n"
18461 "\n"
18462 " nx (PLINT, input) : Number of x values at which function has been\n"
18463 " evaluated.\n"
18464 "\n"
18465 " ny (PLINT, input) : Number of y values at which function has been\n"
18466 " evaluated.\n"
18467 "\n"
18468 " opt (PLINT, input) : Determines the way in which the surface is\n"
18469 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18470 " function of x for each value of y[j] .\n"
18471 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18472 " for each value of x[i] .\n"
18473 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18474 " at which function is defined.\n"
18475 "\n"
18476 ""},
18477 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18478 "Magnitude colored plot surface mesh with contour\n"
18479 "\n"
18480 "DESCRIPTION:\n"
18481 "\n"
18482 " A more powerful form of plmesh: the surface mesh can be colored\n"
18483 " accordingly to the current z value being plotted, a contour plot can\n"
18484 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18485 " plotted function border and the base XY plane.\n"
18486 "\n"
18487 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18488 "\n"
18489 " This function is used in example 11.\n"
18490 "\n"
18491 "\n"
18492 "\n"
18493 "SYNOPSIS:\n"
18494 "\n"
18495 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18496 "\n"
18497 "ARGUMENTS:\n"
18498 "\n"
18499 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18500 " which the function is evaluated.\n"
18501 "\n"
18502 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18503 " which the function is evaluated.\n"
18504 "\n"
18505 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18506 " plot. Should have dimensions of\n"
18507 " nx by\n"
18508 " ny.\n"
18509 "\n"
18510 " nx (PLINT, input) : Number of x values at which function is\n"
18511 " evaluated.\n"
18512 "\n"
18513 " ny (PLINT, input) : Number of y values at which function is\n"
18514 " evaluated.\n"
18515 "\n"
18516 " opt (PLINT, input) : Determines the way in which the surface is\n"
18517 " represented. To specify more than one option just add the options,\n"
18518 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18519 " showing z as a function of x for each value of y[j] .\n"
18520 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18521 " for each value of x[i] .\n"
18522 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18523 " at which function is defined.\n"
18524 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18525 " the z value being plotted. The color is used from the current\n"
18526 " cmap1.\n"
18527 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18528 " using parameters\n"
18529 " nlevel and\n"
18530 " clevel.\n"
18531 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18532 " the borders of the plotted function.\n"
18533 "\n"
18534 "\n"
18535 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18536 " levels.\n"
18537 "\n"
18538 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18539 "\n"
18540 ""},
18541 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18542 "Creates a new stream and makes it the default\n"
18543 "\n"
18544 "DESCRIPTION:\n"
18545 "\n"
18546 " Creates a new stream and makes it the default. Differs from using\n"
18547 " plsstrm, in that a free stream number is found, and returned.\n"
18548 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18549 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18550 " that no initial, library-opening call is required. So stream 0 must\n"
18551 " be preallocated, and there is no simple way of determining whether it\n"
18552 " is already in use or not.\n"
18553 "\n"
18554 " Redacted form: plmkstrm(p_strm)\n"
18555 "\n"
18556 " This function is used in examples 1 and 20.\n"
18557 "\n"
18558 "\n"
18559 "\n"
18560 "SYNOPSIS:\n"
18561 "\n"
18562 "plmkstrm(p_strm)\n"
18563 "\n"
18564 "ARGUMENTS:\n"
18565 "\n"
18566 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18567 " number of the created stream.\n"
18568 "\n"
18569 ""},
18570 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18571 "Write text relative to viewport boundaries\n"
18572 "\n"
18573 "DESCRIPTION:\n"
18574 "\n"
18575 " Writes text at a specified position relative to the viewport\n"
18576 " boundaries. Text may be written inside or outside the viewport, but\n"
18577 " is clipped at the subpage boundaries. The reference point of a string\n"
18578 " lies along a line passing through the string at half the height of a\n"
18579 " capital letter. The position of the reference point along this line\n"
18580 " is determined by just, and the position of the reference point\n"
18581 " relative to the viewport is set by disp and pos.\n"
18582 "\n"
18583 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18584 "\n"
18585 "\n"
18586 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18587 " 26.\n"
18588 "\n"
18589 "\n"
18590 "\n"
18591 "SYNOPSIS:\n"
18592 "\n"
18593 "plmtex(side, disp, pos, just, text)\n"
18594 "\n"
18595 "ARGUMENTS:\n"
18596 "\n"
18597 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18598 " the side of the viewport along which the text is to be written.\n"
18599 " The string must be one of: b: Bottom of viewport, text written\n"
18600 " parallel to edge.\n"
18601 " bv: Bottom of viewport, text written at right angles to edge.\n"
18602 " l: Left of viewport, text written parallel to edge.\n"
18603 " lv: Left of viewport, text written at right angles to edge.\n"
18604 " r: Right of viewport, text written parallel to edge.\n"
18605 " rv: Right of viewport, text written at right angles to edge.\n"
18606 " t: Top of viewport, text written parallel to edge.\n"
18607 " tv: Top of viewport, text written at right angles to edge.\n"
18608 "\n"
18609 "\n"
18610 " disp (PLFLT, input) : Position of the reference point of string,\n"
18611 " measured outwards from the specified viewport edge in units of the\n"
18612 " current character height. Use negative disp to write within the\n"
18613 " viewport.\n"
18614 "\n"
18615 " pos (PLFLT, input) : Position of the reference point of string\n"
18616 " along the specified edge, expressed as a fraction of the length of\n"
18617 " the edge.\n"
18618 "\n"
18619 " just (PLFLT, input) : Specifies the position of the string relative\n"
18620 " to its reference point. If just=0. , the reference point is at\n"
18621 " the left and if just=1. , it is at the right of the string. Other\n"
18622 " values of just give intermediate justifications.\n"
18623 "\n"
18624 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18625 " written out.\n"
18626 "\n"
18627 ""},
18628 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18629 "Write text relative to viewport boundaries in 3D plots\n"
18630 "\n"
18631 "DESCRIPTION:\n"
18632 "\n"
18633 " Writes text at a specified position relative to the viewport\n"
18634 " boundaries. Text may be written inside or outside the viewport, but\n"
18635 " is clipped at the subpage boundaries. The reference point of a string\n"
18636 " lies along a line passing through the string at half the height of a\n"
18637 " capital letter. The position of the reference point along this line\n"
18638 " is determined by just, and the position of the reference point\n"
18639 " relative to the viewport is set by disp and pos.\n"
18640 "\n"
18641 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18642 "\n"
18643 " This function is used in example 28.\n"
18644 "\n"
18645 "\n"
18646 "\n"
18647 "SYNOPSIS:\n"
18648 "\n"
18649 "plmtex3(side, disp, pos, just, text)\n"
18650 "\n"
18651 "ARGUMENTS:\n"
18652 "\n"
18653 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18654 " the side of the viewport along which the text is to be written.\n"
18655 " The string should contain one or more of the following characters:\n"
18656 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18657 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18658 " axis.\n"
18659 " y: Label the Y axis.\n"
18660 " z: Label the Z axis.\n"
18661 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18662 " For X it is the axis that starts at y-min. For Y it is the\n"
18663 " axis that starts at x-min.\n"
18664 " s: Label the secondary axis.\n"
18665 " v: Draw the text perpendicular to the axis.\n"
18666 "\n"
18667 "\n"
18668 " disp (PLFLT, input) : Position of the reference point of string,\n"
18669 " measured outwards from the specified viewport edge in units of the\n"
18670 " current character height. Use negative disp to write within the\n"
18671 " viewport.\n"
18672 "\n"
18673 " pos (PLFLT, input) : Position of the reference point of string\n"
18674 " along the specified edge, expressed as a fraction of the length of\n"
18675 " the edge.\n"
18676 "\n"
18677 " just (PLFLT, input) : Specifies the position of the string relative\n"
18678 " to its reference point. If just=0. , the reference point is at\n"
18679 " the left and if just=1. , it is at the right of the string. Other\n"
18680 " values of just give intermediate justifications.\n"
18681 "\n"
18682 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18683 " written out.\n"
18684 "\n"
18685 ""},
18686 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18687 "Plot 3-d surface plot\n"
18688 "\n"
18689 "DESCRIPTION:\n"
18690 "\n"
18691 " Plots a three-dimensional surface plot within the environment set up\n"
18692 " by plw3d. The surface is defined by the matrix z[\n"
18693 " nx][\n"
18694 " ny] , the point z[i][j] being the value of the function at (\n"
18695 " x[i],\n"
18696 " y[j]). Note that the points in vectors x and y do not need to be\n"
18697 " equally spaced, but must be stored in ascending order. The parameter\n"
18698 " opt controls the way in which the surface is displayed. For further\n"
18699 " details see the PLplot documentation. The only difference between\n"
18700 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18701 " while plot3d only draws the surface as viewed from the top.\n"
18702 "\n"
18703 " Redacted form: plot3d(x, y, z, opt, side)\n"
18704 "\n"
18705 " This function is used in examples 11 and 21.\n"
18706 "\n"
18707 "\n"
18708 "\n"
18709 "SYNOPSIS:\n"
18710 "\n"
18711 "plot3d(x, y, z, nx, ny, opt, side)\n"
18712 "\n"
18713 "ARGUMENTS:\n"
18714 "\n"
18715 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18716 " which the function is evaluated.\n"
18717 "\n"
18718 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18719 " which the function is evaluated.\n"
18720 "\n"
18721 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18722 " plot. Should have dimensions of\n"
18723 " nx by\n"
18724 " ny.\n"
18725 "\n"
18726 " nx (PLINT, input) : Number of x values at which function is\n"
18727 " evaluated.\n"
18728 "\n"
18729 " ny (PLINT, input) : Number of y values at which function is\n"
18730 " evaluated.\n"
18731 "\n"
18732 " opt (PLINT, input) : Determines the way in which the surface is\n"
18733 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18734 " function of x for each value of y[j] .\n"
18735 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18736 " for each value of x[i] .\n"
18737 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18738 " at which function is defined.\n"
18739 "\n"
18740 "\n"
18741 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18742 " should be draw on the figure. If side is true sides are drawn,\n"
18743 " otherwise no sides are drawn.\n"
18744 "\n"
18745 ""},
18746 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18747 "Magnitude colored plot surface with contour\n"
18748 "\n"
18749 "DESCRIPTION:\n"
18750 "\n"
18751 " Aside from dropping the\n"
18752 " side functionality this is a more powerful form of plot3d: the surface\n"
18753 " mesh can be colored accordingly to the current z value being plotted,\n"
18754 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18755 " drawn between the plotted function border and the base XY plane. The\n"
18756 " arguments are identical to those of plmeshc. The only difference\n"
18757 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18758 " the surface, while plot3dc only draws the surface as viewed from the\n"
18759 " top.\n"
18760 "\n"
18761 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18762 "\n"
18763 "\n"
18764 " This function is used in example 21.\n"
18765 "\n"
18766 "\n"
18767 "\n"
18768 "SYNOPSIS:\n"
18769 "\n"
18770 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18771 "\n"
18772 "ARGUMENTS:\n"
18773 "\n"
18774 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18775 " which the function is evaluated.\n"
18776 "\n"
18777 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18778 " which the function is evaluated.\n"
18779 "\n"
18780 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18781 " plot. Should have dimensions of\n"
18782 " nx by\n"
18783 " ny.\n"
18784 "\n"
18785 " nx (PLINT, input) : Number of x values at which function is\n"
18786 " evaluated.\n"
18787 "\n"
18788 " ny (PLINT, input) : Number of y values at which function is\n"
18789 " evaluated.\n"
18790 "\n"
18791 " opt (PLINT, input) : Determines the way in which the surface is\n"
18792 " represented. To specify more than one option just add the options,\n"
18793 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18794 " showing z as a function of x for each value of y[j] .\n"
18795 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18796 " for each value of x[i] .\n"
18797 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18798 " at which function is defined.\n"
18799 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18800 " the z value being plotted. The color is used from the current\n"
18801 " cmap1.\n"
18802 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18803 " using parameters\n"
18804 " nlevel and\n"
18805 " clevel.\n"
18806 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18807 " the borders of the plotted function.\n"
18808 "\n"
18809 "\n"
18810 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18811 " levels.\n"
18812 "\n"
18813 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18814 "\n"
18815 ""},
18816 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18817 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18818 "\n"
18819 "DESCRIPTION:\n"
18820 "\n"
18821 " When the implementation is completed this variant of plot3dc (see that\n"
18822 " function's documentation for more details) should be suitable for the\n"
18823 " case where the area of the x, y coordinate grid where z is defined can\n"
18824 " be non-rectangular. The implementation is incomplete so the last 4\n"
18825 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18826 " indexymax; are currently ignored and the functionality is otherwise\n"
18827 " identical to that of plot3dc.\n"
18828 "\n"
18829 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18830 " indexymin, indexymax)\n"
18831 "\n"
18832 "\n"
18833 " This function is not used in any example.\n"
18834 "\n"
18835 "\n"
18836 "\n"
18837 "SYNOPSIS:\n"
18838 "\n"
18839 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18840 "\n"
18841 "ARGUMENTS:\n"
18842 "\n"
18843 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18844 " which the function is evaluated.\n"
18845 "\n"
18846 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18847 " which the function is evaluated.\n"
18848 "\n"
18849 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18850 " plot. Should have dimensions of\n"
18851 " nx by\n"
18852 " ny.\n"
18853 "\n"
18854 " nx (PLINT, input) : Number of x values at which the function is\n"
18855 " evaluated.\n"
18856 "\n"
18857 " ny (PLINT, input) : Number of y values at which the function is\n"
18858 " evaluated.\n"
18859 "\n"
18860 " opt (PLINT, input) : Determines the way in which the surface is\n"
18861 " represented. To specify more than one option just add the options,\n"
18862 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18863 " showing z as a function of x for each value of y[j] .\n"
18864 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18865 " for each value of x[i] .\n"
18866 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18867 " at which function is defined.\n"
18868 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18869 " the z value being plotted. The color is used from the current\n"
18870 " cmap1.\n"
18871 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18872 " using parameters\n"
18873 " nlevel and\n"
18874 " clevel.\n"
18875 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18876 " the borders of the plotted function.\n"
18877 "\n"
18878 "\n"
18879 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18880 " levels.\n"
18881 "\n"
18882 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18883 "\n"
18884 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18885 " corresponds to the first x index where z is defined.\n"
18886 "\n"
18887 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18888 " which corresponds (by convention) to one more than the last x\n"
18889 " index value where z is defined.\n"
18890 "\n"
18891 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18892 " values which all must be ≥ 0. These values are the first y index\n"
18893 " where z is defined for a particular x index in the range from\n"
18894 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18895 " indexxmax.\n"
18896 "\n"
18897 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18898 " values which all must be ≤ ny. These values correspond (by\n"
18899 " convention) to one more than the last y index where z is defined\n"
18900 " for a particular x index in the range from indexxmin to indexxmax\n"
18901 " - 1. The dimension of indexymax is indexxmax.\n"
18902 "\n"
18903 ""},
18904 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18905 "Plot shaded 3-d surface plot\n"
18906 "\n"
18907 "DESCRIPTION:\n"
18908 "\n"
18909 " Plots a three-dimensional shaded surface plot within the environment\n"
18910 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18911 " z[\n"
18912 " nx][\n"
18913 " ny], the point z[i][j] being the value of the function at (\n"
18914 " x[i],\n"
18915 " y[j]). Note that the points in vectors x and y do not need to be\n"
18916 " equally spaced, but must be stored in ascending order. For further\n"
18917 " details see the PLplot documentation.\n"
18918 "\n"
18919 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18920 "\n"
18921 " This function is not used in any examples.\n"
18922 "\n"
18923 "\n"
18924 "\n"
18925 "SYNOPSIS:\n"
18926 "\n"
18927 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18928 "\n"
18929 "ARGUMENTS:\n"
18930 "\n"
18931 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18932 " which the function is evaluated.\n"
18933 "\n"
18934 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18935 " which the function is evaluated.\n"
18936 "\n"
18937 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18938 " plot. Should have dimensions of\n"
18939 " nx by\n"
18940 " ny.\n"
18941 "\n"
18942 " nx (PLINT, input) : Number of x values at which function is\n"
18943 " evaluated.\n"
18944 "\n"
18945 " ny (PLINT, input) : Number of y values at which function is\n"
18946 " evaluated.\n"
18947 "\n"
18948 " opt (PLINT, input) : Determines the way in which the surface is\n"
18949 " represented. To specify more than one option just add the options,\n"
18950 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18951 " connecting points at which function is defined.\n"
18952 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18953 " using parameters\n"
18954 " nlevel and\n"
18955 " clevel.\n"
18956 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18957 " using parameters\n"
18958 " nlevel and\n"
18959 " clevel.\n"
18960 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18961 " the borders of the plotted function.\n"
18962 " opt=MAG_COLOR : the surface is colored according to the value\n"
18963 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18964 " according to the intensity of the reflected light in the\n"
18965 " surface from a light source whose position is set using\n"
18966 " pllightsource.\n"
18967 "\n"
18968 "\n"
18969 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18970 " levels.\n"
18971 "\n"
18972 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18973 "\n"
18974 ""},
18975 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18976 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18977 "\n"
18978 "DESCRIPTION:\n"
18979 "\n"
18980 " This variant of plsurf3d (see that function's documentation for more\n"
18981 " details) should be suitable for the case where the area of the x, y\n"
18982 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18983 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18984 " indexymin, and indexymax.\n"
18985 "\n"
18986 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18987 " indexymax)\n"
18988 "\n"
18989 " This function is used in example 8.\n"
18990 "\n"
18991 "\n"
18992 "\n"
18993 "SYNOPSIS:\n"
18994 "\n"
18995 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18996 "\n"
18997 "ARGUMENTS:\n"
18998 "\n"
18999 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
19000 " which the function is evaluated.\n"
19001 "\n"
19002 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
19003 " which the function is evaluated.\n"
19004 "\n"
19005 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19006 " plot. Should have dimensions of\n"
19007 " nx by\n"
19008 " ny.\n"
19009 "\n"
19010 " nx (PLINT, input) : Number of x values at which function is\n"
19011 " evaluated.\n"
19012 "\n"
19013 " ny (PLINT, input) : Number of y values at which function is\n"
19014 " evaluated.\n"
19015 "\n"
19016 " opt (PLINT, input) : Determines the way in which the surface is\n"
19017 " represented. To specify more than one option just add the options,\n"
19018 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19019 " connecting points at which function is defined.\n"
19020 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19021 " using parameters\n"
19022 " nlevel and\n"
19023 " clevel.\n"
19024 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19025 " using parameters\n"
19026 " nlevel and\n"
19027 " clevel.\n"
19028 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19029 " the borders of the plotted function.\n"
19030 " opt=MAG_COLOR : the surface is colored according to the value\n"
19031 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19032 " according to the intensity of the reflected light in the\n"
19033 " surface from a light source whose position is set using\n"
19034 " pllightsource.\n"
19035 "\n"
19036 "\n"
19037 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19038 " levels.\n"
19039 "\n"
19040 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19041 "\n"
19042 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19043 " corresponds to the first x index where z is defined.\n"
19044 "\n"
19045 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19046 " which corresponds (by convention) to one more than the last x\n"
19047 " index value where z is defined.\n"
19048 "\n"
19049 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19050 " values which all must be ≥ 0. These values are the first y index\n"
19051 " where z is defined for a particular x index in the range from\n"
19052 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19053 " indexxmax.\n"
19054 "\n"
19055 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19056 " values which all must be ≤ ny. These values correspond (by\n"
19057 " convention) to one more than the last y index where z is defined\n"
19058 " for a particular x index in the range from indexxmin to indexxmax\n"
19059 " - 1. The dimension of indexymax is indexxmax.\n"
19060 "\n"
19061 ""},
19062 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19063 "Parse command-line arguments\n"
19064 "\n"
19065 "DESCRIPTION:\n"
19066 "\n"
19067 " Parse command-line arguments.\n"
19068 "\n"
19069 " plparseopts removes all recognized flags (decreasing argc\n"
19070 " accordingly), so that invalid input may be readily detected. It can\n"
19071 " also be used to process user command line flags. The user can merge\n"
19072 " an option table of type PLOptionTable into the internal option table\n"
19073 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19074 " the external table(s) be parsed by calling plClearOpts before\n"
19075 " plMergeOpts.\n"
19076 "\n"
19077 " The default action taken by plparseopts is as follows:\n"
19078 " Returns with an error if an unrecognized option or badly formed\n"
19079 " option-value pair are encountered.\n"
19080 " Returns immediately (return code 0) when the first non-option command\n"
19081 " line argument is found.\n"
19082 " Returns with the return code of the option handler, if one was called.\n"
19083 "\n"
19084 " Deletes command line arguments from argv list as they are found, and\n"
19085 " decrements argc accordingly.\n"
19086 " Does not show \"invisible\" options in usage or help messages.\n"
19087 " Assumes the program name is contained in argv[0].\n"
19088 "\n"
19089 " These behaviors may be controlled through the\n"
19090 " mode argument.\n"
19091 "\n"
19092 " Redacted form: General: plparseopts(argv, mode)\n"
19093 "\n"
19094 "\n"
19095 " This function is used in all of the examples.\n"
19096 "\n"
19097 "\n"
19098 "\n"
19099 "SYNOPSIS:\n"
19100 "\n"
19101 "PLINT plparseopts(p_argc, argv, mode)\n"
19102 "\n"
19103 "ARGUMENTS:\n"
19104 "\n"
19105 " p_argc (int *, input/output) : Number of arguments.\n"
19106 "\n"
19107 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19108 " strings containing *p_argc command-line arguments.\n"
19109 "\n"
19110 " mode (PLINT, input) : Parsing mode with the following\n"
19111 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19112 " and all error messages enabled, including program exit when an\n"
19113 " error occurs. Anything on the command line that isn't recognized\n"
19114 " as a valid option or option argument is flagged as an error.\n"
19115 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19116 " of errors.\n"
19117 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19118 " arguments.\n"
19119 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19120 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19121 " pointer to the program name.\n"
19122 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19123 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19124 " unrecognized arguments.\n"
19125 "\n"
19126 ""},
19127 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19128 "Set area line fill pattern\n"
19129 "\n"
19130 "DESCRIPTION:\n"
19131 "\n"
19132 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19133 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19134 " inclinations and spacings. The arguments to this routine are the\n"
19135 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19136 " elements) specifying the inclinations in tenths of a degree and the\n"
19137 " spacing in micrometers. (See also plpsty)\n"
19138 "\n"
19139 " Redacted form: General: plpat(inc, del)\n"
19140 "\n"
19141 "\n"
19142 " This function is used in example 15.\n"
19143 "\n"
19144 "\n"
19145 "\n"
19146 "SYNOPSIS:\n"
19147 "\n"
19148 "plpat(nlin, inc, del)\n"
19149 "\n"
19150 "ARGUMENTS:\n"
19151 "\n"
19152 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19153 " pattern, either 1 or 2.\n"
19154 "\n"
19155 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19156 " inclination in tenths of a degree. (Should be between -900 and\n"
19157 " 900).\n"
19158 "\n"
19159 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19160 " spacing in micrometers between the lines making up the pattern.\n"
19161 "\n"
19162 ""},
19163 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19164 "Draw a line between two points, accounting for coordinate transforms\n"
19165 "\n"
19166 "DESCRIPTION:\n"
19167 "\n"
19168 " Joins the point (\n"
19169 " x1,\n"
19170 " y1) to (\n"
19171 " x2,\n"
19172 " y2) . If a global coordinate transform is defined then the line is\n"
19173 " broken in to n segments to approximate the path. If no transform is\n"
19174 " defined then this simply acts like a call to pljoin.\n"
19175 "\n"
19176 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19177 "\n"
19178 " This function is used in example 22.\n"
19179 "\n"
19180 "\n"
19181 "\n"
19182 "SYNOPSIS:\n"
19183 "\n"
19184 "plpath(n, x1, y1, x2, y2)\n"
19185 "\n"
19186 "ARGUMENTS:\n"
19187 "\n"
19188 " n (PLINT, input) : number of points to use to approximate the path.\n"
19189 "\n"
19190 " x1 (PLFLT, input) : x coordinate of first point.\n"
19191 "\n"
19192 " y1 (PLFLT, input) : y coordinate of first point.\n"
19193 "\n"
19194 " x2 (PLFLT, input) : x coordinate of second point.\n"
19195 "\n"
19196 " y2 (PLFLT, input) : y coordinate of second point.\n"
19197 "\n"
19198 ""},
19199 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19200 "Plot a glyph at the specified points\n"
19201 "\n"
19202 "DESCRIPTION:\n"
19203 "\n"
19204 " Plot a glyph at the specified points. (This function is largely\n"
19205 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19206 " code=-1 means try to just draw a point. Right now it's just a move\n"
19207 " and a draw at the same place. Not ideal, since a sufficiently\n"
19208 " intelligent output device may optimize it away, or there may be faster\n"
19209 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19210 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19211 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19212 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19213 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19214 "\n"
19215 " Redacted form: plpoin(x, y, code)\n"
19216 "\n"
19217 " This function is used in examples 1, 6, 14, and 29.\n"
19218 "\n"
19219 "\n"
19220 "\n"
19221 "SYNOPSIS:\n"
19222 "\n"
19223 "plpoin(n, x, y, code)\n"
19224 "\n"
19225 "ARGUMENTS:\n"
19226 "\n"
19227 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19228 "\n"
19229 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19230 " points.\n"
19231 "\n"
19232 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19233 " points.\n"
19234 "\n"
19235 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19236 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19237 " each of the n points.\n"
19238 "\n"
19239 ""},
19240 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19241 "Plot a glyph at the specified 3D points\n"
19242 "\n"
19243 "DESCRIPTION:\n"
19244 "\n"
19245 " Plot a glyph at the specified 3D points. (This function is largely\n"
19246 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19247 " Set up the call to this function similar to what is done for plline3.\n"
19248 " code=-1 means try to just draw a point. Right now it's just a move\n"
19249 " and a draw at the same place. Not ideal, since a sufficiently\n"
19250 " intelligent output device may optimize it away, or there may be faster\n"
19251 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19252 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19253 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19254 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19255 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19256 "\n"
19257 " Redacted form: plpoin3(x, y, z, code)\n"
19258 "\n"
19259 " This function is not used in any example.\n"
19260 "\n"
19261 "\n"
19262 "\n"
19263 "SYNOPSIS:\n"
19264 "\n"
19265 "plpoin3(n, x, y, z, code)\n"
19266 "\n"
19267 "ARGUMENTS:\n"
19268 "\n"
19269 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19270 "\n"
19271 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19272 " points.\n"
19273 "\n"
19274 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19275 " points.\n"
19276 "\n"
19277 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19278 " points.\n"
19279 "\n"
19280 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19281 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19282 " each of the n points.\n"
19283 "\n"
19284 ""},
19285 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19286 "Draw a polygon in 3 space\n"
19287 "\n"
19288 "DESCRIPTION:\n"
19289 "\n"
19290 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19291 " like plline3, but differs from that function in that plpoly3 attempts\n"
19292 " to determine if the polygon is viewable depending on the order of the\n"
19293 " points within the vector and the value of ifcc. If the back of\n"
19294 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19295 " you want, then use plline3 instead.\n"
19296 "\n"
19297 " The points are assumed to be in a plane, and the directionality of the\n"
19298 " plane is determined from the first three points. Additional points do\n"
19299 " not have to lie on the plane defined by the first three, but if they\n"
19300 " do not, then the determination of visibility obviously can't be 100%\n"
19301 " accurate... So if you're 3 space polygons are too far from planar,\n"
19302 " consider breaking them into smaller polygons. 3 points define a plane\n"
19303 " :-).\n"
19304 "\n"
19305 " Bugs: If one of the first two segments is of zero length, or if they\n"
19306 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19307 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19308 " of this problem. (Search for 20.1).\n"
19309 "\n"
19310 " Redacted form: plpoly3(x, y, z, code)\n"
19311 "\n"
19312 " This function is used in example 18.\n"
19313 "\n"
19314 "\n"
19315 "\n"
19316 "SYNOPSIS:\n"
19317 "\n"
19318 "plpoly3(n, x, y, z, draw, ifcc)\n"
19319 "\n"
19320 "ARGUMENTS:\n"
19321 "\n"
19322 " n (PLINT, input) : Number of points defining line.\n"
19323 "\n"
19324 " x (PLFLT_VECTOR, input) : A vector containing\n"
19325 " n x coordinates of points.\n"
19326 "\n"
19327 " y (PLFLT_VECTOR, input) : A vector containing\n"
19328 " n y coordinates of points.\n"
19329 "\n"
19330 " z (PLFLT_VECTOR, input) : A vector containing\n"
19331 " n z coordinates of points.\n"
19332 "\n"
19333 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19334 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19335 " If draw[i] is true, then the polygon segment from index [i] to\n"
19336 " [i+1] is drawn, otherwise, not.\n"
19337 "\n"
19338 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19339 " polygon is determined by assuming the points are laid out in a\n"
19340 " counter-clockwise order. Otherwise, the directionality of the\n"
19341 " polygon is determined by assuming the points are laid out in a\n"
19342 " clockwise order.\n"
19343 "\n"
19344 ""},
19345 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19346 "Set precision in numeric labels\n"
19347 "\n"
19348 "DESCRIPTION:\n"
19349 "\n"
19350 " Sets the number of places after the decimal point in numeric labels.\n"
19351 "\n"
19352 " Redacted form: plprec(setp, prec)\n"
19353 "\n"
19354 " This function is used in example 29.\n"
19355 "\n"
19356 "\n"
19357 "\n"
19358 "SYNOPSIS:\n"
19359 "\n"
19360 "plprec(setp, prec)\n"
19361 "\n"
19362 "ARGUMENTS:\n"
19363 "\n"
19364 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19365 " automatically determines the number of places to use after the\n"
19366 " decimal point in numeric labels (like those used to label axes).\n"
19367 " If setp is 1 then prec sets the number of places.\n"
19368 "\n"
19369 " prec (PLINT, input) : The number of characters to draw after the\n"
19370 " decimal point in numeric labels.\n"
19371 "\n"
19372 ""},
19373 { "plpsty", _wrap_plpsty, METH_O, "\n"
19374 "Select area fill pattern\n"
19375 "\n"
19376 "DESCRIPTION:\n"
19377 "\n"
19378 " If\n"
19379 " patt is zero or less use either a hardware solid fill if the drivers\n"
19380 " have that capability (virtually all do) or fall back to a software\n"
19381 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19382 " 0 <\n"
19383 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19384 " to use (see plpat if you desire other patterns).\n"
19385 "\n"
19386 " Redacted form: plpsty(patt)\n"
19387 "\n"
19388 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19389 "\n"
19390 "\n"
19391 "\n"
19392 "SYNOPSIS:\n"
19393 "\n"
19394 "plpsty(patt)\n"
19395 "\n"
19396 "ARGUMENTS:\n"
19397 "\n"
19398 " patt (PLINT, input) : The desired pattern index. If\n"
19399 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19400 " above) used. For\n"
19401 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19402 " line fill capability itself (most deliberately do not so that line\n"
19403 " fill patterns look identical for those drivers), the patterns\n"
19404 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19405 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19406 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19407 " (8) lines at both 45 degrees and -45 degrees.\n"
19408 "\n"
19409 ""},
19410 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19411 "Write text inside the viewport\n"
19412 "\n"
19413 "DESCRIPTION:\n"
19414 "\n"
19415 " Writes text at a specified position and inclination within the\n"
19416 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19417 " point of a string lies along a line passing through the string at half\n"
19418 " the height of a capital letter. The position of the reference point\n"
19419 " along this line is determined by just, the reference point is placed\n"
19420 " at world coordinates (\n"
19421 " x,\n"
19422 " y) within the viewport. The inclination of the string is specified\n"
19423 " in terms of differences of world coordinates making it easy to write\n"
19424 " text parallel to a line in a graph.\n"
19425 "\n"
19426 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19427 "\n"
19428 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19429 "\n"
19430 "\n"
19431 "\n"
19432 "SYNOPSIS:\n"
19433 "\n"
19434 "plptex(x, y, dx, dy, just, text)\n"
19435 "\n"
19436 "ARGUMENTS:\n"
19437 "\n"
19438 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19439 "\n"
19440 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19441 "\n"
19442 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19443 " inclination of the string. The baseline of the string is parallel\n"
19444 " to a line joining (\n"
19445 " x,\n"
19446 " y) to (\n"
19447 " x+\n"
19448 " dx,\n"
19449 " y+\n"
19450 " dy) .\n"
19451 "\n"
19452 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19453 " inclination of the string.\n"
19454 "\n"
19455 " just (PLFLT, input) : Specifies the position of the string relative\n"
19456 " to its reference point. If just=0. , the reference point is at\n"
19457 " the left and if just=1. , it is at the right of the string. Other\n"
19458 " values of just give intermediate justifications.\n"
19459 "\n"
19460 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19461 " written out.\n"
19462 "\n"
19463 ""},
19464 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19465 "Write text inside the viewport of a 3D plot\n"
19466 "\n"
19467 "DESCRIPTION:\n"
19468 "\n"
19469 " Writes text at a specified position and inclination and with a\n"
19470 " specified shear within the viewport. Text is clipped at the viewport\n"
19471 " boundaries. The reference point of a string lies along a line passing\n"
19472 " through the string at half the height of a capital letter. The\n"
19473 " position of the reference point along this line is determined by just,\n"
19474 " and the reference point is placed at world coordinates (\n"
19475 " wx,\n"
19476 " wy,\n"
19477 " wz) within the viewport. The inclination and shear of the string is\n"
19478 " specified in terms of differences of world coordinates making it easy\n"
19479 " to write text parallel to a line in a graph.\n"
19480 "\n"
19481 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19482 "\n"
19483 " This function is used in example 28.\n"
19484 "\n"
19485 "\n"
19486 "\n"
19487 "SYNOPSIS:\n"
19488 "\n"
19489 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19490 "\n"
19491 "ARGUMENTS:\n"
19492 "\n"
19493 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19494 " string.\n"
19495 "\n"
19496 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19497 " string.\n"
19498 "\n"
19499 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19500 " string.\n"
19501 "\n"
19502 " dx (PLFLT, input) : Together with dy and\n"
19503 " dz , this specifies the inclination of the string. The baseline of\n"
19504 " the string is parallel to a line joining (\n"
19505 " x,\n"
19506 " y,\n"
19507 " z) to (\n"
19508 " x+\n"
19509 " dx,\n"
19510 " y+\n"
19511 " dy,\n"
19512 " z+\n"
19513 " dz) .\n"
19514 "\n"
19515 " dy (PLFLT, input) : Together with dx and\n"
19516 " dz, this specifies the inclination of the string.\n"
19517 "\n"
19518 " dz (PLFLT, input) : Together with dx and\n"
19519 " dy, this specifies the inclination of the string.\n"
19520 "\n"
19521 " sx (PLFLT, input) : Together with sy and\n"
19522 " sz , this specifies the shear of the string. The string is sheared so\n"
19523 " that the characters are vertically parallel to a line joining (\n"
19524 " x,\n"
19525 " y,\n"
19526 " z) to (\n"
19527 " x+\n"
19528 " sx,\n"
19529 " y+\n"
19530 " sy,\n"
19531 " z+\n"
19532 " sz) . If sx =\n"
19533 " sy =\n"
19534 " sz = 0.) then the text is not sheared.\n"
19535 "\n"
19536 " sy (PLFLT, input) : Together with sx and\n"
19537 " sz, this specifies shear of the string.\n"
19538 "\n"
19539 " sz (PLFLT, input) : Together with sx and\n"
19540 " sy, this specifies shear of the string.\n"
19541 "\n"
19542 " just (PLFLT, input) : Specifies the position of the string relative\n"
19543 " to its reference point. If just=0. , the reference point is at\n"
19544 " the left and if just=1. , it is at the right of the string. Other\n"
19545 " values of just give intermediate justifications.\n"
19546 "\n"
19547 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19548 " written out.\n"
19549 "\n"
19550 ""},
19551 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19552 "Random number generator returning a real random number in the range [0,1]\n"
19553 "\n"
19554 "DESCRIPTION:\n"
19555 "\n"
19556 " Random number generator returning a real random number in the range\n"
19557 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19558 " / compilers provide their own random number generator, and so this is\n"
19559 " provided purely for convenience and to give a consistent random number\n"
19560 " generator across all languages supported by PLplot. This is\n"
19561 " particularly useful for comparing results from the test suite of\n"
19562 " examples.\n"
19563 "\n"
19564 " Redacted form: plrandd()\n"
19565 "\n"
19566 " This function is used in examples 17 and 21.\n"
19567 "\n"
19568 "\n"
19569 "\n"
19570 "SYNOPSIS:\n"
19571 "\n"
19572 "plrandd()\n"
19573 "\n"
19574 ""},
19575 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19576 "Replays contents of plot buffer to current device/file\n"
19577 "\n"
19578 "DESCRIPTION:\n"
19579 "\n"
19580 " Replays contents of plot buffer to current device/file.\n"
19581 "\n"
19582 " Redacted form: plreplot()\n"
19583 "\n"
19584 " This function is used in example 1,20.\n"
19585 "\n"
19586 "\n"
19587 "\n"
19588 "SYNOPSIS:\n"
19589 "\n"
19590 "plreplot()\n"
19591 "\n"
19592 ""},
19593 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19594 "Convert RGB color to HLS\n"
19595 "\n"
19596 "DESCRIPTION:\n"
19597 "\n"
19598 " Convert RGB color coordinates to HLS\n"
19599 "\n"
19600 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19601 "\n"
19602 "\n"
19603 " This function is used in example 2.\n"
19604 "\n"
19605 "\n"
19606 "\n"
19607 "SYNOPSIS:\n"
19608 "\n"
19609 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19610 "\n"
19611 "ARGUMENTS:\n"
19612 "\n"
19613 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19614 "\n"
19615 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19616 "\n"
19617 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19618 "\n"
19619 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19620 " degrees (0.0-360.0) on the color cylinder.\n"
19621 "\n"
19622 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19623 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19624 " cylinder.\n"
19625 "\n"
19626 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19627 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19628 " cylinder.\n"
19629 "\n"
19630 ""},
19631 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19632 "Set character size\n"
19633 "\n"
19634 "DESCRIPTION:\n"
19635 "\n"
19636 " This sets up the size of all subsequent characters drawn. The actual\n"
19637 " height of a character is the product of the default character size and\n"
19638 " a scaling factor.\n"
19639 "\n"
19640 " Redacted form: plschr(def, scale)\n"
19641 "\n"
19642 " This function is used in examples 2, 13, 23, and 24.\n"
19643 "\n"
19644 "\n"
19645 "\n"
19646 "SYNOPSIS:\n"
19647 "\n"
19648 "plschr(def, scale)\n"
19649 "\n"
19650 "ARGUMENTS:\n"
19651 "\n"
19652 " def (PLFLT, input) : The default height of a character in\n"
19653 " millimeters, should be set to zero if the default height is to\n"
19654 " remain unchanged. For rasterized drivers the dx and dy values\n"
19655 " specified in plspage are used to convert from mm to pixels (note\n"
19656 " the different unit systems used). This dpi aware scaling is not\n"
19657 " implemented for all drivers yet.\n"
19658 "\n"
19659 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19660 " actual character height.\n"
19661 "\n"
19662 ""},
19663 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19664 "Set cmap0 colors by 8-bit RGB values\n"
19665 "\n"
19666 "DESCRIPTION:\n"
19667 "\n"
19668 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19669 " documentation). This sets the entire color map -- only as many colors\n"
19670 " as specified will be allocated.\n"
19671 "\n"
19672 " Redacted form: plscmap0(r, g, b)\n"
19673 "\n"
19674 " This function is used in examples 2 and 24.\n"
19675 "\n"
19676 "\n"
19677 "\n"
19678 "SYNOPSIS:\n"
19679 "\n"
19680 "plscmap0(r, g, b, ncol0)\n"
19681 "\n"
19682 "ARGUMENTS:\n"
19683 "\n"
19684 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19685 " integers (0-255) representing the degree of red in the color.\n"
19686 "\n"
19687 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19688 " integers (0-255) representing the degree of green in the color.\n"
19689 "\n"
19690 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19691 " integers (0-255) representing the degree of blue in the color.\n"
19692 "\n"
19693 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19694 "\n"
19695 ""},
19696 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19697 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19698 "\n"
19699 "DESCRIPTION:\n"
19700 "\n"
19701 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19702 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19703 " only as many colors as specified will be allocated.\n"
19704 "\n"
19705 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19706 "\n"
19707 " This function is used in examples 30.\n"
19708 "\n"
19709 "\n"
19710 "\n"
19711 "SYNOPSIS:\n"
19712 "\n"
19713 "plscmap0a(r, g, b, alpha, ncol0)\n"
19714 "\n"
19715 "ARGUMENTS:\n"
19716 "\n"
19717 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19718 " integers (0-255) representing the degree of red in the color.\n"
19719 "\n"
19720 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19721 " integers (0-255) representing the degree of green in the color.\n"
19722 "\n"
19723 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19724 " integers (0-255) representing the degree of blue in the color.\n"
19725 "\n"
19726 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19727 " representing the alpha transparency of the color.\n"
19728 "\n"
19729 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19730 " vectors.\n"
19731 "\n"
19732 ""},
19733 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19734 "Set number of colors in cmap0\n"
19735 "\n"
19736 "DESCRIPTION:\n"
19737 "\n"
19738 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19739 " (or reallocate) cmap0, and fill with default values for those colors\n"
19740 " not previously allocated. The first 16 default colors are given in\n"
19741 " the plcol0 documentation. For larger indices the default color is\n"
19742 " red.\n"
19743 "\n"
19744 " The drivers are not guaranteed to support more than 16 colors.\n"
19745 "\n"
19746 " Redacted form: plscmap0n(ncol0)\n"
19747 "\n"
19748 " This function is used in examples 15, 16, and 24.\n"
19749 "\n"
19750 "\n"
19751 "\n"
19752 "SYNOPSIS:\n"
19753 "\n"
19754 "plscmap0n(ncol0)\n"
19755 "\n"
19756 "ARGUMENTS:\n"
19757 "\n"
19758 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19759 " the cmap0 palette. If this number is zero or less, then the value\n"
19760 " from the previous call to plscmap0n is used and if there is no\n"
19761 " previous call, then a default value is used.\n"
19762 "\n"
19763 ""},
19764 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19765 "Set opaque RGB cmap1 colors values\n"
19766 "\n"
19767 "DESCRIPTION:\n"
19768 "\n"
19769 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19770 " vector values. This function also sets the number of cmap1 colors.\n"
19771 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19772 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19773 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19774 " to\n"
19775 " ncol1-1. So in order for this continuous color model to work\n"
19776 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19777 " that these RGB vectors are continuous functions of their integer\n"
19778 " indices.\n"
19779 "\n"
19780 " Redacted form: plscmap1(r, g, b)\n"
19781 "\n"
19782 " This function is used in example 31.\n"
19783 "\n"
19784 "\n"
19785 "\n"
19786 "SYNOPSIS:\n"
19787 "\n"
19788 "plscmap1(r, g, b, ncol1)\n"
19789 "\n"
19790 "ARGUMENTS:\n"
19791 "\n"
19792 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19793 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19794 " color as a continuous function of the integer index of the vector.\n"
19795 "\n"
19796 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19797 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19798 " color as a continuous function of the integer index of the vector.\n"
19799 "\n"
19800 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19801 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19802 " color as a continuous function of the integer index of the vector.\n"
19803 "\n"
19804 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19805 "\n"
19806 ""},
19807 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19808 "Set semitransparent cmap1 RGBA colors.\n"
19809 "\n"
19810 "DESCRIPTION:\n"
19811 "\n"
19812 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19813 " RGBA vector values. This function also sets the number of cmap1\n"
19814 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19815 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19816 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19817 " vectors in the range from 0 to\n"
19818 " ncol1-1. So in order for this continuous color model to work\n"
19819 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19820 " that these RGBA vectors are continuous functions of their integer\n"
19821 " indices.\n"
19822 "\n"
19823 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19824 "\n"
19825 " This function is used in example 31.\n"
19826 "\n"
19827 "\n"
19828 "\n"
19829 "SYNOPSIS:\n"
19830 "\n"
19831 "plscmap1a(r, g, b, alpha, ncol1)\n"
19832 "\n"
19833 "ARGUMENTS:\n"
19834 "\n"
19835 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19836 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19837 " color as a continuous function of the integer index of the vector.\n"
19838 "\n"
19839 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19840 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19841 " color as a continuous function of the integer index of the vector.\n"
19842 "\n"
19843 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19844 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19845 " color as a continuous function of the integer index of the vector.\n"
19846 "\n"
19847 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19848 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19849 " completely transparent and 1.0 corresponds to completely opaque)\n"
19850 " the alpha transparency of the color as a continuous function of\n"
19851 " the integer index of the vector.\n"
19852 "\n"
19853 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19854 " vectors.\n"
19855 "\n"
19856 ""},
19857 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19858 "Set cmap1 colors using a piece-wise linear relationship\n"
19859 "\n"
19860 "DESCRIPTION:\n"
19861 "\n"
19862 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19863 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19864 " (see the PLplot documentation). May be called at any time.\n"
19865 "\n"
19866 " The idea here is to specify a number of control points that define the\n"
19867 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19868 " these points, linear interpolation is used which gives a smooth\n"
19869 " variation of color with intensity index. Any number of control points\n"
19870 " may be specified, located at arbitrary positions, although typically 2\n"
19871 " - 4 are enough. Another way of stating this is that we are traversing\n"
19872 " a given number of lines through HLS or RGB space as we move through\n"
19873 " cmap1 intensity indices. The control points at the minimum and\n"
19874 " maximum position (0 and 1) must always be specified. By adding more\n"
19875 " control points you can get more variation. One good technique for\n"
19876 " plotting functions that vary about some expected average is to use an\n"
19877 " additional 2 control points in the center (position ~= 0.5) that are\n"
19878 " the same lightness as the background (typically white for paper\n"
19879 " output, black for crt), and same hue as the boundary control points.\n"
19880 " This allows the highs and lows to be very easily distinguished.\n"
19881 "\n"
19882 " Each control point must specify the cmap1 intensity index and the\n"
19883 " associated three coordinates in HLS or RGB space. The first point\n"
19884 " must correspond to position = 0, and the last to position = 1.\n"
19885 "\n"
19886 " If RGB colors are provided then the interpolation takes place in RGB\n"
19887 " space and is trivial. However if HLS colors are provided then, because\n"
19888 " of the circular nature of the color wheel for the hue coordinate, the\n"
19889 " interpolation could be performed in either direction around the color\n"
19890 " wheel. The default behaviour is for the hue to be linearly\n"
19891 " interpolated ignoring this circular property of hue. So for example,\n"
19892 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19893 " green and cyan. If instead you wish to interpolate the other way\n"
19894 " around the color wheel you have two options. You may provide hues\n"
19895 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19896 " for red the interpolation will proceed via magenta. Alternatively you\n"
19897 " can utilise the alt_hue_path variable to reverse the direction of\n"
19898 " interpolation if you need to provide hues within the [0-360) range.\n"
19899 "\n"
19900 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19901 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19902 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19903 " 480]falseblue-magenta-red-yellow-green[120\n"
19904 " 240]truegreen-yellow-red-magenta-blue[240\n"
19905 " 120]trueblue-magenta-red-yellow-green\n"
19906 "\n"
19907 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19908 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19909 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19910 "\n"
19911 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19912 " alt_hue_path)\n"
19913 "\n"
19914 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19915 "\n"
19916 "\n"
19917 "\n"
19918 "SYNOPSIS:\n"
19919 "\n"
19920 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19921 "\n"
19922 "ARGUMENTS:\n"
19923 "\n"
19924 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19925 "\n"
19926 " npts (PLINT, input) : number of control points\n"
19927 "\n"
19928 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19929 " intensity index (0.0-1.0) in ascending order for each control\n"
19930 " point.\n"
19931 "\n"
19932 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19933 " coordinate (H or R) for each control point.\n"
19934 "\n"
19935 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19936 " coordinate (L or G) for each control point.\n"
19937 "\n"
19938 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19939 " coordinate (S or B) for each control point.\n"
19940 "\n"
19941 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19942 " npts - 1 elements), each containing either true to use the reversed\n"
19943 " HLS interpolation or false to use the regular HLS interpolation.\n"
19944 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19945 " i and i + 1 control points). This parameter is not used for RGB\n"
19946 " colors (\n"
19947 " itype = true).\n"
19948 "\n"
19949 ""},
19950 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19951 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19952 "\n"
19953 "DESCRIPTION:\n"
19954 "\n"
19955 " This is a variant of plscmap1l that supports alpha channel\n"
19956 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19957 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19958 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19959 " transparency value (0.0-1.0). It may be called at any time.\n"
19960 "\n"
19961 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19962 " alpha, alt_hue_path)\n"
19963 "\n"
19964 " This function is used in example 30.\n"
19965 "\n"
19966 "\n"
19967 "\n"
19968 "SYNOPSIS:\n"
19969 "\n"
19970 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19971 "\n"
19972 "ARGUMENTS:\n"
19973 "\n"
19974 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19975 "\n"
19976 " npts (PLINT, input) : number of control points.\n"
19977 "\n"
19978 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19979 " intensity index (0.0-1.0) in ascending order for each control\n"
19980 " point.\n"
19981 "\n"
19982 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19983 " coordinate (H or R) for each control point.\n"
19984 "\n"
19985 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19986 " coordinate (L or G) for each control point.\n"
19987 "\n"
19988 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19989 " coordinate (S or B) for each control point.\n"
19990 "\n"
19991 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19992 " transparency value (0.0-1.0) for each control point.\n"
19993 "\n"
19994 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19995 " npts - 1 elements) containing the alternative interpolation method\n"
19996 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19997 " refers to the interpolation interval between the i and i + 1\n"
19998 " control points).\n"
19999 "\n"
20000 ""},
20001 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
20002 "Set number of colors in cmap1\n"
20003 "\n"
20004 "DESCRIPTION:\n"
20005 "\n"
20006 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
20007 " values if this is the first allocation (see the PLplot documentation).\n"
20008 "\n"
20009 " Redacted form: plscmap1n(ncol1)\n"
20010 "\n"
20011 " This function is used in examples 8, 11, 20, and 21.\n"
20012 "\n"
20013 "\n"
20014 "\n"
20015 "SYNOPSIS:\n"
20016 "\n"
20017 "plscmap1n(ncol1)\n"
20018 "\n"
20019 "ARGUMENTS:\n"
20020 "\n"
20021 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20022 " the cmap1 palette. If this number is zero or less, then the value\n"
20023 " from the previous call to plscmap1n is used and if there is no\n"
20024 " previous call, then a default value is used.\n"
20025 "\n"
20026 ""},
20027 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
20028 "Set the cmap1 argument range for continuous color plots\n"
20029 "\n"
20030 "DESCRIPTION:\n"
20031 "\n"
20032 " Set the cmap1 argument range for continuous color plots that\n"
20033 " corresponds to the range of data values. The maximum range\n"
20034 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20035 " the cmap1 argument range that is specified with this routine, the\n"
20036 " smaller the subset of the cmap1 color palette that is used to\n"
20037 " represent the continuous data being plotted. If\n"
20038 " min_color is greater than\n"
20039 " max_color or\n"
20040 " max_color is greater than 1.0 or\n"
20041 " min_color is less than 0.0 then no change is made to the cmap1\n"
20042 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20043 "\n"
20044 " Redacted form: plscmap1_range(min_color, max_color)\n"
20045 "\n"
20046 " This function is currently used in example 33.\n"
20047 "\n"
20048 "\n"
20049 "\n"
20050 "SYNOPSIS:\n"
20051 "\n"
20052 "plscmap1_range(min_color, max_color)\n"
20053 "\n"
20054 "ARGUMENTS:\n"
20055 "\n"
20056 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20057 " than 0.0, then 0.0 is used instead.\n"
20058 "\n"
20059 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20060 " than 1.0, then 1.0 is used instead.\n"
20061 "\n"
20062 ""},
20063 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20064 "Get the cmap1 argument range for continuous color plots\n"
20065 "\n"
20066 "DESCRIPTION:\n"
20067 "\n"
20068 " Get the cmap1 argument range for continuous color plots. (Use\n"
20069 " plscmap1_range to set the cmap1 argument range.)\n"
20070 "\n"
20071 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20072 "\n"
20073 " This function is currently not used in any example.\n"
20074 "\n"
20075 "\n"
20076 "\n"
20077 "SYNOPSIS:\n"
20078 "\n"
20079 "plgcmap1_range(min_color, max_color)\n"
20080 "\n"
20081 "ARGUMENTS:\n"
20082 "\n"
20083 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20084 " minimum cmap1 argument.\n"
20085 "\n"
20086 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20087 " maximum cmap1 argument.\n"
20088 "\n"
20089 ""},
20090 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20091 "Set 8-bit RGB values for given cmap0 color index\n"
20092 "\n"
20093 "DESCRIPTION:\n"
20094 "\n"
20095 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20096 " index. Overwrites the previous color value for the given index and,\n"
20097 " thus, does not result in any additional allocation of space for\n"
20098 " colors.\n"
20099 "\n"
20100 " Redacted form: plscol0(icol0, r, g, b)\n"
20101 "\n"
20102 " This function is used in any example 31.\n"
20103 "\n"
20104 "\n"
20105 "\n"
20106 "SYNOPSIS:\n"
20107 "\n"
20108 "plscol0(icol0, r, g, b)\n"
20109 "\n"
20110 "ARGUMENTS:\n"
20111 "\n"
20112 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20113 " number of colors (which is set by default, by plscmap0n, or even\n"
20114 " by plscmap0).\n"
20115 "\n"
20116 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20117 " degree of red in the color.\n"
20118 "\n"
20119 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20120 " degree of green in the color.\n"
20121 "\n"
20122 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20123 " degree of blue in the color.\n"
20124 "\n"
20125 ""},
20126 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20127 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20128 "\n"
20129 "DESCRIPTION:\n"
20130 "\n"
20131 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20132 " (see the PLplot documentation) index. Overwrites the previous color\n"
20133 " value for the given index and, thus, does not result in any additional\n"
20134 " allocation of space for colors.\n"
20135 "\n"
20136 " This function is used in example 30.\n"
20137 "\n"
20138 "\n"
20139 "\n"
20140 "SYNOPSIS:\n"
20141 "\n"
20142 "plscol0a(icol0, r, g, b, alpha)\n"
20143 "\n"
20144 "ARGUMENTS:\n"
20145 "\n"
20146 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20147 " number of colors (which is set by default, by plscmap0n, or even\n"
20148 " by plscmap0).\n"
20149 "\n"
20150 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20151 " degree of red in the color.\n"
20152 "\n"
20153 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20154 " degree of green in the color.\n"
20155 "\n"
20156 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20157 " degree of blue in the color.\n"
20158 "\n"
20159 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20160 " (0.0-1.0).\n"
20161 "\n"
20162 ""},
20163 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20164 "Set the background color by 8-bit RGB value\n"
20165 "\n"
20166 "DESCRIPTION:\n"
20167 "\n"
20168 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20169 " the PLplot documentation).\n"
20170 "\n"
20171 " Redacted form: plscolbg(r, g, b)\n"
20172 "\n"
20173 " This function is used in examples 15 and 31.\n"
20174 "\n"
20175 "\n"
20176 "\n"
20177 "SYNOPSIS:\n"
20178 "\n"
20179 "plscolbg(r, g, b)\n"
20180 "\n"
20181 "ARGUMENTS:\n"
20182 "\n"
20183 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20184 " degree of red in the color.\n"
20185 "\n"
20186 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20187 " degree of green in the color.\n"
20188 "\n"
20189 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20190 " degree of blue in the color.\n"
20191 "\n"
20192 ""},
20193 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20194 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20195 "\n"
20196 "DESCRIPTION:\n"
20197 "\n"
20198 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20199 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20200 "\n"
20201 " This function is used in example 31.\n"
20202 "\n"
20203 "\n"
20204 "\n"
20205 "SYNOPSIS:\n"
20206 "\n"
20207 "plscolbga(r, g, b, alpha)\n"
20208 "\n"
20209 "ARGUMENTS:\n"
20210 "\n"
20211 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20212 " degree of red in the color.\n"
20213 "\n"
20214 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20215 " degree of green in the color.\n"
20216 "\n"
20217 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20218 " degree of blue in the color.\n"
20219 "\n"
20220 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20221 " (0.0-1.0).\n"
20222 "\n"
20223 ""},
20224 { "plscolor", _wrap_plscolor, METH_O, "\n"
20225 "Used to globally turn color output on/off\n"
20226 "\n"
20227 "DESCRIPTION:\n"
20228 "\n"
20229 " Used to globally turn color output on/off for those drivers/devices\n"
20230 " that support it.\n"
20231 "\n"
20232 " Redacted form: plscolor(color)\n"
20233 "\n"
20234 " This function is used in example 31.\n"
20235 "\n"
20236 "\n"
20237 "\n"
20238 "SYNOPSIS:\n"
20239 "\n"
20240 "plscolor(color)\n"
20241 "\n"
20242 "ARGUMENTS:\n"
20243 "\n"
20244 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20245 " turned off. If non-zero, color is turned on.\n"
20246 "\n"
20247 ""},
20248 { "plscompression", _wrap_plscompression, METH_O, "\n"
20249 "Set device-compression level\n"
20250 "\n"
20251 "DESCRIPTION:\n"
20252 "\n"
20253 " Set device-compression level. Only used for drivers that provide\n"
20254 " compression. This function, if used, should be invoked before a call\n"
20255 " to plinit.\n"
20256 "\n"
20257 " Redacted form: plscompression(compression)\n"
20258 "\n"
20259 " This function is used in example 31.\n"
20260 "\n"
20261 "\n"
20262 "\n"
20263 "SYNOPSIS:\n"
20264 "\n"
20265 "plscompression(compression)\n"
20266 "\n"
20267 "ARGUMENTS:\n"
20268 "\n"
20269 " compression (PLINT, input) : The desired compression level. This is\n"
20270 " a device-dependent value. Currently only the jpeg and png devices\n"
20271 " use these values. For jpeg value is the jpeg quality which should\n"
20272 " normally be in the range 0-95. Higher values denote higher quality\n"
20273 " and hence larger image sizes. For png values are in the range -1\n"
20274 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20275 " A value of -1 denotes the default zlib compression level. Values\n"
20276 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20277 " compression level. Higher compression levels correspond to greater\n"
20278 " compression and small file sizes at the expense of more\n"
20279 " computation.\n"
20280 "\n"
20281 ""},
20282 { "plsdev", _wrap_plsdev, METH_O, "\n"
20283 "Set the device (keyword) name\n"
20284 "\n"
20285 "DESCRIPTION:\n"
20286 "\n"
20287 " Set the device (keyword) name.\n"
20288 "\n"
20289 " Redacted form: plsdev(devname)\n"
20290 "\n"
20291 " This function is used in examples 1, 14, and 20.\n"
20292 "\n"
20293 "\n"
20294 "\n"
20295 "SYNOPSIS:\n"
20296 "\n"
20297 "plsdev(devname)\n"
20298 "\n"
20299 "ARGUMENTS:\n"
20300 "\n"
20301 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20302 " containing the device name keyword of the required output device.\n"
20303 " If\n"
20304 " devname is NULL or if the first character of the string is a ``?'',\n"
20305 " the normal (prompted) start up is used.\n"
20306 "\n"
20307 ""},
20308 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20309 "Set parameters that define current device-space window\n"
20310 "\n"
20311 "DESCRIPTION:\n"
20312 "\n"
20313 " Set relative margin width, aspect ratio, and relative justification\n"
20314 " that define current device-space window. If you want to just use the\n"
20315 " previous value for any of these, just pass in the magic value\n"
20316 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20317 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20318 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20319 " to a device-specific value.\n"
20320 "\n"
20321 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20322 "\n"
20323 " This function is used in example 31.\n"
20324 "\n"
20325 "\n"
20326 "\n"
20327 "SYNOPSIS:\n"
20328 "\n"
20329 "plsdidev(mar, aspect, jx, jy)\n"
20330 "\n"
20331 "ARGUMENTS:\n"
20332 "\n"
20333 " mar (PLFLT, input) : Relative margin width.\n"
20334 "\n"
20335 " aspect (PLFLT, input) : Aspect ratio.\n"
20336 "\n"
20337 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20338 " the range -0.5 to 0.5.\n"
20339 "\n"
20340 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20341 " the range -0.5 to 0.5.\n"
20342 "\n"
20343 ""},
20344 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20345 "Set up transformation from metafile coordinates\n"
20346 "\n"
20347 "DESCRIPTION:\n"
20348 "\n"
20349 " Set up transformation from metafile coordinates. The size of the plot\n"
20350 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20351 " general-purpose facility just yet (not sure why the user would need\n"
20352 " it, for one).\n"
20353 "\n"
20354 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20355 " dimypmm)\n"
20356 "\n"
20357 " This function is not used in any examples.\n"
20358 "\n"
20359 "\n"
20360 "\n"
20361 "SYNOPSIS:\n"
20362 "\n"
20363 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20364 "\n"
20365 "ARGUMENTS:\n"
20366 "\n"
20367 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20368 "\n"
20369 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20370 "\n"
20371 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20372 "\n"
20373 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20374 "\n"
20375 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20376 "\n"
20377 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20378 "\n"
20379 ""},
20380 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20381 "Set plot orientation\n"
20382 "\n"
20383 "DESCRIPTION:\n"
20384 "\n"
20385 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20386 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20387 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20388 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20389 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20390 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20391 " not called the default value of rot is 0.\n"
20392 "\n"
20393 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20394 " probably want to change the aspect ratio to a value suitable for the\n"
20395 " plot orientation using a call to plsdidev or the command-line options\n"
20396 " -a or -freeaspect. For more documentation of those options see the\n"
20397 " PLplot documentation. Such command-line options can be set internally\n"
20398 " using plsetopt or set directly using the command line and parsed using\n"
20399 " a call to plparseopts.\n"
20400 "\n"
20401 " Redacted form: plsdiori(rot)\n"
20402 "\n"
20403 " This function is not used in any examples.\n"
20404 "\n"
20405 "\n"
20406 "\n"
20407 "SYNOPSIS:\n"
20408 "\n"
20409 "plsdiori(rot)\n"
20410 "\n"
20411 "ARGUMENTS:\n"
20412 "\n"
20413 " rot (PLFLT, input) : Plot orientation parameter.\n"
20414 "\n"
20415 ""},
20416 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20417 "Set parameters that define current plot-space window\n"
20418 "\n"
20419 "DESCRIPTION:\n"
20420 "\n"
20421 " Set relative minima and maxima that define the current plot-space\n"
20422 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20423 " xmax, and ymax are 0., 0., 1., and 1.\n"
20424 "\n"
20425 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20426 "\n"
20427 " This function is used in example 31.\n"
20428 "\n"
20429 "\n"
20430 "\n"
20431 "SYNOPSIS:\n"
20432 "\n"
20433 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20434 "\n"
20435 "ARGUMENTS:\n"
20436 "\n"
20437 " xmin (PLFLT, input) : Relative minimum in x.\n"
20438 "\n"
20439 " ymin (PLFLT, input) : Relative minimum in y.\n"
20440 "\n"
20441 " xmax (PLFLT, input) : Relative maximum in x.\n"
20442 "\n"
20443 " ymax (PLFLT, input) : Relative maximum in y.\n"
20444 "\n"
20445 ""},
20446 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20447 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20448 "\n"
20449 "DESCRIPTION:\n"
20450 "\n"
20451 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20452 " the current plot-space window. This function has the same effect as\n"
20453 " plsdiplt if that function has not been previously called. Otherwise,\n"
20454 " this function implements zoom mode using the transformation min_used =\n"
20455 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20456 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20457 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20458 "\n"
20459 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20460 "\n"
20461 " This function is used in example 31.\n"
20462 "\n"
20463 "\n"
20464 "\n"
20465 "SYNOPSIS:\n"
20466 "\n"
20467 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20468 "\n"
20469 "ARGUMENTS:\n"
20470 "\n"
20471 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20472 "\n"
20473 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20474 "\n"
20475 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20476 "\n"
20477 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20478 "\n"
20479 ""},
20480 { "plseed", _wrap_plseed, METH_O, "\n"
20481 "Set seed for internal random number generator.\n"
20482 "\n"
20483 "DESCRIPTION:\n"
20484 "\n"
20485 " Set the seed for the internal random number generator. See plrandd for\n"
20486 " further details.\n"
20487 "\n"
20488 " Redacted form: plseed(seed)\n"
20489 "\n"
20490 " This function is used in example 21.\n"
20491 "\n"
20492 "\n"
20493 "\n"
20494 "SYNOPSIS:\n"
20495 "\n"
20496 "plseed(seed)\n"
20497 "\n"
20498 "ARGUMENTS:\n"
20499 "\n"
20500 " seed (unsigned int, input) : Seed for random number generator.\n"
20501 "\n"
20502 ""},
20503 { "plsesc", _wrap_plsesc, METH_O, "\n"
20504 "Set the escape character for text strings\n"
20505 "\n"
20506 "DESCRIPTION:\n"
20507 "\n"
20508 " Set the escape character for text strings. From C (in contrast to\n"
20509 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20510 " characters are allowed to prevent the user from shooting himself in\n"
20511 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20512 " use of backslash as a character escape). Here are the allowed escape\n"
20513 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20514 " #, ASCII 35\n"
20515 " $, ASCII 36\n"
20516 " %, ASCII 37\n"
20517 " &, ASCII 38\n"
20518 " *, ASCII 42\n"
20519 " @, ASCII 64\n"
20520 " ^, ASCII 94\n"
20521 " ~, ASCII 126\n"
20522 "\n"
20523 "\n"
20524 " Redacted form: General: plsesc(esc)\n"
20525 "\n"
20526 "\n"
20527 " This function is used in example 29.\n"
20528 "\n"
20529 "\n"
20530 "\n"
20531 "SYNOPSIS:\n"
20532 "\n"
20533 "plsesc(esc)\n"
20534 "\n"
20535 "ARGUMENTS:\n"
20536 "\n"
20537 " esc (char, input) : Escape character.\n"
20538 "\n"
20539 ""},
20540 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20541 "Set any command-line option\n"
20542 "\n"
20543 "DESCRIPTION:\n"
20544 "\n"
20545 " Set any command-line option internally from a program before it\n"
20546 " invokes plinit. opt is the name of the command-line option and optarg\n"
20547 " is the corresponding command-line option argument.\n"
20548 "\n"
20549 " This function returns 0 on success.\n"
20550 "\n"
20551 " Redacted form: plsetopt(opt, optarg)\n"
20552 "\n"
20553 " This function is used in example 14.\n"
20554 "\n"
20555 "\n"
20556 "\n"
20557 "SYNOPSIS:\n"
20558 "\n"
20559 "PLINT plsetopt(opt, optarg)\n"
20560 "\n"
20561 "ARGUMENTS:\n"
20562 "\n"
20563 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20564 " the command-line option.\n"
20565 "\n"
20566 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20567 " containing the argument of the command-line option.\n"
20568 "\n"
20569 ""},
20570 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20571 "Set family file parameters\n"
20572 "\n"
20573 "DESCRIPTION:\n"
20574 "\n"
20575 " Sets variables dealing with output file familying. Does nothing if\n"
20576 " familying not supported by the driver. This routine, if used, must be\n"
20577 " called before initializing PLplot. See the PLplot documentation for\n"
20578 " more information.\n"
20579 "\n"
20580 " Redacted form: plsfam(fam, num, bmax)\n"
20581 "\n"
20582 " This function is used in examples 14 and 31.\n"
20583 "\n"
20584 "\n"
20585 "\n"
20586 "SYNOPSIS:\n"
20587 "\n"
20588 "plsfam(fam, num, bmax)\n"
20589 "\n"
20590 "ARGUMENTS:\n"
20591 "\n"
20592 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20593 " is enabled.\n"
20594 "\n"
20595 " num (PLINT, input) : Current family file number.\n"
20596 "\n"
20597 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20598 " file.\n"
20599 "\n"
20600 ""},
20601 { "plsfci", _wrap_plsfci, METH_O, "\n"
20602 "Set FCI (font characterization integer)\n"
20603 "\n"
20604 "DESCRIPTION:\n"
20605 "\n"
20606 " Sets font characteristics to be used at the start of the next string\n"
20607 " using the FCI approach. See the PLplot documentation for more\n"
20608 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20609 " more user-friendly API for setting the font characterisitics.\n"
20610 "\n"
20611 " Redacted form: General: plsfci(fci)\n"
20612 "\n"
20613 "\n"
20614 " This function is used in example 23.\n"
20615 "\n"
20616 "\n"
20617 "\n"
20618 "SYNOPSIS:\n"
20619 "\n"
20620 "plsfci(fci)\n"
20621 "\n"
20622 "ARGUMENTS:\n"
20623 "\n"
20624 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20625 " of FCI.\n"
20626 "\n"
20627 ""},
20628 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20629 "Set output file name\n"
20630 "\n"
20631 "DESCRIPTION:\n"
20632 "\n"
20633 " Sets the current output file name, if applicable. If the file name\n"
20634 " has not been specified and is required by the driver, the user will be\n"
20635 " prompted for it. If using the X-windows output driver, this sets the\n"
20636 " display name. This routine, if used, must be called before\n"
20637 " initializing PLplot.\n"
20638 "\n"
20639 " Redacted form: plsfnam(fnam)\n"
20640 "\n"
20641 " This function is used in examples 1 and 20.\n"
20642 "\n"
20643 "\n"
20644 "\n"
20645 "SYNOPSIS:\n"
20646 "\n"
20647 "plsfnam(fnam)\n"
20648 "\n"
20649 "ARGUMENTS:\n"
20650 "\n"
20651 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20652 " the file name.\n"
20653 "\n"
20654 ""},
20655 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20656 "Set family, style and weight of the current font\n"
20657 "\n"
20658 "DESCRIPTION:\n"
20659 "\n"
20660 " Sets the current font. See the PLplot documentation for more\n"
20661 " information on font selection.\n"
20662 "\n"
20663 " Redacted form: plsfont(family, style, weight)\n"
20664 "\n"
20665 " This function is used in example 23.\n"
20666 "\n"
20667 "\n"
20668 "\n"
20669 "SYNOPSIS:\n"
20670 "\n"
20671 "plsfont(family, style, weight)\n"
20672 "\n"
20673 "ARGUMENTS:\n"
20674 "\n"
20675 " family (PLINT, input) : Font family to select for the current font.\n"
20676 " The available values are given by the PL_FCI_* constants in\n"
20677 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20678 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20679 " signifies that the font family should not be altered.\n"
20680 "\n"
20681 " style (PLINT, input) : Font style to select for the current font.\n"
20682 " The available values are given by the PL_FCI_* constants in\n"
20683 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20684 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20685 " should not be altered.\n"
20686 "\n"
20687 " weight (PLINT, input) : Font weight to select for the current font.\n"
20688 " The available values are given by the PL_FCI_* constants in\n"
20689 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20690 " negative value signifies that the font weight should not be\n"
20691 " altered.\n"
20692 "\n"
20693 ""},
20694 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20695 "Shade regions on the basis of value\n"
20696 "\n"
20697 "DESCRIPTION:\n"
20698 "\n"
20699 " Shade regions on the basis of value. This is the high-level routine\n"
20700 " for making continuous color shaded plots with cmap1 while plshade\n"
20701 " should be used to plot individual shaded regions using either cmap0 or\n"
20702 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20703 " our supported languages.\n"
20704 "\n"
20705 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20706 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20707 " pltr_data)\n"
20708 "\n"
20709 "\n"
20710 " This function is used in examples 16, 21, and 22.\n"
20711 "\n"
20712 "\n"
20713 "\n"
20714 "SYNOPSIS:\n"
20715 "\n"
20716 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20717 "\n"
20718 "ARGUMENTS:\n"
20719 "\n"
20720 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20721 " plot. Should have dimensions of\n"
20722 " nx by\n"
20723 " ny.\n"
20724 "\n"
20725 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20726 "\n"
20727 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20728 "\n"
20729 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20730 " the region that should be plotted in the shade plot. This\n"
20731 " function accepts x and y coordinates as input arguments and must\n"
20732 " return 1 if the point is to be included in the shade plot and 0\n"
20733 " otherwise. If you want to plot the entire shade plot (the usual\n"
20734 " case), this argument should be set to NULL.\n"
20735 "\n"
20736 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20737 " pltr below for how these arguments are used (only for the special case\n"
20738 " when the callback function\n"
20739 " pltr is not supplied).\n"
20740 "\n"
20741 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20742 " corresponding to the edges of each shaded region that will be\n"
20743 " plotted by this function. To work properly the levels should be\n"
20744 " monotonic.\n"
20745 "\n"
20746 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20747 " of shade edge values in clevel).\n"
20748 "\n"
20749 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20750 " pattern.\n"
20751 "\n"
20752 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20753 " contours defining edges of shaded regions. The pen color is only\n"
20754 " temporary set for the contour drawing. Set this value to zero or\n"
20755 " less if no shade edge contours are wanted.\n"
20756 "\n"
20757 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20758 " defining edges of shaded regions. This value may not be honored\n"
20759 " by all drivers. The pen width is only temporary set for the\n"
20760 " contour drawing. Set this value to zero or less if no shade edge\n"
20761 " contours are wanted.\n"
20762 "\n"
20763 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20764 " region. Use plfill for this purpose.\n"
20765 "\n"
20766 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20767 " map to rectangles after coordinate transformation with pltrl.\n"
20768 " Otherwise, set rectangular to false. If rectangular is set to\n"
20769 " true, plshade tries to save time by filling large rectangles.\n"
20770 " This optimization fails if the coordinate transformation distorts\n"
20771 " the shape of rectangles. For example a plot in polar coordinates\n"
20772 " has to have rectangular set to false.\n"
20773 "\n"
20774 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20775 " defines the transformation between the zero-based indices of the\n"
20776 " matrix a and world coordinates. If\n"
20777 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20778 " indices of a are mapped to the range\n"
20779 " xmin through\n"
20780 " xmax and the y indices of a are mapped to the range\n"
20781 " ymin through\n"
20782 " ymax.For the C case, transformation functions are provided in the\n"
20783 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20784 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20785 " matrices. In addition, C callback routines for the transformation\n"
20786 " can be supplied by the user such as the mypltr function in\n"
20787 " examples/c/x09c.c which provides a general linear transformation\n"
20788 " between index coordinates and world coordinates.For languages\n"
20789 " other than C you should consult the PLplot documentation for the\n"
20790 " details concerning how PLTRANSFORM_callback arguments are\n"
20791 " interfaced. However, in general, a particular pattern of\n"
20792 " callback-associated arguments such as a tr vector with 6 elements;\n"
20793 " xg and yg vectors; or xg and yg matrices are respectively\n"
20794 " interfaced to a linear-transformation routine similar to the above\n"
20795 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20796 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20797 " support native language callbacks for handling index to\n"
20798 " world-coordinate transformations. Examples of these various\n"
20799 " approaches are given in examples/<language>x09*,\n"
20800 " examples/<language>x16*, examples/<language>x20*,\n"
20801 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20802 " supported languages.\n"
20803 "\n"
20804 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20805 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20806 " externally supplied.\n"
20807 "\n"
20808 ""},
20809 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20810 "Shade individual region on the basis of value\n"
20811 "\n"
20812 "DESCRIPTION:\n"
20813 "\n"
20814 " Shade individual region on the basis of value. Use plshades if you\n"
20815 " want to shade a number of contiguous regions using continuous colors.\n"
20816 " In particular the edge contours are treated properly in plshades. If\n"
20817 " you attempt to do contiguous regions with plshade the contours at the\n"
20818 " edge of the shade are partially obliterated by subsequent plots of\n"
20819 " contiguous shaded regions.\n"
20820 "\n"
20821 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20822 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20823 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20824 "\n"
20825 "\n"
20826 " This function is used in example 15.\n"
20827 "\n"
20828 "\n"
20829 "\n"
20830 "SYNOPSIS:\n"
20831 "\n"
20832 "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"
20833 "\n"
20834 "ARGUMENTS:\n"
20835 "\n"
20836 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20837 " plot. Should have dimensions of\n"
20838 " nx by\n"
20839 " ny.\n"
20840 "\n"
20841 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20842 "\n"
20843 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20844 "\n"
20845 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20846 " the region that should be plotted in the shade plot. This\n"
20847 " function accepts x and y coordinates as input arguments and must\n"
20848 " return 1 if the point is to be included in the shade plot and 0\n"
20849 " otherwise. If you want to plot the entire shade plot (the usual\n"
20850 " case), this argument should be set to NULL.\n"
20851 "\n"
20852 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20853 " pltr below for how these arguments are used (only for the special case\n"
20854 " when the callback function\n"
20855 " pltr is not supplied).\n"
20856 "\n"
20857 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20858 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20859 "\n"
20860 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20861 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20862 "\n"
20863 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20864 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20865 " then sh_color is interpreted as a cmap1 argument in the range\n"
20866 " (0.0-1.0).\n"
20867 "\n"
20868 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20869 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20870 "\n"
20871 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20872 "\n"
20873 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20874 " boundary of shaded region. The min values are used for the\n"
20875 " shade_min boundary, and the max values are used on the shade_max\n"
20876 " boundary. Set color and width to zero for no plotted boundaries.\n"
20877 "\n"
20878 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20879 " boundary of shaded region. The min values are used for the\n"
20880 " shade_min boundary, and the max values are used on the shade_max\n"
20881 " boundary. Set color and width to zero for no plotted boundaries.\n"
20882 "\n"
20883 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20884 " boundary of shaded region. The min values are used for the\n"
20885 " shade_min boundary, and the max values are used on the shade_max\n"
20886 " boundary. Set color and width to zero for no plotted boundaries.\n"
20887 "\n"
20888 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20889 " boundary of shaded region. The min values are used for the\n"
20890 " shade_min boundary, and the max values are used on the shade_max\n"
20891 " boundary. Set color and width to zero for no plotted boundaries.\n"
20892 "\n"
20893 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20894 " Use plfill. Future version of PLplot may have other fill\n"
20895 " routines.\n"
20896 "\n"
20897 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20898 " map to rectangles after coordinate transformation with pltrl.\n"
20899 " Otherwise, set rectangular to false. If rectangular is set to\n"
20900 " true, plshade tries to save time by filling large rectangles.\n"
20901 " This optimization fails if the coordinate transformation distorts\n"
20902 " the shape of rectangles. For example a plot in polar coordinates\n"
20903 " has to have rectangular set to false.\n"
20904 "\n"
20905 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20906 " defines the transformation between the zero-based indices of the\n"
20907 " matrix a and world coordinates. If\n"
20908 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20909 " indices of a are mapped to the range\n"
20910 " xmin through\n"
20911 " xmax and the y indices of a are mapped to the range\n"
20912 " ymin through\n"
20913 " ymax.For the C case, transformation functions are provided in the\n"
20914 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20915 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20916 " matrices. In addition, C callback routines for the transformation\n"
20917 " can be supplied by the user such as the mypltr function in\n"
20918 " examples/c/x09c.c which provides a general linear transformation\n"
20919 " between index coordinates and world coordinates.For languages\n"
20920 " other than C you should consult the PLplot documentation for the\n"
20921 " details concerning how PLTRANSFORM_callback arguments are\n"
20922 " interfaced. However, in general, a particular pattern of\n"
20923 " callback-associated arguments such as a tr vector with 6 elements;\n"
20924 " xg and yg vectors; or xg and yg matrices are respectively\n"
20925 " interfaced to a linear-transformation routine similar to the above\n"
20926 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20927 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20928 " support native language callbacks for handling index to\n"
20929 " world-coordinate transformations. Examples of these various\n"
20930 " approaches are given in examples/<language>x09*,\n"
20931 " examples/<language>x16*, examples/<language>x20*,\n"
20932 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20933 " supported languages.\n"
20934 "\n"
20935 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20936 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20937 " externally supplied.\n"
20938 "\n"
20939 ""},
20940 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20941 "Assign a function to use for generating custom axis labels\n"
20942 "\n"
20943 "DESCRIPTION:\n"
20944 "\n"
20945 " This function allows a user to provide their own function to provide\n"
20946 " axis label text. The user function is given the numeric value for a\n"
20947 " point on an axis and returns a string label to correspond with that\n"
20948 " value. Custom axis labels can be enabled by passing appropriate\n"
20949 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20950 "\n"
20951 " This function is used in example 19.\n"
20952 "\n"
20953 "\n"
20954 "\n"
20955 "SYNOPSIS:\n"
20956 "\n"
20957 "plslabelfunc(label_func, label_data)\n"
20958 "\n"
20959 "ARGUMENTS:\n"
20960 "\n"
20961 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20962 " label function. In order to reset to the default labelling, set\n"
20963 " this to NULL. The labelling function parameters are, in order:\n"
20964 " axis: This indicates which axis a label is being requested for.\n"
20965 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20966 "\n"
20967 " value: This is the value along the axis which is being labelled.\n"
20968 "\n"
20969 " label_text: The string representation of the label value.\n"
20970 "\n"
20971 " length: The maximum length in characters allowed for label_text.\n"
20972 "\n"
20973 "\n"
20974 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20975 " data to the label_func function.\n"
20976 "\n"
20977 ""},
20978 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20979 "Set length of major ticks\n"
20980 "\n"
20981 "DESCRIPTION:\n"
20982 "\n"
20983 " This sets up the length of the major ticks. The actual length is the\n"
20984 " product of the default length and a scaling factor as for character\n"
20985 " height.\n"
20986 "\n"
20987 " Redacted form: plsmaj(def, scale)\n"
20988 "\n"
20989 " This function is used in example 29.\n"
20990 "\n"
20991 "\n"
20992 "\n"
20993 "SYNOPSIS:\n"
20994 "\n"
20995 "plsmaj(def, scale)\n"
20996 "\n"
20997 "ARGUMENTS:\n"
20998 "\n"
20999 " def (PLFLT, input) : The default length of a major tick in\n"
21000 " millimeters, should be set to zero if the default length is to\n"
21001 " remain unchanged.\n"
21002 "\n"
21003 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21004 " actual tick length.\n"
21005 "\n"
21006 ""},
21007 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
21008 "Set the memory area to be plotted (RGB)\n"
21009 "\n"
21010 "DESCRIPTION:\n"
21011 "\n"
21012 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
21013 " the dev member of the stream structure. Also set the number of pixels\n"
21014 " in the memory passed in\n"
21015 " plotmem, which is a block of memory\n"
21016 " maxy by\n"
21017 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
21018 "\n"
21019 " This memory will have to be freed by the user!\n"
21020 "\n"
21021 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21022 "\n"
21023 " This function is not used in any examples.\n"
21024 "\n"
21025 "\n"
21026 "\n"
21027 "SYNOPSIS:\n"
21028 "\n"
21029 "plsmem(maxx, maxy, plotmem)\n"
21030 "\n"
21031 "ARGUMENTS:\n"
21032 "\n"
21033 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21034 "\n"
21035 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21036 "\n"
21037 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21038 " user-supplied writeable memory area.\n"
21039 "\n"
21040 ""},
21041 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21042 "Set the memory area to be plotted (RGBA)\n"
21043 "\n"
21044 "DESCRIPTION:\n"
21045 "\n"
21046 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21047 " dev member of the stream structure. Also set the number of pixels in\n"
21048 " the memory passed in\n"
21049 " plotmem, which is a block of memory\n"
21050 " maxy by\n"
21051 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21052 "\n"
21053 " This memory will have to be freed by the user!\n"
21054 "\n"
21055 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21056 "\n"
21057 " This function is not used in any examples.\n"
21058 "\n"
21059 "\n"
21060 "\n"
21061 "SYNOPSIS:\n"
21062 "\n"
21063 "plsmema(maxx, maxy, plotmem)\n"
21064 "\n"
21065 "ARGUMENTS:\n"
21066 "\n"
21067 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21068 "\n"
21069 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21070 "\n"
21071 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21072 " user-supplied writeable memory area.\n"
21073 "\n"
21074 ""},
21075 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21076 "Set length of minor ticks\n"
21077 "\n"
21078 "DESCRIPTION:\n"
21079 "\n"
21080 " This sets up the length of the minor ticks and the length of the\n"
21081 " terminals on error bars. The actual length is the product of the\n"
21082 " default length and a scaling factor as for character height.\n"
21083 "\n"
21084 " Redacted form: plsmin(def, scale)\n"
21085 "\n"
21086 " This function is used in example 29.\n"
21087 "\n"
21088 "\n"
21089 "\n"
21090 "SYNOPSIS:\n"
21091 "\n"
21092 "plsmin(def, scale)\n"
21093 "\n"
21094 "ARGUMENTS:\n"
21095 "\n"
21096 " def (PLFLT, input) : The default length of a minor tick in\n"
21097 " millimeters, should be set to zero if the default length is to\n"
21098 " remain unchanged.\n"
21099 "\n"
21100 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21101 " actual tick length.\n"
21102 "\n"
21103 ""},
21104 { "plsori", _wrap_plsori, METH_O, "\n"
21105 "Set orientation\n"
21106 "\n"
21107 "DESCRIPTION:\n"
21108 "\n"
21109 " Set integer plot orientation parameter. This function is identical to\n"
21110 " plsdiori except for the type of the argument, and should be used in\n"
21111 " the same way. See the documentation of plsdiori for details.\n"
21112 "\n"
21113 " Redacted form: plsori(ori)\n"
21114 "\n"
21115 " This function is used in example 3.\n"
21116 "\n"
21117 "\n"
21118 "\n"
21119 "SYNOPSIS:\n"
21120 "\n"
21121 "plsori(ori)\n"
21122 "\n"
21123 "ARGUMENTS:\n"
21124 "\n"
21125 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21126 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21127 " angle.\n"
21128 "\n"
21129 ""},
21130 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21131 "Set page parameters\n"
21132 "\n"
21133 "DESCRIPTION:\n"
21134 "\n"
21135 " Sets the page configuration (optional). If an individual parameter is\n"
21136 " zero then that parameter value is not updated. Not all parameters are\n"
21137 " recognized by all drivers and the interpretation is device-dependent.\n"
21138 " The X-window driver uses the length and offset parameters to determine\n"
21139 " the window size and location. The length and offset values are\n"
21140 " expressed in units that are specific to the current driver. For\n"
21141 " instance: screen drivers will usually interpret them as number of\n"
21142 " pixels, whereas printer drivers will usually use mm.\n"
21143 "\n"
21144 " This routine, if used, must be called before initializing PLplot. It\n"
21145 " may be called at later times for interactive drivers to change only\n"
21146 " the dpi for subsequent redraws which you can force via a call to\n"
21147 " plreplot. If this function is not called then the page size defaults\n"
21148 " to landscape A4 for drivers which use real world page sizes and 744\n"
21149 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21150 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21151 "\n"
21152 "\n"
21153 "\n"
21154 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21155 "\n"
21156 " This function is used in examples 14 and 31.\n"
21157 "\n"
21158 "\n"
21159 "\n"
21160 "SYNOPSIS:\n"
21161 "\n"
21162 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21163 "\n"
21164 "ARGUMENTS:\n"
21165 "\n"
21166 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21167 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21168 " (e.g. mm).\n"
21169 "\n"
21170 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21171 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21172 " (e.g. mm).\n"
21173 "\n"
21174 " xleng (PLINT, input) : Page length, x.\n"
21175 "\n"
21176 " yleng (PLINT, input) : Page length, y.\n"
21177 "\n"
21178 " xoff (PLINT, input) : Page offset, x.\n"
21179 "\n"
21180 " yoff (PLINT, input) : Page offset, y.\n"
21181 "\n"
21182 ""},
21183 { "plspal0", _wrap_plspal0, METH_O, "\n"
21184 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21185 "\n"
21186 "DESCRIPTION:\n"
21187 "\n"
21188 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21189 "\n"
21190 " Redacted form: plspal0(filename)\n"
21191 "\n"
21192 " This function is in example 16.\n"
21193 "\n"
21194 "\n"
21195 "\n"
21196 "SYNOPSIS:\n"
21197 "\n"
21198 "plspal0(filename)\n"
21199 "\n"
21200 "ARGUMENTS:\n"
21201 "\n"
21202 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21203 " containing the name of the cmap0*.pal file. If this string is\n"
21204 " empty, use the default cmap0*.pal file.\n"
21205 "\n"
21206 ""},
21207 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21208 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21209 "\n"
21210 "DESCRIPTION:\n"
21211 "\n"
21212 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21213 "\n"
21214 " Redacted form: plspal1(filename, interpolate)\n"
21215 "\n"
21216 " This function is used in example 16.\n"
21217 "\n"
21218 "\n"
21219 "\n"
21220 "SYNOPSIS:\n"
21221 "\n"
21222 "plspal1(filename, interpolate)\n"
21223 "\n"
21224 "ARGUMENTS:\n"
21225 "\n"
21226 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21227 " containing the name of the cmap1*.pal file. If this string is\n"
21228 " empty, use the default cmap1*.pal file.\n"
21229 "\n"
21230 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21231 " columns containing the intensity index, r, g, b, alpha and\n"
21232 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21233 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21234 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21235 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21236 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21237 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21238 " are used instead to set the cmap1 palette directly with a call to\n"
21239 " plscmap1a.\n"
21240 "\n"
21241 ""},
21242 { "plspause", _wrap_plspause, METH_O, "\n"
21243 "Set the pause (on end-of-page) status\n"
21244 "\n"
21245 "DESCRIPTION:\n"
21246 "\n"
21247 " Set the pause (on end-of-page) status.\n"
21248 "\n"
21249 " Redacted form: plspause(pause)\n"
21250 "\n"
21251 " This function is in examples 14,20.\n"
21252 "\n"
21253 "\n"
21254 "\n"
21255 "SYNOPSIS:\n"
21256 "\n"
21257 "plspause(pause)\n"
21258 "\n"
21259 "ARGUMENTS:\n"
21260 "\n"
21261 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21262 " end-of-page for those drivers which support this. Otherwise there\n"
21263 " is no pause.\n"
21264 "\n"
21265 ""},
21266 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21267 "Set current output stream\n"
21268 "\n"
21269 "DESCRIPTION:\n"
21270 "\n"
21271 " Sets the number of the current output stream. The stream number\n"
21272 " defaults to 0 unless changed by this routine. The first use of this\n"
21273 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21274 "\n"
21275 " Redacted form: plsstrm(strm)\n"
21276 "\n"
21277 " This function is examples 1,14,20.\n"
21278 "\n"
21279 "\n"
21280 "\n"
21281 "SYNOPSIS:\n"
21282 "\n"
21283 "plsstrm(strm)\n"
21284 "\n"
21285 "ARGUMENTS:\n"
21286 "\n"
21287 " strm (PLINT, input) : The current stream number.\n"
21288 "\n"
21289 ""},
21290 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21291 "Set the number of subpages in x and y\n"
21292 "\n"
21293 "DESCRIPTION:\n"
21294 "\n"
21295 " Set the number of subpages in x and y.\n"
21296 "\n"
21297 " Redacted form: plssub(nx, ny)\n"
21298 "\n"
21299 " This function is examples 1,2,14,21,25,27.\n"
21300 "\n"
21301 "\n"
21302 "\n"
21303 "SYNOPSIS:\n"
21304 "\n"
21305 "plssub(nx, ny)\n"
21306 "\n"
21307 "ARGUMENTS:\n"
21308 "\n"
21309 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21310 " of window columns).\n"
21311 "\n"
21312 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21313 " of window rows).\n"
21314 "\n"
21315 ""},
21316 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21317 "Set symbol size\n"
21318 "\n"
21319 "DESCRIPTION:\n"
21320 "\n"
21321 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21322 " plsym. The actual height of a symbol is the product of the default\n"
21323 " symbol size and a scaling factor as for the character height.\n"
21324 "\n"
21325 " Redacted form: plssym(def, scale)\n"
21326 "\n"
21327 " This function is used in example 29.\n"
21328 "\n"
21329 "\n"
21330 "\n"
21331 "SYNOPSIS:\n"
21332 "\n"
21333 "plssym(def, scale)\n"
21334 "\n"
21335 "ARGUMENTS:\n"
21336 "\n"
21337 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21338 " should be set to zero if the default height is to remain\n"
21339 " unchanged.\n"
21340 "\n"
21341 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21342 " actual symbol height.\n"
21343 "\n"
21344 ""},
21345 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21346 "Initialization\n"
21347 "\n"
21348 "DESCRIPTION:\n"
21349 "\n"
21350 " Initializing the plotting package. The program prompts for the device\n"
21351 " keyword or number of the desired output device. Hitting a RETURN in\n"
21352 " response to the prompt is the same as selecting the first device. If\n"
21353 " only one device is enabled when PLplot is installed, plstar will issue\n"
21354 " no prompt. The output device is divided into nx by ny subpages, each\n"
21355 " of which may be used independently. The subroutine pladv is used to\n"
21356 " advance from one subpage to the next.\n"
21357 "\n"
21358 " Redacted form: plstar(nx, ny)\n"
21359 "\n"
21360 " This function is used in example 1.\n"
21361 "\n"
21362 "\n"
21363 "\n"
21364 "SYNOPSIS:\n"
21365 "\n"
21366 "plstar(nx, ny)\n"
21367 "\n"
21368 "ARGUMENTS:\n"
21369 "\n"
21370 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21371 " x direction.\n"
21372 "\n"
21373 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21374 " y direction.\n"
21375 "\n"
21376 ""},
21377 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21378 "Initialization\n"
21379 "\n"
21380 "DESCRIPTION:\n"
21381 "\n"
21382 " Alternative to plstar for initializing the plotting package. The\n"
21383 " device name keyword for the desired output device must be supplied as\n"
21384 " an argument. These keywords are the same as those printed out by\n"
21385 " plstar. If the requested device is not available, or if the input\n"
21386 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21387 " is used. This routine also divides the output device page into nx by\n"
21388 " ny subpages, each of which may be used independently. The subroutine\n"
21389 " pladv is used to advance from one subpage to the next.\n"
21390 "\n"
21391 " Redacted form: General: plstart(devname, nx, ny)\n"
21392 "\n"
21393 "\n"
21394 " This function is not used in any examples.\n"
21395 "\n"
21396 "\n"
21397 "\n"
21398 "SYNOPSIS:\n"
21399 "\n"
21400 "plstart(devname, nx, ny)\n"
21401 "\n"
21402 "ARGUMENTS:\n"
21403 "\n"
21404 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21405 " containing the device name keyword of the required output device.\n"
21406 " If\n"
21407 " devname is NULL or if the first character of the string is a ``?'',\n"
21408 " the normal (prompted) start up is used.\n"
21409 "\n"
21410 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21411 " x direction.\n"
21412 "\n"
21413 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21414 " y direction.\n"
21415 "\n"
21416 ""},
21417 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21418 "Set a global coordinate transform function\n"
21419 "\n"
21420 "DESCRIPTION:\n"
21421 "\n"
21422 " This function can be used to define a coordinate transformation which\n"
21423 " affects all elements drawn within the current plot window. The\n"
21424 " coordinate_transform callback function is similar to that provided for\n"
21425 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21426 " parameter may be used to pass extra data to coordinate_transform.\n"
21427 "\n"
21428 " Redacted form: General: plstransform(coordinate_transform,\n"
21429 " coordinate_transform_data)\n"
21430 "\n"
21431 "\n"
21432 " This function is used in examples 19 and 22.\n"
21433 "\n"
21434 "\n"
21435 "\n"
21436 "SYNOPSIS:\n"
21437 "\n"
21438 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21439 "\n"
21440 "ARGUMENTS:\n"
21441 "\n"
21442 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21443 " function that defines the transformation from the input (x, y)\n"
21444 " world coordinates to new PLplot world coordinates. If\n"
21445 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21446 " case), then no transform is applied.\n"
21447 "\n"
21448 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21449 " for\n"
21450 " coordinate_transform.\n"
21451 "\n"
21452 ""},
21453 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21454 "Plot a glyph at the specified points\n"
21455 "\n"
21456 "DESCRIPTION:\n"
21457 "\n"
21458 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21459 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21460 " is specified with a PLplot user string. Note that the user string is\n"
21461 " not actually limited to one glyph so it is possible (but not normally\n"
21462 " useful) to plot more than one glyph at the specified points with this\n"
21463 " function. As with plmtex and plptex, the user string can contain FCI\n"
21464 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21465 " else PLplot escapes for Hershey or unicode text to determine the\n"
21466 " glyph.\n"
21467 "\n"
21468 " Redacted form: plstring(x, y, string)\n"
21469 "\n"
21470 " This function is used in examples 4, 21 and 26.\n"
21471 "\n"
21472 "\n"
21473 "\n"
21474 "SYNOPSIS:\n"
21475 "\n"
21476 "plstring(n, x, y, string)\n"
21477 "\n"
21478 "ARGUMENTS:\n"
21479 "\n"
21480 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21481 "\n"
21482 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21483 " the points.\n"
21484 "\n"
21485 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21486 " the points.\n"
21487 "\n"
21488 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21489 " the glyph(s) to be plotted at each of the n points.\n"
21490 "\n"
21491 ""},
21492 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21493 "Plot a glyph at the specified 3D points\n"
21494 "\n"
21495 "DESCRIPTION:\n"
21496 "\n"
21497 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21498 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21499 " this function similar to what is done for plline3. The glyph is\n"
21500 " specified with a PLplot user string. Note that the user string is not\n"
21501 " actually limited to one glyph so it is possible (but not normally\n"
21502 " useful) to plot more than one glyph at the specified points with this\n"
21503 " function. As with plmtex and plptex, the user string can contain FCI\n"
21504 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21505 " else PLplot escapes for Hershey or unicode text to determine the\n"
21506 " glyph.\n"
21507 "\n"
21508 " Redacted form: plstring3(x, y, z, string)\n"
21509 "\n"
21510 " This function is used in example 18.\n"
21511 "\n"
21512 "\n"
21513 "\n"
21514 "SYNOPSIS:\n"
21515 "\n"
21516 "plstring3(n, x, y, z, string)\n"
21517 "\n"
21518 "ARGUMENTS:\n"
21519 "\n"
21520 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21521 "\n"
21522 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21523 " the points.\n"
21524 "\n"
21525 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21526 " the points.\n"
21527 "\n"
21528 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21529 " the points.\n"
21530 "\n"
21531 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21532 " the glyph(s) to be plotted at each of the n points. points.\n"
21533 "\n"
21534 ""},
21535 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21536 "Add a point to a strip chart\n"
21537 "\n"
21538 "DESCRIPTION:\n"
21539 "\n"
21540 " Add a point to a given pen of a given strip chart. There is no need\n"
21541 " for all pens to have the same number of points or to be equally\n"
21542 " sampled in the x coordinate. Allocates memory and rescales as\n"
21543 " necessary.\n"
21544 "\n"
21545 " Redacted form: plstripa(id, pen, x, y)\n"
21546 "\n"
21547 " This function is used in example 17.\n"
21548 "\n"
21549 "\n"
21550 "\n"
21551 "SYNOPSIS:\n"
21552 "\n"
21553 "plstripa(id, pen, x, y)\n"
21554 "\n"
21555 "ARGUMENTS:\n"
21556 "\n"
21557 " id (PLINT, input) : Identification number of the strip chart (set\n"
21558 " up in plstripc).\n"
21559 "\n"
21560 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21561 "\n"
21562 " x (PLFLT, input) : X coordinate of point to plot.\n"
21563 "\n"
21564 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21565 "\n"
21566 ""},
21567 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21568 "Create a 4-pen strip chart\n"
21569 "\n"
21570 "DESCRIPTION:\n"
21571 "\n"
21572 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21573 "\n"
21574 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21575 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21576 " styline, legline, labx, laby, labz)\n"
21577 "\n"
21578 "\n"
21579 " This function is used in example 17.\n"
21580 "\n"
21581 "\n"
21582 "\n"
21583 "SYNOPSIS:\n"
21584 "\n"
21585 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21586 "\n"
21587 "ARGUMENTS:\n"
21588 "\n"
21589 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21590 " number of the strip chart to use on plstripa and plstripd.\n"
21591 "\n"
21592 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21593 " the x-axis specification as in plbox.\n"
21594 "\n"
21595 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21596 " the y-axis specification as in plbox.\n"
21597 "\n"
21598 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21599 " change as data are added.\n"
21600 "\n"
21601 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21602 " change as data are added.\n"
21603 "\n"
21604 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21605 " is multiplied by the factor (1 +\n"
21606 " xjump) .\n"
21607 "\n"
21608 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21609 " change as data are added.\n"
21610 "\n"
21611 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21612 " change as data are added.\n"
21613 "\n"
21614 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21615 "\n"
21616 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21617 "\n"
21618 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21619 " true, otherwise not.\n"
21620 "\n"
21621 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21622 " otherwise slide display.\n"
21623 "\n"
21624 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21625 "\n"
21626 " collab (PLINT, input) : Legend color index (cmap0).\n"
21627 "\n"
21628 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21629 " indices for the 4 pens.\n"
21630 "\n"
21631 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21632 " indices for the 4 pens.\n"
21633 "\n"
21634 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21635 " strings containing legends for the 4 pens.\n"
21636 "\n"
21637 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21638 " the label for the x axis.\n"
21639 "\n"
21640 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21641 " the label for the y axis.\n"
21642 "\n"
21643 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21644 " the plot title.\n"
21645 "\n"
21646 ""},
21647 { "plstripd", _wrap_plstripd, METH_O, "\n"
21648 "Deletes and releases memory used by a strip chart\n"
21649 "\n"
21650 "DESCRIPTION:\n"
21651 "\n"
21652 " Deletes and releases memory used by a strip chart.\n"
21653 "\n"
21654 " Redacted form: plstripd(id)\n"
21655 "\n"
21656 " This function is used in example 17.\n"
21657 "\n"
21658 "\n"
21659 "\n"
21660 "SYNOPSIS:\n"
21661 "\n"
21662 "plstripd(id)\n"
21663 "\n"
21664 "ARGUMENTS:\n"
21665 "\n"
21666 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21667 "\n"
21668 ""},
21669 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21670 "Set line style\n"
21671 "\n"
21672 "DESCRIPTION:\n"
21673 "\n"
21674 " This sets up the line style for all lines subsequently drawn. A line\n"
21675 " consists of segments in which the pen is alternately down and up. The\n"
21676 " lengths of these segments are passed in the vectors mark and space\n"
21677 " respectively. The number of mark-space pairs is specified by nms. In\n"
21678 " order to return the line style to the default continuous line, plstyl\n"
21679 " should be called with nms =0 .(see also pllsty)\n"
21680 "\n"
21681 " Redacted form: plstyl(mark, space)\n"
21682 "\n"
21683 " This function is used in examples 1, 9, and 14.\n"
21684 "\n"
21685 "\n"
21686 "\n"
21687 "SYNOPSIS:\n"
21688 "\n"
21689 "plstyl(nms, mark, space)\n"
21690 "\n"
21691 "ARGUMENTS:\n"
21692 "\n"
21693 " nms (PLINT, input) : The number of mark and space elements in a\n"
21694 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21695 " . A continuous line is specified by setting nms=0 .\n"
21696 "\n"
21697 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21698 " segments during which the pen is down, measured in micrometers.\n"
21699 "\n"
21700 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21701 " the segments during which the pen is up, measured in micrometers.\n"
21702 "\n"
21703 ""},
21704 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21705 "Set arrow style for vector plots\n"
21706 "\n"
21707 "DESCRIPTION:\n"
21708 "\n"
21709 " Set the style for the arrow used by plvect to plot vectors.\n"
21710 "\n"
21711 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21712 "\n"
21713 " This function is used in example 22.\n"
21714 "\n"
21715 "\n"
21716 "\n"
21717 "SYNOPSIS:\n"
21718 "\n"
21719 "plsvect(arrowx, arrowy, npts, fill)\n"
21720 "\n"
21721 "ARGUMENTS:\n"
21722 "\n"
21723 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21724 " the x and y points which make up the arrow. The arrow is plotted\n"
21725 " by joining these points to form a polygon. The scaling assumes\n"
21726 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21727 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21728 " will be reset to its default.\n"
21729 "\n"
21730 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21731 " arrowy.\n"
21732 "\n"
21733 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21734 " fill is false then the arrow is open.\n"
21735 "\n"
21736 ""},
21737 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21738 "Specify viewport in absolute coordinates\n"
21739 "\n"
21740 "DESCRIPTION:\n"
21741 "\n"
21742 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21743 " should be used only if the viewport is required to have a definite\n"
21744 " size in millimeters. The routine plgspa is useful for finding out the\n"
21745 " size of the current subpage.\n"
21746 "\n"
21747 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21748 "\n"
21749 " This function is used in example 10.\n"
21750 "\n"
21751 "\n"
21752 "\n"
21753 "SYNOPSIS:\n"
21754 "\n"
21755 "plsvpa(xmin, xmax, ymin, ymax)\n"
21756 "\n"
21757 "ARGUMENTS:\n"
21758 "\n"
21759 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21760 " viewport from the left-hand edge of the subpage in millimeters.\n"
21761 "\n"
21762 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21763 " viewport from the left-hand edge of the subpage in millimeters.\n"
21764 "\n"
21765 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21766 " viewport from the bottom edge of the subpage in millimeters.\n"
21767 "\n"
21768 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21769 " from the bottom edge of the subpage in millimeters.\n"
21770 "\n"
21771 ""},
21772 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21773 "Set x axis parameters\n"
21774 "\n"
21775 "DESCRIPTION:\n"
21776 "\n"
21777 " Sets values of the digmax and digits flags for the x axis. See the\n"
21778 " PLplot documentation for more information.\n"
21779 "\n"
21780 " Redacted form: plsxax(digmax, digits)\n"
21781 "\n"
21782 " This function is used in example 31.\n"
21783 "\n"
21784 "\n"
21785 "\n"
21786 "SYNOPSIS:\n"
21787 "\n"
21788 "plsxax(digmax, digits)\n"
21789 "\n"
21790 "ARGUMENTS:\n"
21791 "\n"
21792 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21793 " digits for the x axis. If nonzero, the printed label will be\n"
21794 " switched to a floating-point representation when the number of\n"
21795 " digits exceeds digmax.\n"
21796 "\n"
21797 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21798 " its value here has no effect since it is set only by plbox or\n"
21799 " plbox3. However, the user may obtain its value after a call to\n"
21800 " either of these functions by calling plgxax.\n"
21801 "\n"
21802 ""},
21803 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21804 "Set y axis parameters\n"
21805 "\n"
21806 "DESCRIPTION:\n"
21807 "\n"
21808 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21809 " the description of plsxax for more detail.\n"
21810 "\n"
21811 " Redacted form: plsyax(digmax, digits)\n"
21812 "\n"
21813 " This function is used in examples 1, 14, and 31.\n"
21814 "\n"
21815 "\n"
21816 "\n"
21817 "SYNOPSIS:\n"
21818 "\n"
21819 "plsyax(digmax, digits)\n"
21820 "\n"
21821 "ARGUMENTS:\n"
21822 "\n"
21823 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21824 " digits for the y axis. If nonzero, the printed label will be\n"
21825 " switched to a floating-point representation when the number of\n"
21826 " digits exceeds digmax.\n"
21827 "\n"
21828 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21829 " its value here has no effect since it is set only by plbox or\n"
21830 " plbox3. However, the user may obtain its value after a call to\n"
21831 " either of these functions by calling plgyax.\n"
21832 "\n"
21833 ""},
21834 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21835 "Plot a glyph at the specified points\n"
21836 "\n"
21837 "DESCRIPTION:\n"
21838 "\n"
21839 " Plot a glyph at the specified points. (This function is largely\n"
21840 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21841 "\n"
21842 " Redacted form: plsym(x, y, code)\n"
21843 "\n"
21844 " This function is used in example 7.\n"
21845 "\n"
21846 "\n"
21847 "\n"
21848 "SYNOPSIS:\n"
21849 "\n"
21850 "plsym(n, x, y, code)\n"
21851 "\n"
21852 "ARGUMENTS:\n"
21853 "\n"
21854 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21855 "\n"
21856 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21857 " the points.\n"
21858 "\n"
21859 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21860 " the points.\n"
21861 "\n"
21862 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21863 " to be plotted at each of the n points.\n"
21864 "\n"
21865 ""},
21866 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21867 "Set z axis parameters\n"
21868 "\n"
21869 "DESCRIPTION:\n"
21870 "\n"
21871 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21872 " the description of plsxax for more detail.\n"
21873 "\n"
21874 " Redacted form: plszax(digmax, digits)\n"
21875 "\n"
21876 " This function is used in example 31.\n"
21877 "\n"
21878 "\n"
21879 "\n"
21880 "SYNOPSIS:\n"
21881 "\n"
21882 "plszax(digmax, digits)\n"
21883 "\n"
21884 "ARGUMENTS:\n"
21885 "\n"
21886 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21887 " digits for the z axis. If nonzero, the printed label will be\n"
21888 " switched to a floating-point representation when the number of\n"
21889 " digits exceeds digmax.\n"
21890 "\n"
21891 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21892 " its value here has no effect since it is set only by plbox or\n"
21893 " plbox3. However, the user may obtain its value after a call to\n"
21894 " either of these functions by calling plgzax.\n"
21895 "\n"
21896 ""},
21897 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21898 "Switch to text screen\n"
21899 "\n"
21900 "DESCRIPTION:\n"
21901 "\n"
21902 " Sets an interactive device to text mode, used in conjunction with\n"
21903 " plgra to allow graphics and text to be interspersed. On a device\n"
21904 " which supports separate text and graphics windows, this command causes\n"
21905 " control to be switched to the text window. This can be useful for\n"
21906 " printing diagnostic messages or getting user input, which would\n"
21907 " otherwise interfere with the plots. The program must switch back to\n"
21908 " the graphics window before issuing plot commands, as the text (or\n"
21909 " console) device will probably become quite confused otherwise. If\n"
21910 " already in text mode, this command is ignored. It is also ignored on\n"
21911 " devices which only support a single window or use a different method\n"
21912 " for shifting focus (see also plgra).\n"
21913 "\n"
21914 " Redacted form: pltext()\n"
21915 "\n"
21916 " This function is used in example 1.\n"
21917 "\n"
21918 "\n"
21919 "\n"
21920 "SYNOPSIS:\n"
21921 "\n"
21922 "pltext()\n"
21923 "\n"
21924 ""},
21925 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21926 "Set format for date / time labels\n"
21927 "\n"
21928 "DESCRIPTION:\n"
21929 "\n"
21930 " Sets the format for date / time labels. To enable date / time format\n"
21931 " labels see the options to plbox, plbox3, and plenv.\n"
21932 "\n"
21933 " Redacted form: pltimefmt(fmt)\n"
21934 "\n"
21935 " This function is used in example 29.\n"
21936 "\n"
21937 "\n"
21938 "\n"
21939 "SYNOPSIS:\n"
21940 "\n"
21941 "pltimefmt(fmt)\n"
21942 "\n"
21943 "ARGUMENTS:\n"
21944 "\n"
21945 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21946 " interpreted similarly to the format specifier of typical system\n"
21947 " strftime routines except that PLplot ignores locale and also\n"
21948 " supplies some useful extensions in the context of plotting. All\n"
21949 " text in the string is printed as-is other than conversion\n"
21950 " specifications which take the form of a '%' character followed by\n"
21951 " further conversion specification character. The conversion\n"
21952 " specifications which are similar to those provided by system\n"
21953 " strftime routines are the following: %a: The abbreviated (English)\n"
21954 " weekday name.\n"
21955 " %A: The full (English) weekday name.\n"
21956 " %b: The abbreviated (English) month name.\n"
21957 " %B: The full (English) month name.\n"
21958 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21959 " %C: The century number (year/100) as a 2-digit integer.\n"
21960 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21961 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21962 " %e: Like %d, but a leading zero is replaced by a space.\n"
21963 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21964 " %h: Equivalent to %b.\n"
21965 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21966 " 00 to 23).\n"
21967 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21968 " 01 to 12).\n"
21969 " %j: The day of the year as a decimal number (range 001 to\n"
21970 " 366).\n"
21971 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21972 " 23); single digits are preceded by a blank. (See also %H.)\n"
21973 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21974 " 12); single digits are preceded by a blank. (See also %I.)\n"
21975 " %m: The month as a decimal number (range 01 to 12).\n"
21976 " %M: The minute as a decimal number (range 00 to 59).\n"
21977 " %n: A newline character.\n"
21978 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21979 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21980 " %r: Equivalent to %I:%M:%S %p.\n"
21981 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21982 " including the seconds, see %T below.\n"
21983 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21984 " +0000 (UTC).\n"
21985 " %S: The second as a decimal number (range 00 to 60). (The\n"
21986 " range is up to 60 to allow for occasional leap seconds.)\n"
21987 " %t: A tab character.\n"
21988 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21989 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21990 " being 1. See also %w.\n"
21991 " %U: The week number of the current year as a decimal number,\n"
21992 " range 00 to 53, starting with the first Sunday as the first\n"
21993 " day of week 01. See also %V and %W.\n"
21994 " %v: Equivalent to %e-%b-%Y.\n"
21995 " %V: The ISO 8601 week number of the current year as a decimal\n"
21996 " number, range 01 to 53, where week 1 is the first week that\n"
21997 " has at least 4 days in the new year. See also %U and %W.\n"
21998 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21999 " being 0. See also %u.\n"
22000 " %W: The week number of the current year as a decimal number,\n"
22001 " range 00 to 53, starting with the first Monday as the first\n"
22002 " day of week 01.\n"
22003 " %x: Equivalent to %a %b %d %Y.\n"
22004 " %X: Equivalent to %T.\n"
22005 " %y: The year as a decimal number without a century (range 00\n"
22006 " to 99).\n"
22007 " %Y: The year as a decimal number including a century.\n"
22008 " %z: The UTC time-zone string = \"+0000\".\n"
22009 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
22010 " %+: The UTC date and time in default format of the Unix date\n"
22011 " command which is equivalent to %a %b %d %T %Z %Y.\n"
22012 " %%: A literal \"%\" character.\n"
22013 " The conversion specifications which are extensions to those normally\n"
22014 " provided by system strftime routines are the following: %(0-9):\n"
22015 " The fractional part of the seconds field (including leading\n"
22016 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
22017 " seconds to millisecond accuracy (00.000).\n"
22018 " %.: The fractional part of the seconds field (including\n"
22019 " leading decimal point) to the maximum available accuracy. Thus\n"
22020 " %S%. would give seconds with fractional part up to 9 decimal\n"
22021 " places if available.\n"
22022 "\n"
22023 ""},
22024 { "plvasp", _wrap_plvasp, METH_O, "\n"
22025 "Specify viewport using aspect ratio only\n"
22026 "\n"
22027 "DESCRIPTION:\n"
22028 "\n"
22029 " Selects the largest viewport with the given aspect ratio within the\n"
22030 " subpage that leaves a standard margin (left-hand margin of eight\n"
22031 " character heights, and a margin around the other three sides of five\n"
22032 " character heights).\n"
22033 "\n"
22034 " Redacted form: plvasp(aspect)\n"
22035 "\n"
22036 " This function is used in example 13.\n"
22037 "\n"
22038 "\n"
22039 "\n"
22040 "SYNOPSIS:\n"
22041 "\n"
22042 "plvasp(aspect)\n"
22043 "\n"
22044 "ARGUMENTS:\n"
22045 "\n"
22046 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22047 " axis of resulting viewport.\n"
22048 "\n"
22049 ""},
22050 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22051 "Vector plot\n"
22052 "\n"
22053 "DESCRIPTION:\n"
22054 "\n"
22055 " Draws a plot of vector data contained in the matrices (\n"
22056 " u[\n"
22057 " nx][\n"
22058 " ny],\n"
22059 " v[\n"
22060 " nx][\n"
22061 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22062 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22063 " additional data required by the transformation routine to map indices\n"
22064 " within the matrices to the world coordinates. The style of the vector\n"
22065 " arrow may be set using plsvect.\n"
22066 "\n"
22067 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22068 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22069 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22070 " with either one or two dimensions.\n"
22071 "\n"
22072 " This function is used in example 22.\n"
22073 "\n"
22074 "\n"
22075 "\n"
22076 "SYNOPSIS:\n"
22077 "\n"
22078 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22079 "\n"
22080 "ARGUMENTS:\n"
22081 "\n"
22082 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22083 " and y components of the vector data to be plotted.\n"
22084 "\n"
22085 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22086 "\n"
22087 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22088 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22089 " automatically calculated for the data. If scale < 0 then the\n"
22090 " scaling factor is automatically calculated for the data and then\n"
22091 " multiplied by -\n"
22092 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22093 "\n"
22094 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22095 " defines the transformation between the zero-based indices of the\n"
22096 " matrices u and v and world coordinates.For the C case,\n"
22097 " transformation functions are provided in the PLplot library: pltr0\n"
22098 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22099 " mappings respectively defined by vectors and matrices. In\n"
22100 " addition, C callback routines for the transformation can be\n"
22101 " supplied by the user such as the mypltr function in\n"
22102 " examples/c/x09c.c which provides a general linear transformation\n"
22103 " between index coordinates and world coordinates.For languages\n"
22104 " other than C you should consult the PLplot documentation for the\n"
22105 " details concerning how PLTRANSFORM_callback arguments are\n"
22106 " interfaced. However, in general, a particular pattern of\n"
22107 " callback-associated arguments such as a tr vector with 6 elements;\n"
22108 " xg and yg vectors; or xg and yg matrices are respectively\n"
22109 " interfaced to a linear-transformation routine similar to the above\n"
22110 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22111 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22112 " support native language callbacks for handling index to\n"
22113 " world-coordinate transformations. Examples of these various\n"
22114 " approaches are given in examples/<language>x09*,\n"
22115 " examples/<language>x16*, examples/<language>x20*,\n"
22116 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22117 " supported languages.\n"
22118 "\n"
22119 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22120 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22121 " that is externally supplied.\n"
22122 "\n"
22123 ""},
22124 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22125 "Specify viewport using coordinates and aspect ratio\n"
22126 "\n"
22127 "DESCRIPTION:\n"
22128 "\n"
22129 " Device-independent routine for setting up the viewport. The viewport\n"
22130 " is chosen to be the largest with the given aspect ratio that fits\n"
22131 " within the specified region (in terms of normalized subpage\n"
22132 " coordinates). This routine is functionally equivalent to plvpor when\n"
22133 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22134 " routine reserves no extra space at the edges for labels.\n"
22135 "\n"
22136 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22137 "\n"
22138 " This function is used in example 9.\n"
22139 "\n"
22140 "\n"
22141 "\n"
22142 "SYNOPSIS:\n"
22143 "\n"
22144 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22145 "\n"
22146 "ARGUMENTS:\n"
22147 "\n"
22148 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22149 " left-hand edge of the viewport.\n"
22150 "\n"
22151 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22152 " right-hand edge of the viewport.\n"
22153 "\n"
22154 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22155 " bottom edge of the viewport.\n"
22156 "\n"
22157 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22158 " edge of the viewport.\n"
22159 "\n"
22160 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22161 " axis.\n"
22162 "\n"
22163 ""},
22164 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22165 "Specify viewport using normalized subpage coordinates\n"
22166 "\n"
22167 "DESCRIPTION:\n"
22168 "\n"
22169 " Device-independent routine for setting up the viewport. This defines\n"
22170 " the viewport in terms of normalized subpage coordinates which run from\n"
22171 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22172 " current subpage. Use the alternate routine plsvpa in order to create\n"
22173 " a viewport of a definite size.\n"
22174 "\n"
22175 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22176 "\n"
22177 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22178 " 24, 26, 27, and 31.\n"
22179 "\n"
22180 "\n"
22181 "\n"
22182 "SYNOPSIS:\n"
22183 "\n"
22184 "plvpor(xmin, xmax, ymin, ymax)\n"
22185 "\n"
22186 "ARGUMENTS:\n"
22187 "\n"
22188 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22189 " left-hand edge of the viewport.\n"
22190 "\n"
22191 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22192 " right-hand edge of the viewport.\n"
22193 "\n"
22194 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22195 " bottom edge of the viewport.\n"
22196 "\n"
22197 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22198 " edge of the viewport.\n"
22199 "\n"
22200 ""},
22201 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22202 "Select standard viewport\n"
22203 "\n"
22204 "DESCRIPTION:\n"
22205 "\n"
22206 " Selects the largest viewport within the subpage that leaves a standard\n"
22207 " margin (left-hand margin of eight character heights, and a margin\n"
22208 " around the other three sides of five character heights).\n"
22209 "\n"
22210 " Redacted form: plvsta()\n"
22211 "\n"
22212 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22213 "\n"
22214 "\n"
22215 "\n"
22216 "SYNOPSIS:\n"
22217 "\n"
22218 "plvsta()\n"
22219 "\n"
22220 ""},
22221 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22222 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22223 "\n"
22224 "DESCRIPTION:\n"
22225 "\n"
22226 " Configure the transformations required for projecting a 3D surface on\n"
22227 " an existing 2D window. Those transformations (see the PLplot\n"
22228 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22229 " surface which has its limits expressed in 3D world coordinates and\n"
22230 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22231 " azimuth of the viewing angle). The transformations consist of the\n"
22232 " linear transform from 3D world coordinates to normalized 3D\n"
22233 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22234 " align the pole of the new 3D coordinate system with the viewing\n"
22235 " direction specified by altitude and azimuth so that x and y of the\n"
22236 " surface elements in that transformed coordinate system are the\n"
22237 " projection of the 3D surface with given viewing direction on the 2D\n"
22238 " window.\n"
22239 "\n"
22240 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22241 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22242 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22243 " sizes of basex by basey by height so that xmin maps to -\n"
22244 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22245 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22246 " The resulting rectangular cuboid in normalized coordinates is then\n"
22247 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22248 " must be called before plbox3 or any of the 3D surface plotting\n"
22249 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22250 " plsurf3dl or plfill3.\n"
22251 "\n"
22252 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22253 " zmin, zmax, alt, az)\n"
22254 "\n"
22255 " This function is examples 8, 11, 18, and 21.\n"
22256 "\n"
22257 "\n"
22258 "\n"
22259 "SYNOPSIS:\n"
22260 "\n"
22261 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22262 "\n"
22263 "ARGUMENTS:\n"
22264 "\n"
22265 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22266 " rectangular cuboid.\n"
22267 "\n"
22268 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22269 " rectangular cuboid.\n"
22270 "\n"
22271 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22272 " rectangular cuboid.\n"
22273 "\n"
22274 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22275 " rectangular cuboid.\n"
22276 "\n"
22277 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22278 " rectangular cuboid.\n"
22279 "\n"
22280 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22281 " rectangular cuboid.\n"
22282 "\n"
22283 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22284 " rectangular cuboid.\n"
22285 "\n"
22286 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22287 " rectangular cuboid.\n"
22288 "\n"
22289 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22290 " rectangular cuboid.\n"
22291 "\n"
22292 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22293 " plane of the rectangular cuboid in normalized coordinates.\n"
22294 "\n"
22295 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22296 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22297 " observer is looking face onto the zx plane of the rectangular\n"
22298 " cuboid in normalized coordinates, and as az is increased, the\n"
22299 " observer moves clockwise around that cuboid when viewed from above\n"
22300 " the xy plane.\n"
22301 "\n"
22302 ""},
22303 { "plwidth", _wrap_plwidth, METH_O, "\n"
22304 "Set pen width\n"
22305 "\n"
22306 "DESCRIPTION:\n"
22307 "\n"
22308 " Sets the pen width.\n"
22309 "\n"
22310 " Redacted form: plwidth(width)\n"
22311 "\n"
22312 " This function is used in examples 1 and 2.\n"
22313 "\n"
22314 "\n"
22315 "\n"
22316 "SYNOPSIS:\n"
22317 "\n"
22318 "plwidth(width)\n"
22319 "\n"
22320 "ARGUMENTS:\n"
22321 "\n"
22322 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22323 " or the same as the previous value no action is taken. width = 0.\n"
22324 " should be interpreted as as the minimum valid pen width for the\n"
22325 " device. The interpretation of positive width values is also\n"
22326 " device dependent.\n"
22327 "\n"
22328 ""},
22329 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22330 "Specify window\n"
22331 "\n"
22332 "DESCRIPTION:\n"
22333 "\n"
22334 " Specify the window, i.e., the world coordinates of the edges of the\n"
22335 " viewport.\n"
22336 "\n"
22337 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22338 "\n"
22339 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22340 " 29, and 31.\n"
22341 "\n"
22342 "\n"
22343 "\n"
22344 "SYNOPSIS:\n"
22345 "\n"
22346 "plwind(xmin, xmax, ymin, ymax)\n"
22347 "\n"
22348 "ARGUMENTS:\n"
22349 "\n"
22350 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22351 " of the viewport.\n"
22352 "\n"
22353 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22354 " of the viewport.\n"
22355 "\n"
22356 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22357 " the viewport.\n"
22358 "\n"
22359 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22360 " viewport.\n"
22361 "\n"
22362 ""},
22363 { "plxormod", _wrap_plxormod, METH_O, "\n"
22364 "Enter or leave xor mode\n"
22365 "\n"
22366 "DESCRIPTION:\n"
22367 "\n"
22368 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22369 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22370 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22371 " is not capable of xor operation it returns a status of false.\n"
22372 "\n"
22373 " Redacted form: plxormod(mode, status)\n"
22374 "\n"
22375 " This function is used in examples 1 and 20.\n"
22376 "\n"
22377 "\n"
22378 "\n"
22379 "SYNOPSIS:\n"
22380 "\n"
22381 "plxormod(mode, status)\n"
22382 "\n"
22383 "ARGUMENTS:\n"
22384 "\n"
22385 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22386 " is false means leave xor mode.\n"
22387 "\n"
22388 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22389 " modestatus of true (false) means driver is capable (incapable) of\n"
22390 " xor mode.\n"
22391 "\n"
22392 ""},
22393 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22394 "Plot continental outline or shapefile data in world coordinates\n"
22395 "\n"
22396 "DESCRIPTION:\n"
22397 "\n"
22398 " Plots continental outlines or shapefile data in world coordinates. A\n"
22399 " demonstration of how to use this function to create different\n"
22400 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22401 " basic coastal outlines and USA state borders. To use the map\n"
22402 " functionality PLplot must be compiled with the shapelib library.\n"
22403 " Shapefiles have become a popular standard for geographical data and\n"
22404 " data in this format can be easily found from a number of online\n"
22405 " sources. Shapefile data is actually provided as three or more files\n"
22406 " with the same filename, but different extensions. The .shp and .shx\n"
22407 " files are required for plotting Shapefile data with PLplot.\n"
22408 "\n"
22409 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22410 " objects within shapefiles. However holes in polygons are not\n"
22411 " supported. When plmap is used the type of object is derived from the\n"
22412 " shapefile, if you wish to override the type then use one of the other\n"
22413 " plmap variants. The built in maps have line data only.\n"
22414 "\n"
22415 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22416 "\n"
22417 " This function is used in example 19.\n"
22418 "\n"
22419 "\n"
22420 "\n"
22421 "SYNOPSIS:\n"
22422 "\n"
22423 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22424 "\n"
22425 "ARGUMENTS:\n"
22426 "\n"
22427 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22428 " transform the original map data coordinates to a new coordinate\n"
22429 " system. The PLplot-supplied map data is provided as latitudes and\n"
22430 " longitudes; other Shapefile data may be provided in other\n"
22431 " coordinate systems as can be found in their .prj plain text files.\n"
22432 " For example, by using this transform we can change from a\n"
22433 " longitude, latitude coordinate to a polar stereographic\n"
22434 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22435 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22436 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22437 " data). After the call to mapform(), x[] and y[] should be\n"
22438 " replaced by the corresponding plot coordinates. If no transform is\n"
22439 " desired, mapform can be replaced by NULL.\n"
22440 "\n"
22441 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22442 " the type of map plotted. This is either one of the PLplot built-in\n"
22443 " maps or the file name of a set of Shapefile files without the file\n"
22444 " extensions. For the PLplot built-in maps the possible values are:\n"
22445 " \"globe\" -- continental outlines\n"
22446 " \"usa\" -- USA and state boundaries\n"
22447 " \"cglobe\" -- continental outlines and countries\n"
22448 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22449 "\n"
22450 "\n"
22451 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22452 " drawn. The units must match the shapefile (built in maps are\n"
22453 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22454 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22455 " note this is simply an optimisation, not a clipping so for objects\n"
22456 " with some points inside the box and some points outside the box\n"
22457 " all the points will be rendered. These parameters also define\n"
22458 " latitude and longitude wrapping for shapefiles using these units.\n"
22459 " Longitude points will be wrapped by integer multiples of 360\n"
22460 " degrees to place them in the box. This allows the same data to be\n"
22461 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22462 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22463 " value of minx must be less than the value of maxx. Passing in a\n"
22464 " nan, max/-max floating point number or +/-infinity will case the\n"
22465 " bounding box from the shapefile to be used.\n"
22466 "\n"
22467 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22468 " drawn - see minx.\n"
22469 "\n"
22470 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22471 " drawn - see minx.\n"
22472 "\n"
22473 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22474 " drawn - see minx.\n"
22475 "\n"
22476 ""},
22477 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22478 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22479 "\n"
22480 "DESCRIPTION:\n"
22481 "\n"
22482 " Plot all or a subset of Shapefile data using lines in world\n"
22483 " coordinates. Our 19th standard example demonstrates how to use this\n"
22484 " function. This function plots data from a Shapefile using lines as in\n"
22485 " plmap, however it also has the option of also only drawing specified\n"
22486 " elements from the Shapefile. The vector of indices of the required\n"
22487 " elements are passed as a function argument. The Shapefile data should\n"
22488 " include a metadata file (extension.dbf) listing all items within the\n"
22489 " Shapefile. This file can be opened by most popular spreadsheet\n"
22490 " programs and can be used to decide which indices to pass to this\n"
22491 " function.\n"
22492 "\n"
22493 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22494 " plotentries)\n"
22495 "\n"
22496 " This function is used in example 19.\n"
22497 "\n"
22498 "\n"
22499 "\n"
22500 "SYNOPSIS:\n"
22501 "\n"
22502 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22503 "\n"
22504 "ARGUMENTS:\n"
22505 "\n"
22506 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22507 " transform the coordinates given in the shapefile into a plot\n"
22508 " coordinate system. By using this transform, we can change from a\n"
22509 " longitude, latitude coordinate to a polar stereographic project,\n"
22510 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22511 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22512 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22513 " plot coordinates. If no transform is desired, mapform can be\n"
22514 " replaced by NULL.\n"
22515 "\n"
22516 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22517 " the file name of a set of Shapefile files without the file\n"
22518 " extension.\n"
22519 "\n"
22520 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22521 " be in the same units as used by the Shapefile. You could use a\n"
22522 " very large negative number to plot everything, but you can improve\n"
22523 " performance by limiting the area drawn. The units must match those\n"
22524 " of the Shapefile projection, which may be for example longitude or\n"
22525 " distance. The value of minx must be less than the value of maxx.\n"
22526 "\n"
22527 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22528 " use a very large number to plot everything, but you can improve\n"
22529 " performance by limiting the area drawn.\n"
22530 "\n"
22531 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22532 " be in the same units as used by the Shapefile. You could use a\n"
22533 " very large negative number to plot everything, but you can improve\n"
22534 " performance by limiting the area drawn. The units must match those\n"
22535 " of the Shapefile projection, which may be for example latitude or\n"
22536 " distance. The value of miny must be less than the value of maxy.\n"
22537 "\n"
22538 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22539 " use a very large number to plot everything, but you can improve\n"
22540 " performance by limiting the area drawn.\n"
22541 "\n"
22542 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22543 " zero-based indices of the Shapefile elements which will be drawn.\n"
22544 " Setting\n"
22545 " plotentries to NULL will plot all elements of the Shapefile.\n"
22546 "\n"
22547 " nplotentries (PLINT, input) : The number of items in\n"
22548 " plotentries. Ignored if\n"
22549 " plotentries is NULL.\n"
22550 "\n"
22551 ""},
22552 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22553 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22554 "\n"
22555 "DESCRIPTION:\n"
22556 "\n"
22557 " As per plmapline, however the items are plotted as strings or points\n"
22558 " in the same way as plstring.\n"
22559 "\n"
22560 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22561 " maxy, plotentries)\n"
22562 "\n"
22563 " This function is not used in any examples.\n"
22564 "\n"
22565 "\n"
22566 "\n"
22567 "SYNOPSIS:\n"
22568 "\n"
22569 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22570 "\n"
22571 "ARGUMENTS:\n"
22572 "\n"
22573 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22574 " transform the coordinates given in the shapefile into a plot\n"
22575 " coordinate system. By using this transform, we can change from a\n"
22576 " longitude, latitude coordinate to a polar stereographic project,\n"
22577 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22578 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22579 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22580 " plot coordinates. If no transform is desired, mapform can be\n"
22581 " replaced by NULL.\n"
22582 "\n"
22583 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22584 " the file name of a set of Shapefile files without the file\n"
22585 " extension.\n"
22586 "\n"
22587 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22588 " drawn.\n"
22589 "\n"
22590 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22591 " be in the same units as used by the Shapefile. You could use a\n"
22592 " very large negative number to plot everything, but you can improve\n"
22593 " performance by limiting the area drawn. The units must match those\n"
22594 " of the Shapefile projection, which may be for example longitude or\n"
22595 " distance. The value of minx must be less than the value of maxx.\n"
22596 "\n"
22597 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22598 " use a very large number to plot everything, but you can improve\n"
22599 " performance by limiting the area drawn.\n"
22600 "\n"
22601 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22602 " be in the same units as used by the Shapefile. You could use a\n"
22603 " very large negative number to plot everything, but you can improve\n"
22604 " performance by limiting the area drawn. The units must match those\n"
22605 " of the Shapefile projection, which may be for example latitude or\n"
22606 " distance. The value of miny must be less than the value of maxy.\n"
22607 "\n"
22608 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22609 " use a very large number to plot everything, but you can improve\n"
22610 " performance by limiting the area drawn.\n"
22611 "\n"
22612 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22613 " zero-based indices of the Shapefile elements which will be drawn.\n"
22614 " Setting\n"
22615 " plotentries to NULL will plot all elements of the Shapefile.\n"
22616 "\n"
22617 " nplotentries (PLINT, input) : The number of items in\n"
22618 " plotentries. Ignored if\n"
22619 " plotentries is NULL.\n"
22620 "\n"
22621 ""},
22622 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22623 "Draw text at points defined by Shapefile data in world coordinates\n"
22624 "\n"
22625 "DESCRIPTION:\n"
22626 "\n"
22627 " As per plmapline, however the items are plotted as text in the same\n"
22628 " way as plptex.\n"
22629 "\n"
22630 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22631 " miny, maxy, plotentry)\n"
22632 "\n"
22633 " This function is used in example 19.\n"
22634 "\n"
22635 "\n"
22636 "\n"
22637 "SYNOPSIS:\n"
22638 "\n"
22639 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22640 "\n"
22641 "ARGUMENTS:\n"
22642 "\n"
22643 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22644 " transform the coordinates given in the shapefile into a plot\n"
22645 " coordinate system. By using this transform, we can change from a\n"
22646 " longitude, latitude coordinate to a polar stereographic project,\n"
22647 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22648 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22649 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22650 " plot coordinates. If no transform is desired, mapform can be\n"
22651 " replaced by NULL.\n"
22652 "\n"
22653 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22654 " the file name of a set of Shapefile files without the file\n"
22655 " extension.\n"
22656 "\n"
22657 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22658 " dy/dx.\n"
22659 "\n"
22660 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22661 " dy/dx.\n"
22662 "\n"
22663 " just (PLFLT, input) : Set the justification of the text. The value\n"
22664 " given will be the fraction of the distance along the string that\n"
22665 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22666 " centralized text and 1.0 gives right aligned text.\n"
22667 "\n"
22668 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22669 "\n"
22670 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22671 " be in the same units as used by the Shapefile. You could use a\n"
22672 " very large negative number to plot everything, but you can improve\n"
22673 " performance by limiting the area drawn. The units must match those\n"
22674 " of the Shapefile projection, which may be for example longitude or\n"
22675 " distance. The value of minx must be less than the value of maxx.\n"
22676 "\n"
22677 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22678 " use a very large number to plot everything, but you can improve\n"
22679 " performance by limiting the area drawn.\n"
22680 "\n"
22681 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22682 " be in the same units as used by the Shapefile. You could use a\n"
22683 " very large negative number to plot everything, but you can improve\n"
22684 " performance by limiting the area drawn. The units must match those\n"
22685 " of the Shapefile projection, which may be for example latitude or\n"
22686 " distance. The value of miny must be less than the value of maxy.\n"
22687 "\n"
22688 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22689 " use a very large number to plot everything, but you can improve\n"
22690 " performance by limiting the area drawn.\n"
22691 "\n"
22692 " plotentry (PLINT, input) : An integer indicating which text string\n"
22693 " of the Shapefile (zero indexed) will be drawn.\n"
22694 "\n"
22695 ""},
22696 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22697 "Plot all or a subset of Shapefile data, filling the polygons\n"
22698 "\n"
22699 "DESCRIPTION:\n"
22700 "\n"
22701 " As per plmapline, however the items are filled in the same way as\n"
22702 " plfill.\n"
22703 "\n"
22704 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22705 " plotentries)\n"
22706 "\n"
22707 " This function is used in example 19.\n"
22708 "\n"
22709 "\n"
22710 "\n"
22711 "SYNOPSIS:\n"
22712 "\n"
22713 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22714 "\n"
22715 "ARGUMENTS:\n"
22716 "\n"
22717 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22718 " transform the coordinates given in the shapefile into a plot\n"
22719 " coordinate system. By using this transform, we can change from a\n"
22720 " longitude, latitude coordinate to a polar stereographic project,\n"
22721 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22722 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22723 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22724 " plot coordinates. If no transform is desired, mapform can be\n"
22725 " replaced by NULL.\n"
22726 "\n"
22727 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22728 " the file name of a set of Shapefile files without the file\n"
22729 " extension.\n"
22730 "\n"
22731 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22732 " be in the same units as used by the Shapefile. You could use a\n"
22733 " very large negative number to plot everything, but you can improve\n"
22734 " performance by limiting the area drawn. The units must match those\n"
22735 " of the Shapefile projection, which may be for example longitude or\n"
22736 " distance. The value of minx must be less than the value of maxx.\n"
22737 "\n"
22738 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22739 " use a very large number to plot everything, but you can improve\n"
22740 " performance by limiting the area drawn.\n"
22741 "\n"
22742 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22743 " be in the same units as used by the Shapefile. You could use a\n"
22744 " very large negative number to plot everything, but you can improve\n"
22745 " performance by limiting the area drawn. The units must match those\n"
22746 " of the Shapefile projection, which may be for example latitude or\n"
22747 " distance. The value of miny must be less than the value of maxy.\n"
22748 "\n"
22749 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22750 " use a very large number to plot everything, but you can improve\n"
22751 " performance by limiting the area drawn.\n"
22752 "\n"
22753 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22754 " zero-based indices of the Shapefile elements which will be drawn.\n"
22755 " Setting\n"
22756 " plotentries to NULL will plot all elements of the Shapefile.\n"
22757 "\n"
22758 " nplotentries (PLINT, input) : The number of items in\n"
22759 " plotentries. Ignored if\n"
22760 " plotentries is NULL.\n"
22761 "\n"
22762 ""},
22763 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22764 "Plot latitude and longitude lines\n"
22765 "\n"
22766 "DESCRIPTION:\n"
22767 "\n"
22768 " Displays latitude and longitude on the current plot. The lines are\n"
22769 " plotted in the current color and line style.\n"
22770 "\n"
22771 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22772 " minlat, maxlat)\n"
22773 "\n"
22774 " This function is used in example 19.\n"
22775 "\n"
22776 "\n"
22777 "\n"
22778 "SYNOPSIS:\n"
22779 "\n"
22780 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22781 "\n"
22782 "ARGUMENTS:\n"
22783 "\n"
22784 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22785 " transform the coordinate longitudes and latitudes to a plot\n"
22786 " coordinate system. By using this transform, we can change from a\n"
22787 " longitude, latitude coordinate to a polar stereographic project,\n"
22788 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22789 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22790 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22791 " plot coordinates. If no transform is desired, mapform can be\n"
22792 " replaced by NULL.\n"
22793 "\n"
22794 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22795 " longitude lines are to be plotted.\n"
22796 "\n"
22797 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22798 " lines are to be plotted.\n"
22799 "\n"
22800 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22801 " side of the plot. The value of minlong must be less than the value\n"
22802 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22803 " equal to 360.\n"
22804 "\n"
22805 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22806 " side of the plot.\n"
22807 "\n"
22808 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22809 " background. One can always use -90.0 as the boundary outside the\n"
22810 " plot window will be automatically eliminated. However, the\n"
22811 " program will be faster if one can reduce the size of the\n"
22812 " background plotted.\n"
22813 "\n"
22814 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22815 " background. One can always use 90.0 as the boundary outside the\n"
22816 " plot window will be automatically eliminated.\n"
22817 "\n"
22818 ""},
22819 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22820 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22821 "\n"
22822 "DESCRIPTION:\n"
22823 "\n"
22824 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22825 " automatically adjusted to use the maximum and minimum values in idata\n"
22826 " as valuemin and valuemax in a call to plimagefr.\n"
22827 "\n"
22828 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22829 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22830 "\n"
22831 "\n"
22832 " This function is used in example 20.\n"
22833 "\n"
22834 "\n"
22835 "\n"
22836 "SYNOPSIS:\n"
22837 "\n"
22838 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22839 "\n"
22840 "ARGUMENTS:\n"
22841 "\n"
22842 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22843 " to plot. Should have dimensions of\n"
22844 " nx by\n"
22845 " ny.\n"
22846 "\n"
22847 " nx, ny (PLINT, input) : Dimensions of idata\n"
22848 "\n"
22849 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22850 " are linearly transformed to these world coordinate ranges such\n"
22851 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22852 " - 1] corresponds to (xmax, ymax).\n"
22853 "\n"
22854 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22855 " (inclusive) will be plotted.\n"
22856 "\n"
22857 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22858 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22859 " Dymin) to (Dxmax, Dymax).\n"
22860 "\n"
22861 ""},
22862 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22863 "Plot a 2D matrix using cmap1\n"
22864 "\n"
22865 "DESCRIPTION:\n"
22866 "\n"
22867 " Plot a 2D matrix using cmap1.\n"
22868 "\n"
22869 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22870 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22871 "\n"
22872 "\n"
22873 " This function is used in example 20.\n"
22874 "\n"
22875 "\n"
22876 "\n"
22877 "SYNOPSIS:\n"
22878 "\n"
22879 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22880 "\n"
22881 "ARGUMENTS:\n"
22882 "\n"
22883 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22884 " plot. Should have dimensions of\n"
22885 " nx by\n"
22886 " ny.\n"
22887 "\n"
22888 " nx, ny (PLINT, input) : Dimensions of idata\n"
22889 "\n"
22890 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22891 " pltr below for how these arguments are used (only for the special case\n"
22892 " when the callback function\n"
22893 " pltr is not supplied).\n"
22894 "\n"
22895 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22896 " (inclusive) will be plotted.\n"
22897 "\n"
22898 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22899 " values to use for value to color mappings. A datum equal to or\n"
22900 " less than valuemin will be plotted with color 0.0, while a datum\n"
22901 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22902 " Data between valuemin and valuemax map linearly to colors in the\n"
22903 " range (0.0-1.0).\n"
22904 "\n"
22905 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22906 " defines the transformation between the zero-based indices of the\n"
22907 " matrix idata and world coordinates. If\n"
22908 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22909 " indices of idata are mapped to the range\n"
22910 " xmin through\n"
22911 " xmax and the y indices of idata are mapped to the range\n"
22912 " ymin through\n"
22913 " ymax.For the C case, transformation functions are provided in the\n"
22914 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22915 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22916 " matrices. In addition, C callback routines for the transformation\n"
22917 " can be supplied by the user such as the mypltr function in\n"
22918 " examples/c/x09c.c which provides a general linear transformation\n"
22919 " between index coordinates and world coordinates.For languages\n"
22920 " other than C you should consult the PLplot documentation for the\n"
22921 " details concerning how PLTRANSFORM_callback arguments are\n"
22922 " interfaced. However, in general, a particular pattern of\n"
22923 " callback-associated arguments such as a tr vector with 6 elements;\n"
22924 " xg and yg vectors; or xg and yg matrices are respectively\n"
22925 " interfaced to a linear-transformation routine similar to the above\n"
22926 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22927 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22928 " support native language callbacks for handling index to\n"
22929 " world-coordinate transformations. Examples of these various\n"
22930 " approaches are given in examples/<language>x09*,\n"
22931 " examples/<language>x16*, examples/<language>x20*,\n"
22932 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22933 " supported languages.\n"
22934 "\n"
22935 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22936 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22937 " externally supplied.\n"
22938 "\n"
22939 ""},
22940 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22941 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22942 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22943 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22944 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22945 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22946 "Wait for graphics input event and translate to world coordinates.\n"
22947 "\n"
22948 "DESCRIPTION:\n"
22949 "\n"
22950 " Wait for graphics input event and translate to world coordinates.\n"
22951 " Returns 0 if no translation to world coordinates is possible.\n"
22952 "\n"
22953 " This function returns 1 on success and 0 if no translation to world\n"
22954 " coordinates is possible.\n"
22955 "\n"
22956 " Redacted form: plGetCursor(gin)\n"
22957 "\n"
22958 " This function is used in examples 1 and 20.\n"
22959 "\n"
22960 "\n"
22961 "\n"
22962 "SYNOPSIS:\n"
22963 "\n"
22964 "PLINT plGetCursor(gin)\n"
22965 "\n"
22966 "ARGUMENTS:\n"
22967 "\n"
22968 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22969 " which will contain the output. The structure is not allocated by\n"
22970 " the routine and must exist before the function is called.\n"
22971 "\n"
22972 ""},
22973 { NULL, NULL, 0, NULL }
22974};
22975
22976
22977/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22978
22979static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22980static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22981static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22982static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22983static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22984static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22985static 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};
22986static 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};
22987static 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};
22988static 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};
22989static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22990static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22991static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22992static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22993
23010
23011static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23012static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
23013static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
23014static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23015static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23021static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23022static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23023static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23024static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23025
23042
23043
23044/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23045
23047{0, 0, 0, 0.0, 0, 0}};
23048
23049#ifdef __cplusplus
23050}
23051#endif
23052/* -----------------------------------------------------------------------------
23053 * Type initialization:
23054 * This problem is tough by the requirement that no dynamic
23055 * memory is used. Also, since swig_type_info structures store pointers to
23056 * swig_cast_info structures and swig_cast_info structures store pointers back
23057 * to swig_type_info structures, we need some lookup code at initialization.
23058 * The idea is that swig generates all the structures that are needed.
23059 * The runtime then collects these partially filled structures.
23060 * The SWIG_InitializeModule function takes these initial arrays out of
23061 * swig_module, and does all the lookup, filling in the swig_module.types
23062 * array with the correct data and linking the correct swig_cast_info
23063 * structures together.
23064 *
23065 * The generated swig_type_info structures are assigned statically to an initial
23066 * array. We just loop through that array, and handle each type individually.
23067 * First we lookup if this type has been already loaded, and if so, use the
23068 * loaded structure instead of the generated one. Then we have to fill in the
23069 * cast linked list. The cast data is initially stored in something like a
23070 * two-dimensional array. Each row corresponds to a type (there are the same
23071 * number of rows as there are in the swig_type_initial array). Each entry in
23072 * a column is one of the swig_cast_info structures for that type.
23073 * The cast_initial array is actually an array of arrays, because each row has
23074 * a variable number of columns. So to actually build the cast linked list,
23075 * we find the array of casts associated with the type, and loop through it
23076 * adding the casts to the list. The one last trick we need to do is making
23077 * sure the type pointer in the swig_cast_info struct is correct.
23078 *
23079 * First off, we lookup the cast->type name to see if it is already loaded.
23080 * There are three cases to handle:
23081 * 1) If the cast->type has already been loaded AND the type we are adding
23082 * casting info to has not been loaded (it is in this module), THEN we
23083 * replace the cast->type pointer with the type pointer that has already
23084 * been loaded.
23085 * 2) If BOTH types (the one we are adding casting info to, and the
23086 * cast->type) are loaded, THEN the cast info has already been loaded by
23087 * the previous module so we just ignore it.
23088 * 3) Finally, if cast->type has not already been loaded, then we add that
23089 * swig_cast_info to the linked list (because the cast->type) pointer will
23090 * be correct.
23091 * ----------------------------------------------------------------------------- */
23092
23093#ifdef __cplusplus
23094extern "C" {
23095#if 0
23096} /* c-mode */
23097#endif
23098#endif
23099
23100#if 0
23101#define SWIGRUNTIME_DEBUG
23102#endif
23103
23104#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23105#define SWIG_INIT_CLIENT_DATA_TYPE void *
23106#endif
23107
23108SWIGRUNTIME void
23110 size_t i;
23111 swig_module_info *module_head, *iter;
23112 int init;
23113
23114 /* check to see if the circular list has been setup, if not, set it up */
23115 if (swig_module.next==0) {
23116 /* Initialize the swig_module */
23117 swig_module.type_initial = swig_type_initial;
23118 swig_module.cast_initial = swig_cast_initial;
23119 swig_module.next = &swig_module;
23120 init = 1;
23121 } else {
23122 init = 0;
23123 }
23124
23125 /* Try and load any already created modules */
23126 module_head = SWIG_GetModule(clientdata);
23127 if (!module_head) {
23128 /* This is the first module loaded for this interpreter */
23129 /* so set the swig module into the interpreter */
23130 SWIG_SetModule(clientdata, &swig_module);
23131 } else {
23132 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23133 iter=module_head;
23134 do {
23135 if (iter==&swig_module) {
23136 /* Our module is already in the list, so there's nothing more to do. */
23137 return;
23138 }
23139 iter=iter->next;
23140 } while (iter!= module_head);
23141
23142 /* otherwise we must add our module into the list */
23143 swig_module.next = module_head->next;
23144 module_head->next = &swig_module;
23145 }
23146
23147 /* When multiple interpreters are used, a module could have already been initialized in
23148 a different interpreter, but not yet have a pointer in this interpreter.
23149 In this case, we do not want to continue adding types... everything should be
23150 set up already */
23151 if (init == 0) return;
23152
23153 /* Now work on filling in swig_module.types */
23154#ifdef SWIGRUNTIME_DEBUG
23155 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23156#endif
23157 for (i = 0; i < swig_module.size; ++i) {
23158 swig_type_info *type = 0;
23159 swig_type_info *ret;
23160 swig_cast_info *cast;
23161
23162#ifdef SWIGRUNTIME_DEBUG
23163 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23164#endif
23165
23166 /* if there is another module already loaded */
23167 if (swig_module.next != &swig_module) {
23168 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23169 }
23170 if (type) {
23171 /* Overwrite clientdata field */
23172#ifdef SWIGRUNTIME_DEBUG
23173 printf("SWIG_InitializeModule: found type %s\n", type->name);
23174#endif
23175 if (swig_module.type_initial[i]->clientdata) {
23176 type->clientdata = swig_module.type_initial[i]->clientdata;
23177#ifdef SWIGRUNTIME_DEBUG
23178 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23179#endif
23180 }
23181 } else {
23182 type = swig_module.type_initial[i];
23183 }
23184
23185 /* Insert casting types */
23186 cast = swig_module.cast_initial[i];
23187 while (cast->type) {
23188 /* Don't need to add information already in the list */
23189 ret = 0;
23190#ifdef SWIGRUNTIME_DEBUG
23191 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23192#endif
23193 if (swig_module.next != &swig_module) {
23195#ifdef SWIGRUNTIME_DEBUG
23196 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23197#endif
23198 }
23199 if (ret) {
23200 if (type == swig_module.type_initial[i]) {
23201#ifdef SWIGRUNTIME_DEBUG
23202 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23203#endif
23204 cast->type = ret;
23205 ret = 0;
23206 } else {
23207 /* Check for casting already in the list */
23208 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23209#ifdef SWIGRUNTIME_DEBUG
23210 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23211#endif
23212 if (!ocast) ret = 0;
23213 }
23214 }
23215
23216 if (!ret) {
23217#ifdef SWIGRUNTIME_DEBUG
23218 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23219#endif
23220 if (type->cast) {
23221 type->cast->prev = cast;
23222 cast->next = type->cast;
23223 }
23224 type->cast = cast;
23225 }
23226 cast++;
23227 }
23228 /* Set entry in modules->types array equal to the type */
23229 swig_module.types[i] = type;
23230 }
23231 swig_module.types[i] = 0;
23232
23233#ifdef SWIGRUNTIME_DEBUG
23234 printf("**** SWIG_InitializeModule: Cast List ******\n");
23235 for (i = 0; i < swig_module.size; ++i) {
23236 int j = 0;
23237 swig_cast_info *cast = swig_module.cast_initial[i];
23238 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23239 while (cast->type) {
23240 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23241 cast++;
23242 ++j;
23243 }
23244 printf("---- Total casts: %d\n",j);
23245 }
23246 printf("**** SWIG_InitializeModule: Cast List ******\n");
23247#endif
23248}
23249
23250/* This function will propagate the clientdata field of type to
23251* any new swig_type_info structures that have been added into the list
23252* of equivalent types. It is like calling
23253* SWIG_TypeClientData(type, clientdata) a second time.
23254*/
23255SWIGRUNTIME void
23257 size_t i;
23258 swig_cast_info *equiv;
23259 static int init_run = 0;
23260
23261 if (init_run) return;
23262 init_run = 1;
23263
23264 for (i = 0; i < swig_module.size; i++) {
23265 if (swig_module.types[i]->clientdata) {
23266 equiv = swig_module.types[i]->cast;
23267 while (equiv) {
23268 if (!equiv->converter) {
23269 if (equiv->type && !equiv->type->clientdata)
23270 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23271 }
23272 equiv = equiv->next;
23273 }
23274 }
23275 }
23276}
23277
23278#ifdef __cplusplus
23279#if 0
23280{
23281 /* c-mode */
23282#endif
23283}
23284#endif
23285
23286
23287
23288#ifdef __cplusplus
23289extern "C" {
23290#endif
23291
23292 /* -----------------------------------------------------------------------------
23293 * constants/methods manipulation
23294 * ----------------------------------------------------------------------------- */
23295
23296 /* Install Constants */
23297 SWIGINTERN void
23299 PyObject *obj = 0;
23300 size_t i;
23301 for (i = 0; constants[i].type; ++i) {
23302 switch(constants[i].type) {
23303 case SWIG_PY_POINTER:
23304 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23305 break;
23306 case SWIG_PY_BINARY:
23307 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23308 break;
23309 default:
23310 obj = 0;
23311 break;
23312 }
23313 if (obj) {
23314 PyDict_SetItemString(d, constants[i].name, obj);
23315 SWIG_Py_DECREF(obj);
23316 }
23317 }
23318 }
23319
23320 /* -----------------------------------------------------------------------------
23321 * Patch %callback methods' docstrings to hold the callback ptrs
23322 * -----------------------------------------------------------------------------*/
23323
23324 SWIGINTERN void
23325 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23326 size_t i;
23327 for (i = 0; methods[i].ml_name; ++i) {
23328 const char *c = methods[i].ml_doc;
23329 if (!c) continue;
23330 c = strstr(c, "swig_ptr: ");
23331 if (c) {
23332 int j;
23333 const swig_const_info *ci = 0;
23334 const char *name = c + 10;
23335 for (j = 0; const_table[j].type; ++j) {
23336 if (strncmp(const_table[j].name, name,
23337 strlen(const_table[j].name)) == 0) {
23338 ci = &(const_table[j]);
23339 break;
23340 }
23341 }
23342 if (ci) {
23343 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23344 if (ptr) {
23345 size_t shift = (ci->ptype) - types;
23346 swig_type_info *ty = types_initial[shift];
23347 size_t ldoc = (c - methods[i].ml_doc);
23348 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23349 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23350 if (ndoc) {
23351 char *buff = ndoc;
23352 memcpy(buff, methods[i].ml_doc, ldoc);
23353 buff += ldoc;
23354 memcpy(buff, "swig_ptr: ", 10);
23355 buff += 10;
23356 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23357 methods[i].ml_doc = ndoc;
23358 }
23359 }
23360 }
23361 }
23362 }
23363 }
23364
23365#ifdef __cplusplus
23366}
23367#endif
23368
23369
23370
23371
23372/* -----------------------------------------------------------------------------*
23373 * Partial Init method
23374 * -----------------------------------------------------------------------------*/
23375
23376#ifdef __cplusplus
23377extern "C"
23378#endif
23379
23381#if PY_VERSION_HEX >= 0x03000000
23382PyObject*
23383#else
23384void
23385#endif
23387 PyObject *m, *d, *md, *globals;
23388
23389#if PY_VERSION_HEX >= 0x03000000
23390 static struct PyModuleDef SWIG_module = {
23391 PyModuleDef_HEAD_INIT,
23392 SWIG_name,
23393 NULL,
23394 -1,
23396 NULL,
23397 NULL,
23398 NULL,
23399 NULL
23400 };
23401#endif
23402
23403#if defined(SWIGPYTHON_BUILTIN)
23404 static SwigPyClientData SwigPyObject_clientdata = {
23405 0, 0, 0, 0, 0, 0, 0
23406 };
23407 static PyGetSetDef this_getset_def = {
23408 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23409 };
23410 static SwigPyGetSet thisown_getset_closure = {
23413 };
23414 static PyGetSetDef thisown_getset_def = {
23415 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23416 };
23417 PyTypeObject *builtin_pytype;
23418 int builtin_base_count;
23419 swig_type_info *builtin_basetype;
23420 PyObject *tuple;
23421 PyGetSetDescrObject *static_getset;
23422 PyTypeObject *metatype;
23423 PyTypeObject *swigpyobject;
23424 SwigPyClientData *cd;
23425 PyObject *public_interface, *public_symbol;
23426 PyObject *this_descr;
23427 PyObject *thisown_descr;
23428 PyObject *self = 0;
23429 int i;
23430
23431 (void)builtin_pytype;
23432 (void)builtin_base_count;
23433 (void)builtin_basetype;
23434 (void)tuple;
23435 (void)static_getset;
23436 (void)self;
23437
23438 /* Metaclass is used to implement static member variables */
23439 metatype = SwigPyObjectType();
23440 assert(metatype);
23441#endif
23442
23443 (void)globals;
23444
23445 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23446 SWIG_This();
23449#ifndef SWIGPYTHON_BUILTIN
23451#endif
23452
23453 /* Fix SwigMethods to carry the callback ptrs when needed */
23455
23456#if PY_VERSION_HEX >= 0x03000000
23457 m = PyModule_Create(&SWIG_module);
23458#else
23459 m = Py_InitModule(SWIG_name, SwigMethods);
23460#endif
23461
23462 md = d = PyModule_GetDict(m);
23463 (void)md;
23464
23466
23467#ifdef SWIGPYTHON_BUILTIN
23468 swigpyobject = SwigPyObject_TypeOnce();
23469
23470 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23471 assert(SwigPyObject_stype);
23472 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23473 if (!cd) {
23474 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23475 SwigPyObject_clientdata.pytype = swigpyobject;
23476 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23477 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23478# if PY_VERSION_HEX >= 0x03000000
23479 return NULL;
23480# else
23481 return;
23482# endif
23483 }
23484
23485 /* All objects have a 'this' attribute */
23486 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23487 (void)this_descr;
23488
23489 /* All objects have a 'thisown' attribute */
23490 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23491 (void)thisown_descr;
23492
23493 public_interface = PyList_New(0);
23494 public_symbol = 0;
23495 (void)public_symbol;
23496
23497 PyDict_SetItemString(md, "__all__", public_interface);
23498 SWIG_Py_DECREF(public_interface);
23499 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23500 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23501 for (i = 0; swig_const_table[i].name != 0; ++i)
23502 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23503#endif
23504
23506
23507
23508 import_array();
23509
23510 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23511 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23512 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23513 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23514 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23515 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23516 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23517 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23518 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23519 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23520 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23521 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23522 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23523 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23524 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23525 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23526 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23527 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23528 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23529 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23530 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23531 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23532 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23533 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23534 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23535 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23536 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23537 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23538 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23539 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23540 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23541 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23542 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23543 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23544 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23545 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23546 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23547 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23548 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23549 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23550 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23551 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23552 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23553 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23554 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23555 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23556 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23557 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23558 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23559 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23560 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23561 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23562 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23563 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23564 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23565 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23566 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23567 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23568 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23569 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23570 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23571 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23572 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23573 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23574 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23575 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23576 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23577 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23578 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23579 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23580 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23581 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23582 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23583 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23584 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23585 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23586 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23587 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23588 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23589 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23590 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23591 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23592 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23593 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23594 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23595 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23596 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23597 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23598 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23599 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23600 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23601 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23602 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23603 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23604 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23605 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23606 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23607 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23608 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23609 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23610 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23611 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23612 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23613 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23614 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23615 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23616 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23617 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23618 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23619 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23620 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23621 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23622 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23623 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23624 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23625 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23626 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23627 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23628 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23629 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23630 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23631 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23632 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23633 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23634 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23635 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23636 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23637 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23638 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23639 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23640 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23641 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23642 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23643 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23644 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23645 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23646 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23647 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23648 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23649 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23650 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23651 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23652 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23653 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23654 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23655 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23656 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23657 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23658 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23659 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23660 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23661 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23662 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23663 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23664 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23665 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23666 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23667 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23668 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23669 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23670 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23671 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23672 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23673 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23674 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23675 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23676 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23677 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23678 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23679 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23680 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23681 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23682 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23683 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23684 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23685 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23686 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23687 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23688 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23689 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23690 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23691 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23692 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23693 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23694 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23695#if PY_VERSION_HEX >= 0x03000000
23696 return m;
23697#else
23698 return;
23699#endif
23700}
23701
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_Py_XDECREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_Py_XINCREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
#define SWIG_Py_DECREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
#define SWIG_Py_INCREF
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj, int is_void)
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
static swig_cast_info * swig_cast_initial[]
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
static int _wrap_plend(lua_State *L)
#define SWIG_POINTER_OWN
#define SWIG_SyntaxError
static swig_cast_info _swigc__p_f_double_double__int[]
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
static PLINT Alen
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
static int _wrap_plGetCursor(lua_State *L)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
#define SWIG_RuntimeError
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
#define SWIGRUNTIME
#define SWIG_RUNTIME_VERSION
#define SWIG_OLDOBJ
#define SWIG_ValueError
static int _wrap_new_PLGraphicsIn(lua_State *L)
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
static swig_type_info * swig_types[13]
static int _wrap_plResetOpts(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static int _wrap_plot3dcl(lua_State *L)
static int _wrap_plOptUsage(lua_State *L)
static swig_module_info swig_module
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
static PLINT Ylen
static swig_type_info _swigt__p_double
#define SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_POINTER_RELEASE
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
static swig_type_info _swigt__p_p_char
static int _wrap_plend1(lua_State *L)
static swig_type_info _swigt__p_p_double
#define SWIG_POINTER_CLEAR
#define SWIGTYPE_p_int
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int _wrap_plClearOpts(lua_State *L)
static swig_cast_info _swigc__p_char[]
static int _wrap_plot3d(lua_State *L)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define SWIG_POINTER_NO_NULL
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_IOError
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
static swig_type_info _swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_f_double_double__int
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
static int _wrap_plot3dc(lua_State *L)
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
#define SWIG_NEWOBJ
#define SWIG_TMPOBJ
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static int _wrap_plSetUsage(lua_State *L)
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
#define SWIG_ERROR_RELEASE_NOT_OWNED
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
#define SWIG_ERROR
#define SWIG_name
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
static swig_type_info * swig_type_initial[]
static swig_cast_info _swigc__p_PLGraphicsIn[]
static swig_cast_info _swigc__p_p_char[]
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
#define SWIG_MemoryError
#define SWIG_SystemError
#define SWIG_DivisionByZero
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
#define SWIG_OverflowError
#define SWIGEXPORT
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_IndexError
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
#define SWIG_OK
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
#define SWIGINTERNINLINE
#define SWIGRUNTIMEINLINE
char string[PL_MAXKEY]
Definition plplot.h:440
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135