PLplot 5.15.0
Loading...
Searching...
No Matches
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.3.0
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040300
11#define SWIGPYTHON
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14#define SWIG_name "_plplotc"
15/* -----------------------------------------------------------------------------
16 * This section contains generic SWIG labels for method/variable
17 * declarations/attributes, and other compiler dependent labels.
18 * ----------------------------------------------------------------------------- */
19
20/* template workaround for compilers that cannot correctly implement the C++ standard */
21#ifndef SWIGTEMPLATEDISAMBIGUATOR
22# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
23# define SWIGTEMPLATEDISAMBIGUATOR template
24# elif defined(__HP_aCC)
25/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
26/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
27# define SWIGTEMPLATEDISAMBIGUATOR template
28# else
29# define SWIGTEMPLATEDISAMBIGUATOR
30# endif
31#endif
32
33/* inline attribute */
34#ifndef SWIGINLINE
35# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
36# define SWIGINLINE inline
37# else
38# define SWIGINLINE
39# endif
40#endif
41
42/* attribute recognised by some compilers to avoid 'unused' warnings */
43#ifndef SWIGUNUSED
44# if defined(__GNUC__)
45# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46# define SWIGUNUSED __attribute__ ((__unused__))
47# else
48# define SWIGUNUSED
49# endif
50# elif defined(__ICC)
51# define SWIGUNUSED __attribute__ ((__unused__))
52# else
53# define SWIGUNUSED
54# endif
55#endif
56
57#ifndef SWIG_MSC_UNSUPPRESS_4505
58# if defined(_MSC_VER)
59# pragma warning(disable : 4505) /* unreferenced local function has been removed */
60# endif
61#endif
62
63#ifndef SWIGUNUSEDPARM
64# ifdef __cplusplus
65# define SWIGUNUSEDPARM(p)
66# else
67# define SWIGUNUSEDPARM(p) p SWIGUNUSED
68# endif
69#endif
70
71/* internal SWIG method */
72#ifndef SWIGINTERN
73# define SWIGINTERN static SWIGUNUSED
74#endif
75
76/* internal inline SWIG method */
77#ifndef SWIGINTERNINLINE
78# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
79#endif
80
81/* exporting methods */
82#if defined(__GNUC__)
83# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
84# ifndef GCC_HASCLASSVISIBILITY
85# define GCC_HASCLASSVISIBILITY
86# endif
87# endif
88#endif
89
90#ifndef SWIGEXPORT
91# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
92# if defined(STATIC_LINKED)
93# define SWIGEXPORT
94# else
95# define SWIGEXPORT __declspec(dllexport)
96# endif
97# else
98# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
99# define SWIGEXPORT __attribute__ ((visibility("default")))
100# else
101# define SWIGEXPORT
102# endif
103# endif
104#endif
105
106/* calling conventions for Windows */
107#ifndef SWIGSTDCALL
108# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
109# define SWIGSTDCALL __stdcall
110# else
111# define SWIGSTDCALL
112# endif
113#endif
114
115/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
116#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
117# define _CRT_SECURE_NO_DEPRECATE
118#endif
119
120/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
121#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
122# define _SCL_SECURE_NO_DEPRECATE
123#endif
124
125/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
126#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
127# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
128#endif
129
130/* Intel's compiler complains if a variable which was never initialised is
131 * cast to void, which is a common idiom which we use to indicate that we
132 * are aware a variable isn't used. So we just silence that warning.
133 * See: https://github.com/swig/swig/issues/192 for more discussion.
134 */
135#ifdef __INTEL_COMPILER
136# pragma warning disable 592
137#endif
138
139#if defined(__cplusplus) && __cplusplus >=201103L
140# define SWIG_NULLPTR nullptr
141#else
142# define SWIG_NULLPTR NULL
143#endif
144
145/* -----------------------------------------------------------------------------
146 * swigcompat.swg
147 *
148 * Macros to provide support compatibility with older C and C++ standards.
149 *
150 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
151 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
152 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
153 * ----------------------------------------------------------------------------- */
154
155/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
156 * if you're missing it.
157 */
158#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
159 (defined __cplusplus && __cplusplus >= 201103L) || \
160 defined SWIG_HAVE_SNPRINTF) && \
161 !defined SWIG_NO_SNPRINTF
162# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
163# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
164#else
165/* Fallback versions ignore the buffer size, but most of our uses either have a
166 * fixed maximum possible size or dynamically allocate a buffer that's large
167 * enough.
168 */
169# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
170# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
171#endif
172
173
174#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
175/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
176# include <math.h>
177#endif
178
179#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
180#define PY_SSIZE_T_CLEAN
181#endif
182
183#if __GNUC__ >= 7
184#pragma GCC diagnostic push
185#if defined(__cplusplus) && __cplusplus >=201703L
186#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
187#endif
188#endif
189
190#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
191/* Use debug wrappers with the Python release dll */
192
193#if defined(_MSC_VER) && _MSC_VER >= 1929
194/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
195 * See https://github.com/swig/swig/issues/2090 */
196# include <corecrt.h>
197#endif
198
199# undef _DEBUG
200# include <Python.h>
201# define _DEBUG 1
202#else
203# include <Python.h>
204#endif
205#include <structmember.h>
206
207#if __GNUC__ >= 7
208#pragma GCC diagnostic pop
209#endif
210
211#include <stdio.h>
212#include <stdlib.h>
213
214/* -----------------------------------------------------------------------------
215 * swigrun.swg
216 *
217 * This file contains generic C API SWIG runtime support for pointer
218 * type checking.
219 * ----------------------------------------------------------------------------- */
220
221/* This should only be incremented when either the layout of swig_type_info changes,
222 or for whatever reason, the runtime changes incompatibly */
223#define SWIG_RUNTIME_VERSION "4"
224
225/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
226#ifdef SWIG_TYPE_TABLE
227# define SWIG_QUOTE_STRING(x) #x
228# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
229# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
230#else
231# define SWIG_TYPE_TABLE_NAME
232#endif
233
234/*
235 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
236 creating a static or dynamic library from the SWIG runtime code.
237 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
238
239 But only do this if strictly necessary, ie, if you have problems
240 with your compiler or suchlike.
241*/
242
243#ifndef SWIGRUNTIME
244# define SWIGRUNTIME SWIGINTERN
245#endif
246
247#ifndef SWIGRUNTIMEINLINE
248# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
249#endif
250
251/* Generic buffer size */
252#ifndef SWIG_BUFFER_SIZE
253# define SWIG_BUFFER_SIZE 1024
254#endif
255
256/* Flags for pointer conversions */
257#define SWIG_POINTER_DISOWN 0x1
258#define SWIG_CAST_NEW_MEMORY 0x2
259#define SWIG_POINTER_NO_NULL 0x4
260#define SWIG_POINTER_CLEAR 0x8
261#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
262
263/* Flags for new pointer objects */
264#define SWIG_POINTER_OWN 0x1
265
266
267/*
268 Flags/methods for returning states.
269
270 The SWIG conversion methods, as ConvertPtr, return an integer
271 that tells if the conversion was successful or not. And if not,
272 an error code can be returned (see swigerrors.swg for the codes).
273
274 Use the following macros/flags to set or process the returning
275 states.
276
277 In old versions of SWIG, code such as the following was usually written:
278
279 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
280 // success code
281 } else {
282 //fail code
283 }
284
285 Now you can be more explicit:
286
287 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
288 if (SWIG_IsOK(res)) {
289 // success code
290 } else {
291 // fail code
292 }
293
294 which is the same really, but now you can also do
295
296 Type *ptr;
297 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
298 if (SWIG_IsOK(res)) {
299 // success code
300 if (SWIG_IsNewObj(res) {
301 ...
302 delete *ptr;
303 } else {
304 ...
305 }
306 } else {
307 // fail code
308 }
309
310 I.e., now SWIG_ConvertPtr can return new objects and you can
311 identify the case and take care of the deallocation. Of course that
312 also requires SWIG_ConvertPtr to return new result values, such as
313
314 int SWIG_ConvertPtr(obj, ptr,...) {
315 if (<obj is ok>) {
316 if (<need new object>) {
317 *ptr = <ptr to new allocated object>;
318 return SWIG_NEWOBJ;
319 } else {
320 *ptr = <ptr to old object>;
321 return SWIG_OLDOBJ;
322 }
323 } else {
324 return SWIG_BADOBJ;
325 }
326 }
327
328 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
329 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
330 SWIG errors code.
331
332 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
333 allows returning the 'cast rank', for example, if you have this
334
335 int food(double)
336 int fooi(int);
337
338 and you call
339
340 food(1) // cast rank '1' (1 -> 1.0)
341 fooi(1) // cast rank '0'
342
343 just use the SWIG_AddCast()/SWIG_CheckState()
344*/
345
346#define SWIG_OK (0)
347/* Runtime errors are < 0 */
348#define SWIG_ERROR (-1)
349/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
350/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
351/* Errors < -200 are generic runtime specific errors */
352#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
353
354#define SWIG_IsOK(r) (r >= 0)
355#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
356
357/* The CastRankLimit says how many bits are used for the cast rank */
358#define SWIG_CASTRANKLIMIT (1 << 8)
359/* The NewMask denotes the object was created (using new/malloc) */
360#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
361/* The TmpMask is for in/out typemaps that use temporary objects */
362#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
363/* Simple returning values */
364#define SWIG_BADOBJ (SWIG_ERROR)
365#define SWIG_OLDOBJ (SWIG_OK)
366#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
367#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
368/* Check, add and del object mask methods */
369#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
370#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
371#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
372#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
373#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
374#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
375
376/* Cast-Rank Mode */
377#if defined(SWIG_CASTRANK_MODE)
378# ifndef SWIG_TypeRank
379# define SWIG_TypeRank unsigned long
380# endif
381# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
382# define SWIG_MAXCASTRANK (2)
383# endif
384# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
385# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
387 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
388}
390 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
391}
392#else /* no cast-rank mode */
393# define SWIG_AddCast(r) (r)
394# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
395#endif
396
397
398#include <string.h>
399
400#ifdef __cplusplus
401extern "C" {
402#endif
403
404typedef void *(*swig_converter_func)(void *, int *);
405typedef struct swig_type_info *(*swig_dycast_func)(void **);
406
407/* Structure to store information on one type */
408typedef struct swig_type_info {
409 const char *name; /* mangled name of this type */
410 const char *str; /* human readable name of this type */
411 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
412 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
413 void *clientdata; /* language specific type data */
414 int owndata; /* flag if the structure owns the clientdata */
416
417/* Structure to store a type and conversion function used for casting */
418typedef struct swig_cast_info {
419 swig_type_info *type; /* pointer to type that is equivalent to this type */
420 swig_converter_func converter; /* function to cast the void pointers */
421 struct swig_cast_info *next; /* pointer to next cast in linked list */
422 struct swig_cast_info *prev; /* pointer to the previous cast */
424
425/* Structure used to store module information
426 * Each module generates one structure like this, and the runtime collects
427 * all of these structures and stores them in a circularly linked list.*/
428typedef struct swig_module_info {
429 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
430 size_t size; /* Number of types in this module */
431 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
432 swig_type_info **type_initial; /* Array of initially generated type structures */
433 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
434 void *clientdata; /* Language specific module data */
436
437/*
438 Compare two type names skipping the space characters, therefore
439 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
440
441 Return 0 when the two name types are equivalent, as in
442 strncmp, but skipping ' '.
443*/
444SWIGRUNTIME int
445SWIG_TypeNameComp(const char *f1, const char *l1,
446 const char *f2, const char *l2) {
447 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
448 while ((*f1 == ' ') && (f1 != l1)) ++f1;
449 while ((*f2 == ' ') && (f2 != l2)) ++f2;
450 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
451 }
452 return (int)((l1 - f1) - (l2 - f2));
453}
454
455/*
456 Check type equivalence in a name list like <name1>|<name2>|...
457 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
458*/
459SWIGRUNTIME int
460SWIG_TypeCmp(const char *nb, const char *tb) {
461 int equiv = 1;
462 const char* te = tb + strlen(tb);
463 const char* ne = nb;
464 while (equiv != 0 && *ne) {
465 for (nb = ne; *ne; ++ne) {
466 if (*ne == '|') break;
467 }
468 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
469 if (*ne) ++ne;
470 }
471 return equiv;
472}
473
474/*
475 Check type equivalence in a name list like <name1>|<name2>|...
476 Return 0 if not equal, 1 if equal
477*/
478SWIGRUNTIME int
479SWIG_TypeEquiv(const char *nb, const char *tb) {
480 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
481}
482
483/*
484 Check the typename
485*/
487SWIG_TypeCheck(const char *c, swig_type_info *ty) {
488 if (ty) {
489 swig_cast_info *iter = ty->cast;
490 while (iter) {
491 if (strcmp(iter->type->name, c) == 0) {
492 if (iter == ty->cast)
493 return iter;
494 /* Move iter to the top of the linked list */
495 iter->prev->next = iter->next;
496 if (iter->next)
497 iter->next->prev = iter->prev;
498 iter->next = ty->cast;
499 iter->prev = 0;
500 if (ty->cast) ty->cast->prev = iter;
501 ty->cast = iter;
502 return iter;
503 }
504 iter = iter->next;
505 }
506 }
507 return 0;
508}
509
510/*
511 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
512*/
515 if (ty) {
516 swig_cast_info *iter = ty->cast;
517 while (iter) {
518 if (iter->type == from) {
519 if (iter == ty->cast)
520 return iter;
521 /* Move iter to the top of the linked list */
522 iter->prev->next = iter->next;
523 if (iter->next)
524 iter->next->prev = iter->prev;
525 iter->next = ty->cast;
526 iter->prev = 0;
527 if (ty->cast) ty->cast->prev = iter;
528 ty->cast = iter;
529 return iter;
530 }
531 iter = iter->next;
532 }
533 }
534 return 0;
535}
536
537/*
538 Cast a pointer up an inheritance hierarchy
539*/
541SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
542 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
543}
544
545/*
546 Dynamic pointer casting. Down an inheritance hierarchy
547*/
550 swig_type_info *lastty = ty;
551 if (!ty || !ty->dcast) return ty;
552 while (ty && (ty->dcast)) {
553 ty = (*ty->dcast)(ptr);
554 if (ty) lastty = ty;
555 }
556 return lastty;
557}
558
559/*
560 Return the name associated with this type
561*/
562SWIGRUNTIMEINLINE const char *
564 return ty->name;
565}
566
567/*
568 Return the pretty name associated with this type,
569 that is an unmangled type name in a form presentable to the user.
570*/
571SWIGRUNTIME const char *
573 /* The "str" field contains the equivalent pretty names of the
574 type, separated by vertical-bar characters. Choose the last
575 name. It should be the most specific; a fully resolved name
576 but not necessarily with default template parameters expanded. */
577 if (!type) return NULL;
578 if (type->str != NULL) {
579 const char *last_name = type->str;
580 const char *s;
581 for (s = type->str; *s; s++)
582 if (*s == '|') last_name = s+1;
583 return last_name;
584 }
585 else
586 return type->name;
587}
588
589/*
590 Set the clientdata field for a type
591*/
592SWIGRUNTIME void
594 swig_cast_info *cast = ti->cast;
595 /* if (ti->clientdata == clientdata) return; */
597
598 while (cast) {
599 if (!cast->converter) {
600 swig_type_info *tc = cast->type;
601 if (!tc->clientdata) {
603 }
604 }
605 cast = cast->next;
606 }
607}
608SWIGRUNTIME void
613
614/*
615 Search for a swig_type_info structure only by mangled name
616 Search is a O(log #types)
617
618 We start searching at module start, and finish searching when start == end.
619 Note: if start == end at the beginning of the function, we go all the way around
620 the circular list.
621*/
624 swig_module_info *end,
625 const char *name) {
626 swig_module_info *iter = start;
627 do {
628 if (iter->size) {
629 size_t l = 0;
630 size_t r = iter->size - 1;
631 do {
632 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
633 size_t i = (l + r) >> 1;
634 const char *iname = iter->types[i]->name;
635 if (iname) {
636 int compare = strcmp(name, iname);
637 if (compare == 0) {
638 return iter->types[i];
639 } else if (compare < 0) {
640 if (i) {
641 r = i - 1;
642 } else {
643 break;
644 }
645 } else if (compare > 0) {
646 l = i + 1;
647 }
648 } else {
649 break; /* should never happen */
650 }
651 } while (l <= r);
652 }
653 iter = iter->next;
654 } while (iter != end);
655 return 0;
656}
657
658/*
659 Search for a swig_type_info structure for either a mangled name or a human readable name.
660 It first searches the mangled names of the types, which is a O(log #types)
661 If a type is not found it then searches the human readable names, which is O(#types).
662
663 We start searching at module start, and finish searching when start == end.
664 Note: if start == end at the beginning of the function, we go all the way around
665 the circular list.
666*/
669 swig_module_info *end,
670 const char *name) {
671 /* STEP 1: Search the name field using binary search */
673 if (ret) {
674 return ret;
675 } else {
676 /* STEP 2: If the type hasn't been found, do a complete search
677 of the str field (the human readable name) */
678 swig_module_info *iter = start;
679 do {
680 size_t i = 0;
681 for (; i < iter->size; ++i) {
682 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
683 return iter->types[i];
684 }
685 iter = iter->next;
686 } while (iter != end);
687 }
688
689 /* neither found a match */
690 return 0;
691}
692
693/*
694 Pack binary data into a string
695*/
696SWIGRUNTIME char *
697SWIG_PackData(char *c, void *ptr, size_t sz) {
698 static const char hex[17] = "0123456789abcdef";
699 const unsigned char *u = (unsigned char *) ptr;
700 const unsigned char *eu = u + sz;
701 for (; u != eu; ++u) {
702 unsigned char uu = *u;
703 *(c++) = hex[(uu & 0xf0) >> 4];
704 *(c++) = hex[uu & 0xf];
705 }
706 return c;
707}
708
709/*
710 Unpack binary data from a string
711*/
712SWIGRUNTIME const char *
713SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
714 unsigned char *u = (unsigned char *) ptr;
715 const unsigned char *eu = u + sz;
716 for (; u != eu; ++u) {
717 char d = *(c++);
718 unsigned char uu;
719 if ((d >= '0') && (d <= '9'))
720 uu = (unsigned char)((d - '0') << 4);
721 else if ((d >= 'a') && (d <= 'f'))
722 uu = (unsigned char)((d - ('a'-10)) << 4);
723 else
724 return (char *) 0;
725 d = *(c++);
726 if ((d >= '0') && (d <= '9'))
727 uu |= (unsigned char)(d - '0');
728 else if ((d >= 'a') && (d <= 'f'))
729 uu |= (unsigned char)(d - ('a'-10));
730 else
731 return (char *) 0;
732 *u = uu;
733 }
734 return c;
735}
736
737/*
738 Pack 'void *' into a string buffer.
739*/
740SWIGRUNTIME char *
741SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
742 char *r = buff;
743 if ((2*sizeof(void *) + 2) > bsz) return 0;
744 *(r++) = '_';
745 r = SWIG_PackData(r,&ptr,sizeof(void *));
746 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
747 strcpy(r,name);
748 return buff;
749}
750
751SWIGRUNTIME const char *
752SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
753 if (*c != '_') {
754 if (strcmp(c,"NULL") == 0) {
755 *ptr = (void *) 0;
756 return name;
757 } else {
758 return 0;
759 }
760 }
761 return SWIG_UnpackData(++c,ptr,sizeof(void *));
762}
763
764SWIGRUNTIME char *
765SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
766 char *r = buff;
767 size_t lname = (name ? strlen(name) : 0);
768 if ((2*sz + 2 + lname) > bsz) return 0;
769 *(r++) = '_';
770 r = SWIG_PackData(r,ptr,sz);
771 if (lname) {
772 strncpy(r,name,lname+1);
773 } else {
774 *r = 0;
775 }
776 return buff;
777}
778
779SWIGRUNTIME const char *
780SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
781 if (*c != '_') {
782 if (strcmp(c,"NULL") == 0) {
783 memset(ptr,0,sz);
784 return name;
785 } else {
786 return 0;
787 }
788 }
789 return SWIG_UnpackData(++c,ptr,sz);
790}
791
792#ifdef __cplusplus
793}
794#endif
795
796/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
797#define SWIG_UnknownError -1
798#define SWIG_IOError -2
799#define SWIG_RuntimeError -3
800#define SWIG_IndexError -4
801#define SWIG_TypeError -5
802#define SWIG_DivisionByZero -6
803#define SWIG_OverflowError -7
804#define SWIG_SyntaxError -8
805#define SWIG_ValueError -9
806#define SWIG_SystemError -10
807#define SWIG_AttributeError -11
808#define SWIG_MemoryError -12
809#define SWIG_NullReferenceError -13
810
811
812/* Compatibility macros for Python 3 */
813#if PY_VERSION_HEX >= 0x03000000
814
815#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
816#define PyInt_Check(x) PyLong_Check(x)
817#define PyInt_AsLong(x) PyLong_AsLong(x)
818#define PyInt_FromLong(x) PyLong_FromLong(x)
819#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
820#define PyString_Check(name) PyBytes_Check(name)
821#define PyString_FromString(x) PyUnicode_FromString(x)
822#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
823#define PyString_AsString(str) PyBytes_AsString(str)
824#define PyString_Size(str) PyBytes_Size(str)
825#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
826#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
827#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
828
829#endif
830
831/* SWIG APIs for compatibility of both Python 2 & 3 */
832
833#if PY_VERSION_HEX >= 0x03000000
834# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
835#else
836# define SWIG_Python_str_FromFormat PyString_FromFormat
837#endif
838
839
840/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
841SWIGINTERN const char *
842SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
843{
844#if PY_VERSION_HEX >= 0x03030000
845# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
846 *pbytes = NULL;
847 return PyUnicode_AsUTF8AndSize(str, psize);
848# else
849 const char *chars;
850 *pbytes = PyUnicode_AsUTF8String(str);
851 chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
852 if (chars && psize)
853 *psize = PyBytes_Size(*pbytes);
854 return chars;
855# endif
856#else
857 char *chars = NULL;
858 *pbytes = NULL;
859 PyString_AsStringAndSize(str, &chars, psize);
860 return chars;
861#endif
862}
863
864SWIGINTERN PyObject*
866{
867#if PY_VERSION_HEX >= 0x03000000
868 return PyUnicode_FromString(c);
869#else
870 return PyString_FromString(c);
871#endif
872}
873
874/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
875# define SWIGPY_USE_CAPSULE
876#ifdef SWIGPYTHON_BUILTIN
877# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
878#else
879# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
880#endif
881# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
882
883#if PY_VERSION_HEX < 0x03020000
884#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
885#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
886#define Py_hash_t long
887#endif
888
889#ifdef Py_LIMITED_API
890# define PyTuple_GET_ITEM PyTuple_GetItem
891/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
892 interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
893# define PyTuple_SET_ITEM PyTuple_SetItem
894# define PyTuple_GET_SIZE PyTuple_Size
895# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
896# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
897# define PyCFunction_GET_SELF PyCFunction_GetSelf
898# define PyList_GET_ITEM PyList_GetItem
899# define PyList_SET_ITEM PyList_SetItem
900# define PySliceObject PyObject
901#endif
902
903/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
904#ifdef Py_LIMITED_API
905# define SWIG_Py_INCREF Py_IncRef
906# define SWIG_Py_XINCREF Py_IncRef
907# define SWIG_Py_DECREF Py_DecRef
908# define SWIG_Py_XDECREF Py_DecRef
909#else
910# define SWIG_Py_INCREF Py_INCREF
911# define SWIG_Py_XINCREF Py_XINCREF
912# define SWIG_Py_DECREF Py_DECREF
913# define SWIG_Py_XDECREF Py_XDECREF
914#endif
915
916/* -----------------------------------------------------------------------------
917 * error manipulation
918 * ----------------------------------------------------------------------------- */
919
920SWIGRUNTIME PyObject*
922 PyObject* type = 0;
923 switch(code) {
924 case SWIG_MemoryError:
925 type = PyExc_MemoryError;
926 break;
927 case SWIG_IOError:
928 type = PyExc_IOError;
929 break;
931 type = PyExc_RuntimeError;
932 break;
933 case SWIG_IndexError:
934 type = PyExc_IndexError;
935 break;
936 case SWIG_TypeError:
937 type = PyExc_TypeError;
938 break;
940 type = PyExc_ZeroDivisionError;
941 break;
943 type = PyExc_OverflowError;
944 break;
945 case SWIG_SyntaxError:
946 type = PyExc_SyntaxError;
947 break;
948 case SWIG_ValueError:
949 type = PyExc_ValueError;
950 break;
951 case SWIG_SystemError:
952 type = PyExc_SystemError;
953 break;
955 type = PyExc_AttributeError;
956 break;
958 type = PyExc_TypeError;
959 break;
960 default:
961 type = PyExc_RuntimeError;
962 }
963 return type;
964}
965
966
967SWIGRUNTIME void
968SWIG_Python_AddErrorMsg(const char* mesg)
969{
970 PyObject *type = 0;
971 PyObject *value = 0;
972 PyObject *traceback = 0;
973
974 if (PyErr_Occurred())
975 PyErr_Fetch(&type, &value, &traceback);
976 if (value) {
977 PyObject *old_str = PyObject_Str(value);
978 PyObject *bytes = NULL;
979 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
980 PyErr_Clear();
981 SWIG_Py_XINCREF(type);
982 if (tmp)
983 PyErr_Format(type, "%s %s", tmp, mesg);
984 else
985 PyErr_Format(type, "%s", mesg);
986 SWIG_Py_XDECREF(bytes);
987 SWIG_Py_DECREF(old_str);
989 } else {
990 PyErr_SetString(PyExc_RuntimeError, mesg);
991 }
992}
993
994SWIGRUNTIME int
996{
997 PyObject *error;
998 if (obj)
999 return 0;
1000 error = PyErr_Occurred();
1001 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
1002}
1003
1004SWIGRUNTIME void
1006{
1008 /* Use existing TypeError to preserve stacktrace and enhance with given message */
1009 PyObject *newvalue;
1010 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1011 PyErr_Fetch(&type, &value, &traceback);
1012#if PY_VERSION_HEX >= 0x03000000
1013 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
1014#else
1015 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
1016#endif
1017 if (newvalue) {
1019 PyErr_Restore(type, newvalue, traceback);
1020 } else {
1021 PyErr_Restore(type, value, traceback);
1022 }
1023 } else {
1024 /* Raise TypeError using given message */
1025 PyErr_SetString(PyExc_TypeError, message);
1026 }
1027}
1028
1029#if defined(SWIG_PYTHON_NO_THREADS)
1030# if defined(SWIG_PYTHON_THREADS)
1031# undef SWIG_PYTHON_THREADS
1032# endif
1033#endif
1034#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1035# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1036# define SWIG_PYTHON_USE_GIL
1037# endif
1038# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1039# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1040# if PY_VERSION_HEX < 0x03070000
1041# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1042# else
1043# define SWIG_PYTHON_INITIALIZE_THREADS
1044# endif
1045# endif
1046# ifdef __cplusplus /* C++ code */
1047 class SWIG_Python_Thread_Block {
1048 bool status;
1049 PyGILState_STATE state;
1050 public:
1051 void end() { if (status) { PyGILState_Release(state); status = false;} }
1052 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1053 ~SWIG_Python_Thread_Block() { end(); }
1054 };
1055 class SWIG_Python_Thread_Allow {
1056 bool status;
1057 PyThreadState *save;
1058 public:
1059 void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
1060 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1061 ~SWIG_Python_Thread_Allow() { end(); }
1062 };
1063# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1064# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1065# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1066# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1067# else /* C code */
1068# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1069# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1070# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1071# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1072# endif
1073# else /* Old thread way, not implemented, user must provide it */
1074# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1075# define SWIG_PYTHON_INITIALIZE_THREADS
1076# endif
1077# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1078# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1079# endif
1080# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1081# define SWIG_PYTHON_THREAD_END_BLOCK
1082# endif
1083# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1084# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1085# endif
1086# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1087# define SWIG_PYTHON_THREAD_END_ALLOW
1088# endif
1089# endif
1090#else /* No thread support */
1091# define SWIG_PYTHON_INITIALIZE_THREADS
1092# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1093# define SWIG_PYTHON_THREAD_END_BLOCK
1094# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1095# define SWIG_PYTHON_THREAD_END_ALLOW
1096#endif
1097
1098/* -----------------------------------------------------------------------------
1099 * Python API portion that goes into the runtime
1100 * ----------------------------------------------------------------------------- */
1101
1102#ifdef __cplusplus
1103extern "C" {
1104#endif
1105
1106/* -----------------------------------------------------------------------------
1107 * Constant declarations
1108 * ----------------------------------------------------------------------------- */
1109
1110/* Constant Types */
1111#define SWIG_PY_POINTER 4
1112#define SWIG_PY_BINARY 5
1113
1114/* Constant information structure */
1123
1124#ifdef __cplusplus
1125}
1126#endif
1127
1128
1129/* -----------------------------------------------------------------------------
1130 * pyrun.swg
1131 *
1132 * This file contains the runtime support for Python modules
1133 * and includes code for managing global variables and pointer
1134 * type checking.
1135 *
1136 * ----------------------------------------------------------------------------- */
1137
1138#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1139# error "This version of SWIG only supports Python >= 2.7"
1140#endif
1141
1142#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1143# error "This version of SWIG only supports Python 3 >= 3.3"
1144#endif
1145
1146/* Common SWIG API */
1147
1148/* for raw pointers */
1149#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1150#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1151#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1152
1153#ifdef SWIGPYTHON_BUILTIN
1154#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1155#else
1156#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1157#endif
1158
1159#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1160
1161#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1162#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1163#define swig_owntype int
1164
1165/* for raw packed data */
1166#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1167#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1168
1169/* for class or struct pointers */
1170#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1171#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1172
1173/* for C or C++ function pointers */
1174#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1175#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1176
1177/* for C++ member pointers, ie, member methods */
1178#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1179#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1180
1181
1182/* Runtime API */
1183
1184#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1185#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1186#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1187
1188#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1189#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1190#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1191#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1192#define SWIG_fail goto fail
1193
1194
1195/* Runtime API implementation */
1196
1197/* Error manipulation */
1198
1199SWIGINTERN void
1200SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1202 PyErr_SetObject(errtype, obj);
1203 SWIG_Py_DECREF(obj);
1205}
1206
1207SWIGINTERN void
1208SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1210 PyErr_SetString(errtype, msg);
1212}
1213
1214#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1215
1216/* Set a constant value */
1217
1218#if defined(SWIGPYTHON_BUILTIN)
1219
1220SWIGINTERN void
1221SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1222 PyObject *s = PyString_InternFromString(key);
1223 PyList_Append(seq, s);
1224 SWIG_Py_DECREF(s);
1225}
1226
1227SWIGINTERN void
1228SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1229 PyDict_SetItemString(d, name, obj);
1230 SWIG_Py_DECREF(obj);
1231 if (public_interface)
1232 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1233}
1234
1235#else
1236
1237SWIGINTERN void
1238SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1239 PyDict_SetItemString(d, name, obj);
1240 SWIG_Py_DECREF(obj);
1241}
1242
1243#endif
1244
1245/* Append a value to the result obj */
1246
1247SWIGINTERN PyObject*
1248SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
1249 if (!result) {
1250 result = obj;
1251 } else if (result == Py_None && is_void) {
1252 SWIG_Py_DECREF(result);
1253 result = obj;
1254 } else {
1255 if (!PyList_Check(result)) {
1256 PyObject *o2 = result;
1257 result = PyList_New(1);
1258 if (result) {
1259 PyList_SET_ITEM(result, 0, o2);
1260 } else {
1261 SWIG_Py_DECREF(obj);
1262 return o2;
1263 }
1264 }
1265 PyList_Append(result,obj);
1266 SWIG_Py_DECREF(obj);
1267 }
1268 return result;
1269}
1270
1271/* Unpack the argument tuple */
1272
1273SWIGINTERN Py_ssize_t
1274SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1275{
1276 if (!args) {
1277 if (!min && !max) {
1278 return 1;
1279 } else {
1280 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1281 name, (min == max ? "" : "at least "), (int)min);
1282 return 0;
1283 }
1284 }
1285 if (!PyTuple_Check(args)) {
1286 if (min <= 1 && max >= 1) {
1287 Py_ssize_t i;
1288 objs[0] = args;
1289 for (i = 1; i < max; ++i) {
1290 objs[i] = 0;
1291 }
1292 return 2;
1293 }
1294 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1295 return 0;
1296 } else {
1297 Py_ssize_t l = PyTuple_GET_SIZE(args);
1298 if (l < min) {
1299 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1300 name, (min == max ? "" : "at least "), (int)min, (int)l);
1301 return 0;
1302 } else if (l > max) {
1303 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1304 name, (min == max ? "" : "at most "), (int)max, (int)l);
1305 return 0;
1306 } else {
1307 Py_ssize_t i;
1308 for (i = 0; i < l; ++i) {
1309 objs[i] = PyTuple_GET_ITEM(args, i);
1310 }
1311 for (; l < max; ++l) {
1312 objs[l] = 0;
1313 }
1314 return i + 1;
1315 }
1316 }
1317}
1318
1319SWIGINTERN int
1320SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1321 int no_kwargs = 1;
1322 if (kwargs) {
1323 assert(PyDict_Check(kwargs));
1324 if (PyDict_Size(kwargs) > 0) {
1325 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1326 no_kwargs = 0;
1327 }
1328 }
1329 return no_kwargs;
1330}
1331
1332/* A functor is a function object with one single object argument */
1333#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1334
1335/*
1336 Helper for static pointer initialization for both C and C++ code, for example
1337 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1338*/
1339#ifdef __cplusplus
1340#define SWIG_STATIC_POINTER(var) var
1341#else
1342#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1343#endif
1344
1345#ifdef __cplusplus
1346extern "C" {
1347#endif
1348
1349/* Python-specific SWIG API */
1350#define SWIG_newvarlink() SWIG_Python_newvarlink()
1351#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1352#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1353
1354/* -----------------------------------------------------------------------------
1355 * global variable support code.
1356 * ----------------------------------------------------------------------------- */
1357
1358typedef struct swig_globalvar {
1359 char *name; /* Name of global variable */
1360 PyObject *(*get_attr)(void); /* Return the current value */
1361 int (*set_attr)(PyObject *); /* Set the value */
1364
1369
1370SWIGINTERN PyObject *
1372#if PY_VERSION_HEX >= 0x03000000
1373 return PyUnicode_InternFromString("<Swig global variables>");
1374#else
1375 return PyString_FromString("<Swig global variables>");
1376#endif
1377}
1378
1379SWIGINTERN PyObject *
1380swig_varlink_str(PyObject *o) {
1382#if PY_VERSION_HEX >= 0x03000000
1383 PyObject *str = PyUnicode_InternFromString("(");
1384 PyObject *tail;
1385 PyObject *joined;
1386 swig_globalvar *var;
1387 for (var = v->vars; var; var=var->next) {
1388 tail = PyUnicode_FromString(var->name);
1389 joined = PyUnicode_Concat(str, tail);
1390 SWIG_Py_DECREF(str);
1392 str = joined;
1393 if (var->next) {
1394 tail = PyUnicode_InternFromString(", ");
1395 joined = PyUnicode_Concat(str, tail);
1396 SWIG_Py_DECREF(str);
1398 str = joined;
1399 }
1400 }
1401 tail = PyUnicode_InternFromString(")");
1402 joined = PyUnicode_Concat(str, tail);
1403 SWIG_Py_DECREF(str);
1405 str = joined;
1406#else
1407 PyObject *str = PyString_FromString("(");
1408 swig_globalvar *var;
1409 for (var = v->vars; var; var=var->next) {
1410 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1411 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1412 }
1413 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1414#endif
1415 return str;
1416}
1417
1418SWIGINTERN void
1421 swig_globalvar *var = v->vars;
1422 while (var) {
1423 swig_globalvar *n = var->next;
1424 free(var->name);
1425 free(var);
1426 var = n;
1427 }
1428}
1429
1430SWIGINTERN PyObject *
1431swig_varlink_getattr(PyObject *o, char *n) {
1433 PyObject *res = NULL;
1434 swig_globalvar *var = v->vars;
1435 while (var) {
1436 if (strcmp(var->name,n) == 0) {
1437 res = (*var->get_attr)();
1438 break;
1439 }
1440 var = var->next;
1441 }
1442 if (res == NULL && !PyErr_Occurred()) {
1443 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1444 }
1445 return res;
1446}
1447
1448SWIGINTERN int
1449swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1451 int res = 1;
1452 swig_globalvar *var = v->vars;
1453 while (var) {
1454 if (strcmp(var->name,n) == 0) {
1455 res = (*var->set_attr)(p);
1456 break;
1457 }
1458 var = var->next;
1459 }
1460 if (res == 1 && !PyErr_Occurred()) {
1461 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1462 }
1463 return res;
1464}
1465
1466#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000
1467#define SWIG_HEAPTYPES
1468#endif
1469
1470SWIGINTERN PyTypeObject*
1472 static char varlink__doc__[] = "Swig var link object";
1473#ifndef SWIG_HEAPTYPES
1474 static PyTypeObject varlink_type;
1475 static int type_init = 0;
1476 if (!type_init) {
1477 const PyTypeObject tmp = {
1478#if PY_VERSION_HEX >= 0x03000000
1479 PyVarObject_HEAD_INIT(NULL, 0)
1480#else
1481 PyObject_HEAD_INIT(NULL)
1482 0, /* ob_size */
1483#endif
1484 "swigvarlink", /* tp_name */
1485 sizeof(swig_varlinkobject), /* tp_basicsize */
1486 0, /* tp_itemsize */
1487 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1488#if PY_VERSION_HEX < 0x030800b4
1489 (printfunc)0, /* tp_print */
1490#else
1491 (Py_ssize_t)0, /* tp_vectorcall_offset */
1492#endif
1493 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1494 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1495 0, /* tp_compare */
1496 (reprfunc) swig_varlink_repr, /* tp_repr */
1497 0, /* tp_as_number */
1498 0, /* tp_as_sequence */
1499 0, /* tp_as_mapping */
1500 0, /* tp_hash */
1501 0, /* tp_call */
1502 (reprfunc) swig_varlink_str, /* tp_str */
1503 0, /* tp_getattro */
1504 0, /* tp_setattro */
1505 0, /* tp_as_buffer */
1506 0, /* tp_flags */
1507 varlink__doc__, /* tp_doc */
1508 0, /* tp_traverse */
1509 0, /* tp_clear */
1510 0, /* tp_richcompare */
1511 0, /* tp_weaklistoffset */
1512 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1513 0, /* tp_del */
1514 0, /* tp_version_tag */
1515#if PY_VERSION_HEX >= 0x03040000
1516 0, /* tp_finalize */
1517#endif
1518#if PY_VERSION_HEX >= 0x03080000
1519 0, /* tp_vectorcall */
1520#endif
1521#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1522 0, /* tp_print */
1523#endif
1524#if PY_VERSION_HEX >= 0x030C0000
1525 0, /* tp_watched */
1526#endif
1527#if PY_VERSION_HEX >= 0x030d00a4
1528 0, /* tp_versions_used */
1529#endif
1530#ifdef COUNT_ALLOCS
1531 0, /* tp_allocs */
1532 0, /* tp_frees */
1533 0, /* tp_maxalloc */
1534 0, /* tp_prev */
1535 0 /* tp_next */
1536#endif
1537 };
1538 varlink_type = tmp;
1539 type_init = 1;
1540 if (PyType_Ready(&varlink_type) < 0)
1541 return NULL;
1542 }
1543 return &varlink_type;
1544#else
1545 PyType_Slot slots[] = {
1546 { Py_tp_dealloc, (void *)swig_varlink_dealloc },
1547 { Py_tp_repr, (void *)swig_varlink_repr },
1548 { Py_tp_getattr, (void *)swig_varlink_getattr },
1549 { Py_tp_setattr, (void *)swig_varlink_setattr },
1550 { Py_tp_str, (void *)swig_varlink_str },
1551 { Py_tp_doc, (void *)varlink__doc__ },
1552 { 0, NULL }
1553 };
1554 PyType_Spec spec = {
1555 "swigvarlink",
1556 sizeof(swig_varlinkobject),
1557 0,
1558 Py_TPFLAGS_DEFAULT,
1559 slots
1560 };
1561 return (PyTypeObject *)PyType_FromSpec(&spec);
1562#endif
1563}
1564
1565/* Create a variable linking object for use later */
1566SWIGINTERN PyObject *
1568 swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
1569 if (result) {
1570 result->vars = 0;
1571 }
1572 return ((PyObject*) result);
1573}
1574
1575SWIGINTERN void
1576SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1578 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1579 if (gv) {
1580 size_t size = strlen(name)+1;
1581 gv->name = (char *)malloc(size);
1582 if (gv->name) {
1583 memcpy(gv->name, name, size);
1584 gv->get_attr = get_attr;
1585 gv->set_attr = set_attr;
1586 gv->next = v->vars;
1587 }
1588 }
1589 v->vars = gv;
1590}
1591
1592
1593static PyObject *Swig_Globals_global = NULL;
1594
1595SWIGINTERN PyObject *
1597 if (Swig_Globals_global == NULL) {
1599 }
1600 return Swig_Globals_global;
1601}
1602
1603#ifdef __cplusplus
1604}
1605#endif
1606
1607/* -----------------------------------------------------------------------------
1608 * Pointer declarations
1609 * ----------------------------------------------------------------------------- */
1610
1611/* Flags for new pointer objects */
1612#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1613#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1614
1615#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1616
1617#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1618#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1619
1620#ifdef __cplusplus
1621extern "C" {
1622#endif
1623
1624/* The python void return value */
1625
1626SWIGRUNTIMEINLINE PyObject *
1628{
1629 PyObject *none = Py_None;
1630 SWIG_Py_INCREF(none);
1631 return none;
1632}
1633
1634/* SwigPyClientData */
1635
1636typedef struct {
1637 PyObject *klass;
1638 PyObject *newraw;
1639 PyObject *newargs;
1640 PyObject *destroy;
1643 PyTypeObject *pytype;
1645
1648{
1650 int fail = data ? data->implicitconv : 0;
1651 if (fail)
1652 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1653 return fail;
1654}
1655
1656SWIGRUNTIMEINLINE PyObject *
1658 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1659 PyObject *klass = data ? data->klass : 0;
1660 return (klass ? klass : PyExc_RuntimeError);
1661}
1662
1663
1666{
1667 if (!obj) {
1668 return 0;
1669 } else {
1670 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1671 /* the klass element */
1672 data->klass = obj;
1673 SWIG_Py_INCREF(data->klass);
1674 /* the newraw method and newargs arguments used to create a new raw instance */
1675 if (PyClass_Check(obj)) {
1676 data->newraw = 0;
1677 SWIG_Py_INCREF(obj);
1678 data->newargs = obj;
1679 } else {
1680 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1681 if (data->newraw) {
1682 data->newargs = PyTuple_New(1);
1683 if (data->newargs) {
1684 SWIG_Py_INCREF(obj);
1685 PyTuple_SET_ITEM(data->newargs, 0, obj);
1686 } else {
1687 SWIG_Py_DECREF(data->newraw);
1688 SWIG_Py_DECREF(data->klass);
1689 free(data);
1690 return 0;
1691 }
1692 } else {
1693 SWIG_Py_INCREF(obj);
1694 data->newargs = obj;
1695 }
1696 }
1697 /* the destroy method, aka as the C++ delete method */
1698 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1699 if (PyErr_Occurred()) {
1700 PyErr_Clear();
1701 data->destroy = 0;
1702 }
1703 if (data->destroy) {
1704 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1705 } else {
1706 data->delargs = 0;
1707 }
1708 data->implicitconv = 0;
1709 data->pytype = 0;
1710 return data;
1711 }
1712}
1713
1714SWIGRUNTIME void
1716{
1717 SWIG_Py_XDECREF(data->klass);
1718 SWIG_Py_XDECREF(data->newraw);
1719 SWIG_Py_XDECREF(data->newargs);
1720 SWIG_Py_XDECREF(data->destroy);
1721 free(data);
1722}
1723
1724/* =============== SwigPyObject =====================*/
1725
1726typedef struct {
1727 PyObject_HEAD
1728 void *ptr;
1730 int own;
1731 PyObject *next;
1732#ifdef SWIGPYTHON_BUILTIN
1733 PyObject *dict;
1734#endif
1735} SwigPyObject;
1736
1737
1738#ifdef SWIGPYTHON_BUILTIN
1739
1740SWIGRUNTIME PyObject *
1741SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1742{
1743 SwigPyObject *sobj = (SwigPyObject *)v;
1744
1745 if (!sobj->dict)
1746 sobj->dict = PyDict_New();
1747
1748 SWIG_Py_XINCREF(sobj->dict);
1749 return sobj->dict;
1750}
1751
1752#endif
1753
1754SWIGRUNTIME PyObject *
1756{
1757 return PyLong_FromVoidPtr(v->ptr);
1758}
1759
1760SWIGRUNTIME PyObject *
1762{
1763 PyObject *res = NULL;
1764 PyObject *args = PyTuple_New(1);
1765 if (args) {
1766 PyObject *val = SwigPyObject_long(v);
1767 if (val) {
1768 PyObject *ofmt;
1769 PyTuple_SET_ITEM(args, 0, val);
1770 ofmt = SWIG_Python_str_FromChar(fmt);
1771 if (ofmt) {
1772#if PY_VERSION_HEX >= 0x03000000
1773 res = PyUnicode_Format(ofmt,args);
1774#else
1775 res = PyString_Format(ofmt,args);
1776#endif
1777 SWIG_Py_DECREF(ofmt);
1778 }
1779 }
1780 SWIG_Py_DECREF(args);
1781 }
1782 return res;
1783}
1784
1785SWIGRUNTIME PyObject *
1787{
1788 return SwigPyObject_format("%o",v);
1789}
1790
1791SWIGRUNTIME PyObject *
1793{
1794 return SwigPyObject_format("%x",v);
1795}
1796
1797SWIGRUNTIME PyObject *
1799{
1800 const char *name = SWIG_TypePrettyName(v->ty);
1801 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1802 if (repr && v->next) {
1803 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1804 if (nrep) {
1805# if PY_VERSION_HEX >= 0x03000000
1806 PyObject *joined = PyUnicode_Concat(repr, nrep);
1807 SWIG_Py_DECREF(repr);
1808 SWIG_Py_DECREF(nrep);
1809 repr = joined;
1810# else
1811 PyString_ConcatAndDel(&repr,nrep);
1812# endif
1813 } else {
1814 SWIG_Py_DECREF(repr);
1815 repr = NULL;
1816 }
1817 }
1818 return repr;
1819}
1820
1821/* We need a version taking two PyObject* parameters so it's a valid
1822 * PyCFunction to use in swigobject_methods[]. */
1823SWIGRUNTIME PyObject *
1824SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1825{
1826 return SwigPyObject_repr((SwigPyObject*)v);
1827}
1828
1829SWIGRUNTIME int
1831{
1832 void *i = v->ptr;
1833 void *j = w->ptr;
1834 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1835}
1836
1837/* Added for Python 3.x, would it also be useful for Python 2.x? */
1838SWIGRUNTIME PyObject*
1840{
1841 PyObject* res = NULL;
1842 if (!PyErr_Occurred()) {
1843 if (op != Py_EQ && op != Py_NE) {
1844 SWIG_Py_INCREF(Py_NotImplemented);
1845 return Py_NotImplemented;
1846 }
1847 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1848 }
1849 return res;
1850}
1851
1852
1853SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1854
1855#ifdef SWIGPYTHON_BUILTIN
1856static swig_type_info *SwigPyObject_stype = 0;
1857SWIGRUNTIME PyTypeObject*
1858SwigPyObject_type(void) {
1859 SwigPyClientData *cd;
1860 assert(SwigPyObject_stype);
1861 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1862 assert(cd);
1863 assert(cd->pytype);
1864 return cd->pytype;
1865}
1866#else
1867SWIGRUNTIME PyTypeObject*
1869 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1870 return type;
1871}
1872#endif
1873
1875SwigPyObject_Check(PyObject *op) {
1876 PyTypeObject *target_tp = SwigPyObject_type();
1877 PyTypeObject *op_type = Py_TYPE(op);
1878#ifdef SWIGPYTHON_BUILTIN
1879 if (PyType_IsSubtype(op_type, target_tp))
1880 return 1;
1881 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1882#else
1883# ifdef Py_LIMITED_API
1884 int cmp;
1885 PyObject *tp_name;
1886#endif
1887 if (op_type == target_tp)
1888 return 1;
1889# ifdef Py_LIMITED_API
1890 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
1891 if (!tp_name)
1892 return 0;
1893 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
1894 SWIG_Py_DECREF(tp_name);
1895 return cmp == 0;
1896# else
1897 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1898# endif
1899#endif
1900}
1901
1902SWIGRUNTIME PyObject *
1903SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1904
1905static PyObject* Swig_Capsule_global = NULL;
1906
1907SWIGRUNTIME void
1909{
1910 SwigPyObject *sobj = (SwigPyObject *) v;
1911 PyObject *next = sobj->next;
1912 if (sobj->own == SWIG_POINTER_OWN) {
1913 swig_type_info *ty = sobj->ty;
1914 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1915 PyObject *destroy = data ? data->destroy : 0;
1916 if (destroy) {
1917 /* destroy is always a VARARGS method */
1918 PyObject *res;
1919
1920 /* PyObject_CallFunction() has the potential to silently drop
1921 the active exception. In cases of unnamed temporary
1922 variable or where we just finished iterating over a generator
1923 StopIteration will be active right now, and this needs to
1924 remain true upon return from SwigPyObject_dealloc. So save
1925 and restore. */
1926
1927 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1928 PyErr_Fetch(&type, &value, &traceback);
1929
1930 if (data->delargs) {
1931 /* we need to create a temporary object to carry the destroy operation */
1932 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1933 if (tmp) {
1934 res = SWIG_Python_CallFunctor(destroy, tmp);
1935 } else {
1936 res = 0;
1937 }
1938 SWIG_Py_XDECREF(tmp);
1939 } else {
1940 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1941 PyObject *mself = PyCFunction_GET_SELF(destroy);
1942 res = ((*meth)(mself, v));
1943 }
1944 if (!res)
1945 PyErr_WriteUnraisable(destroy);
1946
1947 PyErr_Restore(type, value, traceback);
1948
1949 SWIG_Py_XDECREF(res);
1950 }
1951#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1952 else {
1953 const char *name = SWIG_TypePrettyName(ty);
1954 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1955 }
1956#endif
1958 }
1959 SWIG_Py_XDECREF(next);
1960#ifdef SWIGPYTHON_BUILTIN
1961 SWIG_Py_XDECREF(sobj->dict);
1962#endif
1963 PyObject_Free(v);
1964}
1965
1966SWIGRUNTIME PyObject*
1967SwigPyObject_append(PyObject* v, PyObject* next)
1968{
1969 SwigPyObject *sobj = (SwigPyObject *) v;
1970 if (!SwigPyObject_Check(next)) {
1971 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1972 return NULL;
1973 }
1974 ((SwigPyObject *)next)->next = sobj->next;
1975 sobj->next = next;
1976 SWIG_Py_INCREF(next);
1977 return SWIG_Py_Void();
1978}
1979
1980SWIGRUNTIME PyObject*
1981SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1982{
1983 SwigPyObject *sobj = (SwigPyObject *) v;
1984 if (sobj->next) {
1985 SWIG_Py_INCREF(sobj->next);
1986 return sobj->next;
1987 } else {
1988 return SWIG_Py_Void();
1989 }
1990}
1991
1992SWIGINTERN PyObject*
1993SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1994{
1995 SwigPyObject *sobj = (SwigPyObject *)v;
1996 sobj->own = 0;
1997 return SWIG_Py_Void();
1998}
1999
2000SWIGINTERN PyObject*
2001SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2002{
2003 SwigPyObject *sobj = (SwigPyObject *)v;
2004 sobj->own = SWIG_POINTER_OWN;
2005 return SWIG_Py_Void();
2006}
2007
2008SWIGINTERN PyObject*
2009SwigPyObject_own(PyObject *v, PyObject *args)
2010{
2011 PyObject *val = 0;
2012 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
2013 return NULL;
2014 } else {
2015 SwigPyObject *sobj = (SwigPyObject *)v;
2016 PyObject *obj = PyBool_FromLong(sobj->own);
2017 if (val) {
2018 if (PyObject_IsTrue(val)) {
2020 } else {
2022 }
2023 }
2024 return obj;
2025 }
2026}
2027
2028static PyMethodDef
2030 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
2031 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
2032 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
2033 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
2034 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
2035 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
2036 {0, 0, 0, 0}
2037};
2038
2039SWIGRUNTIME PyTypeObject*
2041 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2042#ifndef SWIG_HEAPTYPES
2043 static PyNumberMethods SwigPyObject_as_number = {
2044 (binaryfunc)0, /*nb_add*/
2045 (binaryfunc)0, /*nb_subtract*/
2046 (binaryfunc)0, /*nb_multiply*/
2047 /* nb_divide removed in Python 3 */
2048#if PY_VERSION_HEX < 0x03000000
2049 (binaryfunc)0, /*nb_divide*/
2050#endif
2051 (binaryfunc)0, /*nb_remainder*/
2052 (binaryfunc)0, /*nb_divmod*/
2053 (ternaryfunc)0,/*nb_power*/
2054 (unaryfunc)0, /*nb_negative*/
2055 (unaryfunc)0, /*nb_positive*/
2056 (unaryfunc)0, /*nb_absolute*/
2057 (inquiry)0, /*nb_nonzero*/
2058 0, /*nb_invert*/
2059 0, /*nb_lshift*/
2060 0, /*nb_rshift*/
2061 0, /*nb_and*/
2062 0, /*nb_xor*/
2063 0, /*nb_or*/
2064#if PY_VERSION_HEX < 0x03000000
2065 0, /*nb_coerce*/
2066#endif
2067 (unaryfunc)SwigPyObject_long, /*nb_int*/
2068#if PY_VERSION_HEX < 0x03000000
2069 (unaryfunc)SwigPyObject_long, /*nb_long*/
2070#else
2071 0, /*nb_reserved*/
2072#endif
2073 (unaryfunc)0, /*nb_float*/
2074#if PY_VERSION_HEX < 0x03000000
2075 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
2076 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
2077#endif
2078#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
2079 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
2080#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
2081 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
2082#else
2083 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2084#endif
2085 };
2086
2087 static PyTypeObject swigpyobject_type;
2088 static int type_init = 0;
2089 if (!type_init) {
2090 const PyTypeObject tmp = {
2091#if PY_VERSION_HEX >= 0x03000000
2092 PyVarObject_HEAD_INIT(NULL, 0)
2093#else
2094 PyObject_HEAD_INIT(NULL)
2095 0, /* ob_size */
2096#endif
2097 "SwigPyObject", /* tp_name */
2098 sizeof(SwigPyObject), /* tp_basicsize */
2099 0, /* tp_itemsize */
2100 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
2101#if PY_VERSION_HEX < 0x030800b4
2102 (printfunc)0, /* tp_print */
2103#else
2104 (Py_ssize_t)0, /* tp_vectorcall_offset */
2105#endif
2106 (getattrfunc)0, /* tp_getattr */
2107 (setattrfunc)0, /* tp_setattr */
2108#if PY_VERSION_HEX >= 0x03000000
2109 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
2110#else
2111 (cmpfunc)SwigPyObject_compare, /* tp_compare */
2112#endif
2113 (reprfunc)SwigPyObject_repr, /* tp_repr */
2114 &SwigPyObject_as_number, /* tp_as_number */
2115 0, /* tp_as_sequence */
2116 0, /* tp_as_mapping */
2117 (hashfunc)0, /* tp_hash */
2118 (ternaryfunc)0, /* tp_call */
2119 0, /* tp_str */
2120 PyObject_GenericGetAttr, /* tp_getattro */
2121 0, /* tp_setattro */
2122 0, /* tp_as_buffer */
2123 Py_TPFLAGS_DEFAULT, /* tp_flags */
2124 swigobject_doc, /* tp_doc */
2125 0, /* tp_traverse */
2126 0, /* tp_clear */
2127 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2128 0, /* tp_weaklistoffset */
2129 0, /* tp_iter */
2130 0, /* tp_iternext */
2131 swigobject_methods, /* tp_methods */
2132 0, /* tp_members */
2133 0, /* tp_getset */
2134 0, /* tp_base */
2135 0, /* tp_dict */
2136 0, /* tp_descr_get */
2137 0, /* tp_descr_set */
2138 0, /* tp_dictoffset */
2139 0, /* tp_init */
2140 0, /* tp_alloc */
2141 0, /* tp_new */
2142 0, /* tp_free */
2143 0, /* tp_is_gc */
2144 0, /* tp_bases */
2145 0, /* tp_mro */
2146 0, /* tp_cache */
2147 0, /* tp_subclasses */
2148 0, /* tp_weaklist */
2149 0, /* tp_del */
2150 0, /* tp_version_tag */
2151#if PY_VERSION_HEX >= 0x03040000
2152 0, /* tp_finalize */
2153#endif
2154#if PY_VERSION_HEX >= 0x03080000
2155 0, /* tp_vectorcall */
2156#endif
2157#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2158 0, /* tp_print */
2159#endif
2160#if PY_VERSION_HEX >= 0x030C0000
2161 0, /* tp_watched */
2162#endif
2163#if PY_VERSION_HEX >= 0x030d00a4
2164 0, /* tp_versions_used */
2165#endif
2166#ifdef COUNT_ALLOCS
2167 0, /* tp_allocs */
2168 0, /* tp_frees */
2169 0, /* tp_maxalloc */
2170 0, /* tp_prev */
2171 0 /* tp_next */
2172#endif
2173 };
2174 swigpyobject_type = tmp;
2175 type_init = 1;
2176 if (PyType_Ready(&swigpyobject_type) != 0)
2177 return NULL;
2178 }
2179 return &swigpyobject_type;
2180#else
2181 PyType_Slot slots[] = {
2182 { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
2183 { Py_tp_repr, (void *)SwigPyObject_repr },
2184 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2185 { Py_tp_doc, (void *)swigobject_doc },
2186 { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
2187 { Py_tp_methods, (void *)swigobject_methods },
2188 { Py_nb_int, (void *)SwigPyObject_long },
2189 { 0, NULL }
2190 };
2191 PyType_Spec spec = {
2192 "SwigPyObject",
2193 sizeof(SwigPyObject),
2194 0,
2195 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
2196 slots
2197 };
2198 return (PyTypeObject *)PyType_FromSpec(&spec);
2199#endif
2200}
2201
2202SWIGRUNTIME PyObject *
2203SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2204{
2205 SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
2206 if (sobj) {
2207 sobj->ptr = ptr;
2208 sobj->ty = ty;
2209 sobj->own = own;
2210 sobj->next = 0;
2211#ifdef SWIGPYTHON_BUILTIN
2212 sobj->dict = 0;
2213#endif
2214 if (own == SWIG_POINTER_OWN) {
2215 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2216 * module information is correctly destroyed after all SWIG python objects have been freed
2217 * by the GC (and corresponding destructors invoked) */
2219 }
2220 }
2221 return (PyObject *)sobj;
2222}
2223
2224/* -----------------------------------------------------------------------------
2225 * Implements a simple Swig Packed type, and use it instead of string
2226 * ----------------------------------------------------------------------------- */
2227
2228typedef struct {
2229 PyObject_HEAD
2230 void *pack;
2232 size_t size;
2233} SwigPyPacked;
2234
2235SWIGRUNTIME PyObject *
2237{
2238 char result[SWIG_BUFFER_SIZE];
2239 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2240 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2241 } else {
2242 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2243 }
2244}
2245
2246SWIGRUNTIME PyObject *
2248{
2249 char result[SWIG_BUFFER_SIZE];
2250 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2251 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2252 } else {
2253 return SWIG_Python_str_FromChar(v->ty->name);
2254 }
2255}
2256
2257SWIGRUNTIME int
2259{
2260 size_t i = v->size;
2261 size_t j = w->size;
2262 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2263 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2264}
2265
2266SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2267
2268SWIGRUNTIME PyTypeObject*
2270 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2271 return type;
2272}
2273
2275SwigPyPacked_Check(PyObject *op) {
2276#ifdef Py_LIMITED_API
2277 int cmp;
2278 PyObject *tp_name;
2279#endif
2280 PyTypeObject* op_type = Py_TYPE(op);
2281 if (op_type == SwigPyPacked_TypeOnce())
2282 return 1;
2283#ifdef Py_LIMITED_API
2284 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
2285 if (!tp_name)
2286 return 0;
2287 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
2288 SWIG_Py_DECREF(tp_name);
2289 return cmp == 0;
2290#else
2291 return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
2292#endif
2293}
2294
2295SWIGRUNTIME void
2297{
2298 if (SwigPyPacked_Check(v)) {
2299 SwigPyPacked *sobj = (SwigPyPacked *) v;
2300 free(sobj->pack);
2301 }
2302 PyObject_Free(v);
2303}
2304
2305SWIGRUNTIME PyTypeObject*
2307 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2308#ifndef SWIG_HEAPTYPES
2309 static PyTypeObject swigpypacked_type;
2310 static int type_init = 0;
2311 if (!type_init) {
2312 const PyTypeObject tmp = {
2313#if PY_VERSION_HEX>=0x03000000
2314 PyVarObject_HEAD_INIT(NULL, 0)
2315#else
2316 PyObject_HEAD_INIT(NULL)
2317 0, /* ob_size */
2318#endif
2319 "SwigPyPacked", /* tp_name */
2320 sizeof(SwigPyPacked), /* tp_basicsize */
2321 0, /* tp_itemsize */
2322 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2323#if PY_VERSION_HEX < 0x030800b4
2324 (printfunc)0, /* tp_print */
2325#else
2326 (Py_ssize_t)0, /* tp_vectorcall_offset */
2327#endif
2328 (getattrfunc)0, /* tp_getattr */
2329 (setattrfunc)0, /* tp_setattr */
2330#if PY_VERSION_HEX>=0x03000000
2331 0, /* tp_reserved in 3.0.1 */
2332#else
2333 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2334#endif
2335 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2336 0, /* tp_as_number */
2337 0, /* tp_as_sequence */
2338 0, /* tp_as_mapping */
2339 (hashfunc)0, /* tp_hash */
2340 (ternaryfunc)0, /* tp_call */
2341 (reprfunc)SwigPyPacked_str, /* tp_str */
2342 PyObject_GenericGetAttr, /* tp_getattro */
2343 0, /* tp_setattro */
2344 0, /* tp_as_buffer */
2345 Py_TPFLAGS_DEFAULT, /* tp_flags */
2346 swigpacked_doc, /* tp_doc */
2347 0, /* tp_traverse */
2348 0, /* tp_clear */
2349 0, /* tp_richcompare */
2350 0, /* tp_weaklistoffset */
2351 0, /* tp_iter */
2352 0, /* tp_iternext */
2353 0, /* tp_methods */
2354 0, /* tp_members */
2355 0, /* tp_getset */
2356 0, /* tp_base */
2357 0, /* tp_dict */
2358 0, /* tp_descr_get */
2359 0, /* tp_descr_set */
2360 0, /* tp_dictoffset */
2361 0, /* tp_init */
2362 0, /* tp_alloc */
2363 0, /* tp_new */
2364 0, /* tp_free */
2365 0, /* tp_is_gc */
2366 0, /* tp_bases */
2367 0, /* tp_mro */
2368 0, /* tp_cache */
2369 0, /* tp_subclasses */
2370 0, /* tp_weaklist */
2371 0, /* tp_del */
2372 0, /* tp_version_tag */
2373#if PY_VERSION_HEX >= 0x03040000
2374 0, /* tp_finalize */
2375#endif
2376#if PY_VERSION_HEX >= 0x03080000
2377 0, /* tp_vectorcall */
2378#endif
2379#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2380 0, /* tp_print */
2381#endif
2382#if PY_VERSION_HEX >= 0x030C0000
2383 0, /* tp_watched */
2384#endif
2385#if PY_VERSION_HEX >= 0x030d00a4
2386 0, /* tp_versions_used */
2387#endif
2388#ifdef COUNT_ALLOCS
2389 0, /* tp_allocs */
2390 0, /* tp_frees */
2391 0, /* tp_maxalloc */
2392 0, /* tp_prev */
2393 0 /* tp_next */
2394#endif
2395 };
2396 swigpypacked_type = tmp;
2397 type_init = 1;
2398 if (PyType_Ready(&swigpypacked_type) != 0)
2399 return NULL;
2400 }
2401 return &swigpypacked_type;
2402#else
2403 PyType_Slot slots[] = {
2404 { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
2405 { Py_tp_repr, (void *)SwigPyPacked_repr },
2406 { Py_tp_str, (void *)SwigPyPacked_str },
2407 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2408 { Py_tp_doc, (void *)swigpacked_doc },
2409 { 0, NULL }
2410 };
2411 PyType_Spec spec = {
2412 "SwigPyPacked",
2413 sizeof(SwigPyPacked),
2414 0,
2415 Py_TPFLAGS_DEFAULT,
2416 slots
2417 };
2418 return (PyTypeObject *)PyType_FromSpec(&spec);
2419#endif
2420}
2421
2422SWIGRUNTIME PyObject *
2423SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2424{
2425 SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
2426 if (sobj) {
2427 void *pack = malloc(size);
2428 if (pack) {
2429 memcpy(pack, ptr, size);
2430 sobj->pack = pack;
2431 sobj->ty = ty;
2432 sobj->size = size;
2433 } else {
2434 PyObject_Free((PyObject *)sobj);
2435 sobj = 0;
2436 }
2437 }
2438 return (PyObject *) sobj;
2439}
2440
2442SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2443{
2444 if (SwigPyPacked_Check(obj)) {
2445 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2446 if (sobj->size != size) return 0;
2447 memcpy(ptr, sobj->pack, size);
2448 return sobj->ty;
2449 } else {
2450 return 0;
2451 }
2452}
2453
2454/* -----------------------------------------------------------------------------
2455 * pointers/data manipulation
2456 * ----------------------------------------------------------------------------- */
2457
2458static PyObject *Swig_This_global = NULL;
2459
2460SWIGRUNTIME PyObject *
2462{
2463 if (Swig_This_global == NULL)
2465 return Swig_This_global;
2466}
2467
2468/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2469
2470/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2471#if PY_VERSION_HEX>=0x03000000
2472#define SWIG_PYTHON_SLOW_GETSET_THIS
2473#endif
2474
2477{
2478 PyObject *obj;
2479
2480 if (SwigPyObject_Check(pyobj))
2481 return (SwigPyObject *) pyobj;
2482
2483#ifdef SWIGPYTHON_BUILTIN
2484 (void)obj;
2485# ifdef PyWeakref_CheckProxy
2486 if (PyWeakref_CheckProxy(pyobj)) {
2487#if PY_VERSION_HEX >= 0x030D0000
2488 PyWeakref_GetRef(pyobj, &pyobj);
2489 Py_DECREF(pyobj);
2490#else
2491 pyobj = PyWeakref_GET_OBJECT(pyobj);
2492#endif
2493 if (pyobj && SwigPyObject_Check(pyobj))
2494 return (SwigPyObject*) pyobj;
2495 }
2496# endif
2497 return NULL;
2498#else
2499
2500 obj = 0;
2501
2502#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2503 if (PyInstance_Check(pyobj)) {
2504 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2505 } else {
2506 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2507 if (dictptr != NULL) {
2508 PyObject *dict = *dictptr;
2509 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2510 } else {
2511#ifdef PyWeakref_CheckProxy
2512 if (PyWeakref_CheckProxy(pyobj)) {
2513 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2514 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2515 }
2516#endif
2517 obj = PyObject_GetAttr(pyobj,SWIG_This());
2518 if (obj) {
2519 SWIG_Py_DECREF(obj);
2520 } else {
2521 if (PyErr_Occurred()) PyErr_Clear();
2522 return 0;
2523 }
2524 }
2525 }
2526#else
2527 obj = PyObject_GetAttr(pyobj,SWIG_This());
2528 if (obj) {
2529 SWIG_Py_DECREF(obj);
2530 } else {
2531 if (PyErr_Occurred()) PyErr_Clear();
2532 return 0;
2533 }
2534#endif
2535 if (obj && !SwigPyObject_Check(obj)) {
2536 /* a PyObject is called 'this', try to get the 'real this'
2537 SwigPyObject from it */
2538 return SWIG_Python_GetSwigThis(obj);
2539 }
2540 return (SwigPyObject *)obj;
2541#endif
2542}
2543
2544/* Acquire a pointer value */
2545
2546SWIGRUNTIME int
2547SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2548 if (own == SWIG_POINTER_OWN) {
2550 if (sobj) {
2551 int oldown = sobj->own;
2552 sobj->own = own;
2553 return oldown;
2554 }
2555 }
2556 return 0;
2557}
2558
2559/* Convert a pointer value */
2560
2561SWIGRUNTIME int
2562SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2563 int res;
2564 SwigPyObject *sobj;
2565 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2566
2567 if (!obj)
2568 return SWIG_ERROR;
2569 if (obj == Py_None && !implicit_conv) {
2570 if (ptr)
2571 *ptr = 0;
2573 }
2574
2575 res = SWIG_ERROR;
2576
2577 sobj = SWIG_Python_GetSwigThis(obj);
2578 if (own)
2579 *own = 0;
2580 while (sobj) {
2581 void *vptr = sobj->ptr;
2582 if (ty) {
2583 swig_type_info *to = sobj->ty;
2584 if (to == ty) {
2585 /* no type cast needed */
2586 if (ptr) *ptr = vptr;
2587 break;
2588 } else {
2589 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2590 if (!tc) {
2591 sobj = (SwigPyObject *)sobj->next;
2592 } else {
2593 if (ptr) {
2594 int newmemory = 0;
2595 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2596 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2597 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2598 if (own)
2599 *own = *own | SWIG_CAST_NEW_MEMORY;
2600 }
2601 }
2602 break;
2603 }
2604 }
2605 } else {
2606 if (ptr) *ptr = vptr;
2607 break;
2608 }
2609 }
2610 if (sobj) {
2611 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2613 } else {
2614 if (own)
2615 *own = *own | sobj->own;
2616 if (flags & SWIG_POINTER_DISOWN) {
2617 sobj->own = 0;
2618 }
2619 if (flags & SWIG_POINTER_CLEAR) {
2620 sobj->ptr = 0;
2621 }
2622 res = SWIG_OK;
2623 }
2624 } else {
2625 if (implicit_conv) {
2626 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2627 if (data && !data->implicitconv) {
2628 PyObject *klass = data->klass;
2629 if (klass) {
2630 PyObject *impconv;
2631 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2632 impconv = SWIG_Python_CallFunctor(klass, obj);
2633 data->implicitconv = 0;
2634 if (PyErr_Occurred()) {
2635 PyErr_Clear();
2636 impconv = 0;
2637 }
2638 if (impconv) {
2639 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2640 if (iobj) {
2641 void *vptr;
2642 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2643 if (SWIG_IsOK(res)) {
2644 if (ptr) {
2645 *ptr = vptr;
2646 /* transfer the ownership to 'ptr' */
2647 iobj->own = 0;
2648 res = SWIG_AddCast(res);
2649 res = SWIG_AddNewMask(res);
2650 } else {
2651 res = SWIG_AddCast(res);
2652 }
2653 }
2654 }
2655 SWIG_Py_DECREF(impconv);
2656 }
2657 }
2658 }
2659 if (!SWIG_IsOK(res) && obj == Py_None) {
2660 if (ptr)
2661 *ptr = 0;
2662 if (PyErr_Occurred())
2663 PyErr_Clear();
2664 res = SWIG_OK;
2665 }
2666 }
2667 }
2668 return res;
2669}
2670
2671/* Convert a function ptr value */
2672
2673SWIGRUNTIME int
2674SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2675 if (!PyCFunction_Check(obj)) {
2676 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2677 } else {
2678 void *vptr = 0;
2679 swig_cast_info *tc;
2680
2681 /* here we get the method pointer for callbacks */
2682#ifndef Py_LIMITED_API
2683 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2684#else
2685 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2686 PyObject *bytes = NULL;
2687 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2688#endif
2689 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2690 if (desc)
2691 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2692#ifdef Py_LIMITED_API
2693 SWIG_Py_XDECREF(bytes);
2694 SWIG_Py_XDECREF(pystr_doc);
2695#endif
2696 if (!desc)
2697 return SWIG_ERROR;
2698 tc = SWIG_TypeCheck(desc,ty);
2699 if (tc) {
2700 int newmemory = 0;
2701 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2702 assert(!newmemory); /* newmemory handling not yet implemented */
2703 } else {
2704 return SWIG_ERROR;
2705 }
2706 return SWIG_OK;
2707 }
2708}
2709
2710/* Convert a packed pointer value */
2711
2712SWIGRUNTIME int
2713SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2714 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2715 if (!to) return SWIG_ERROR;
2716 if (ty) {
2717 if (to != ty) {
2718 /* check type cast? */
2719 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2720 if (!tc) return SWIG_ERROR;
2721 }
2722 }
2723 return SWIG_OK;
2724}
2725
2726/* -----------------------------------------------------------------------------
2727 * Create a new pointer object
2728 * ----------------------------------------------------------------------------- */
2729
2730/*
2731 Create a new instance object, without calling __init__, and set the
2732 'this' attribute.
2733*/
2734
2735SWIGRUNTIME PyObject*
2737{
2738 PyObject *inst = 0;
2739 PyObject *newraw = data->newraw;
2740 if (newraw) {
2741 inst = PyObject_Call(newraw, data->newargs, NULL);
2742 if (inst) {
2743#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2744 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2745 if (dictptr != NULL) {
2746 PyObject *dict = *dictptr;
2747 if (dict == NULL) {
2748 dict = PyDict_New();
2749 *dictptr = dict;
2750 }
2751 if (dict) {
2752 PyDict_SetItem(dict, SWIG_This(), swig_this);
2753 } else{
2754 SWIG_Py_DECREF(inst);
2755 inst = 0;
2756 }
2757 }
2758#else
2759 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2760 SWIG_Py_DECREF(inst);
2761 inst = 0;
2762 }
2763#endif
2764 }
2765 } else {
2766#if PY_VERSION_HEX >= 0x03000000
2767 PyObject *empty_args = PyTuple_New(0);
2768 if (empty_args) {
2769 PyObject *empty_kwargs = PyDict_New();
2770 if (empty_kwargs) {
2771#ifndef Py_LIMITED_API
2772 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2773#else
2774 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2775#endif
2776 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2777 SWIG_Py_DECREF(empty_kwargs);
2778 if (inst) {
2779 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2780 SWIG_Py_DECREF(inst);
2781 inst = 0;
2782 } else {
2783 PyType_Modified(Py_TYPE(inst));
2784 }
2785 }
2786 }
2787 SWIG_Py_DECREF(empty_args);
2788 }
2789#else
2790 PyObject *dict = PyDict_New();
2791 if (dict) {
2792 PyDict_SetItem(dict, SWIG_This(), swig_this);
2793 inst = PyInstance_NewRaw(data->newargs, dict);
2794 SWIG_Py_DECREF(dict);
2795 }
2796#endif
2797 }
2798 return inst;
2799}
2800
2801SWIGRUNTIME int
2802SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2803{
2804#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2805 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2806 if (dictptr != NULL) {
2807 PyObject *dict = *dictptr;
2808 if (dict == NULL) {
2809 dict = PyDict_New();
2810 *dictptr = dict;
2811 }
2812 if (dict) {
2813 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2814 } else{
2815 return -1;
2816 }
2817 }
2818#endif
2819 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2820}
2821
2822
2823SWIGINTERN PyObject *
2825 PyObject *obj[2];
2826 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2827 return NULL;
2828 } else {
2829 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2830 if (sthis) {
2831 SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2832 } else {
2833 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2834 return NULL;
2835 }
2836 return SWIG_Py_Void();
2837 }
2838}
2839
2840/* Create a new pointer object */
2841
2842SWIGRUNTIME PyObject *
2843SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2844 SwigPyClientData *clientdata;
2845 PyObject * robj;
2846 int own;
2847
2848 if (!ptr)
2849 return SWIG_Py_Void();
2850
2851 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2852 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2853 if (clientdata && clientdata->pytype) {
2854 SwigPyObject *newobj;
2855 if (flags & SWIG_BUILTIN_TP_INIT) {
2856 newobj = (SwigPyObject*) self;
2857 if (newobj->ptr) {
2858#ifndef Py_LIMITED_API
2859 allocfunc alloc = clientdata->pytype->tp_alloc;
2860#else
2861 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2862#endif
2863 PyObject *next_self = alloc(clientdata->pytype, 0);
2864 while (newobj->next)
2865 newobj = (SwigPyObject *) newobj->next;
2866 newobj->next = next_self;
2867 newobj = (SwigPyObject *)next_self;
2868#ifdef SWIGPYTHON_BUILTIN
2869 newobj->dict = 0;
2870#endif
2871 }
2872 } else {
2873 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2874#ifdef SWIGPYTHON_BUILTIN
2875 if (newobj) {
2876 newobj->dict = 0;
2877 }
2878#endif
2879 }
2880 if (newobj) {
2881 newobj->ptr = ptr;
2882 newobj->ty = type;
2883 newobj->own = own;
2884 newobj->next = 0;
2885 return (PyObject*) newobj;
2886 }
2887 return SWIG_Py_Void();
2888 }
2889
2890 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2891
2892 robj = SwigPyObject_New(ptr, type, own);
2893 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2894 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2895 SWIG_Py_DECREF(robj);
2896 robj = inst;
2897 }
2898 return robj;
2899}
2900
2901/* Create a new packed object */
2902
2903SWIGRUNTIMEINLINE PyObject *
2904SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2905 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2906}
2907
2908/* -----------------------------------------------------------------------------*
2909 * Get type list
2910 * -----------------------------------------------------------------------------*/
2911
2912#ifdef SWIG_LINK_RUNTIME
2913void *SWIG_ReturnGlobalTypeList(void *);
2914#endif
2915
2916static PyObject *Swig_TypeCache_global = NULL;
2917
2918/* The python cached type query */
2919SWIGRUNTIME PyObject *
2921 if (Swig_TypeCache_global == NULL) {
2922 Swig_TypeCache_global = PyDict_New();
2923 }
2924 return Swig_TypeCache_global;
2925}
2926
2929#ifdef SWIG_LINK_RUNTIME
2930 static void *type_pointer = (void *)0;
2931 /* first check if module already created */
2932 if (!type_pointer) {
2933 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2934 }
2935#else
2936 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2937 if (PyErr_Occurred()) {
2938 PyErr_Clear();
2939 type_pointer = (void *)0;
2940 }
2941#endif
2942 return (swig_module_info *) type_pointer;
2943}
2944
2945
2946static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2947
2948SWIGRUNTIME void
2950{
2951 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2952 swig_type_info **types = swig_module->types;
2953 size_t i;
2954 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2955 return;
2956 for (i =0; i < swig_module->size; ++i) {
2957 swig_type_info *ty = types[i];
2958 if (ty->owndata) {
2960 ty->clientdata = 0;
2961 if (data) SwigPyClientData_Del(data);
2962 }
2963 }
2965 Swig_This_global = NULL;
2967 Swig_Globals_global = NULL;
2969 Swig_TypeCache_global = NULL;
2970 Swig_Capsule_global = NULL;
2971}
2972
2973SWIGRUNTIME void
2975#if PY_VERSION_HEX >= 0x03000000
2976 /* Add a dummy module object into sys.modules */
2977 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2978#else
2979 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2980 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2981#endif
2982 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2983 if (pointer && module) {
2984 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2986 Swig_Capsule_global = pointer;
2987 } else {
2988 SWIG_Py_DECREF(pointer);
2989 }
2990 } else {
2991 SWIG_Py_XDECREF(pointer);
2992 }
2993}
2994
2996SWIG_Python_TypeQuery(const char *type)
2997{
2998 PyObject *cache = SWIG_Python_TypeCache();
2999 PyObject *key = SWIG_Python_str_FromChar(type);
3000 PyObject *obj = PyDict_GetItem(cache, key);
3001 swig_type_info *descriptor;
3002 if (obj) {
3003 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
3004 } else {
3006 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
3007 if (descriptor) {
3008 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
3009 if (obj) {
3010 PyDict_SetItem(cache, key, obj);
3011 SWIG_Py_DECREF(obj);
3012 }
3013 }
3014 }
3015 SWIG_Py_DECREF(key);
3016 return descriptor;
3017}
3018
3019/*
3020 For backward compatibility only
3021*/
3022#define SWIG_POINTER_EXCEPTION 0
3023#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
3024#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
3025
3026SWIGRUNTIME int
3027SWIG_Python_AddErrMesg(const char* mesg, int infront)
3028{
3029 if (PyErr_Occurred()) {
3030 PyObject *type = 0;
3031 PyObject *value = 0;
3032 PyObject *traceback = 0;
3033 PyErr_Fetch(&type, &value, &traceback);
3034 if (value) {
3035 PyObject *old_str = PyObject_Str(value);
3036 PyObject *bytes = NULL;
3037 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
3038 const char *errmesg = tmp ? tmp : "Invalid error message";
3039 SWIG_Py_XINCREF(type);
3040 PyErr_Clear();
3041 if (infront) {
3042 PyErr_Format(type, "%s %s", mesg, errmesg);
3043 } else {
3044 PyErr_Format(type, "%s %s", errmesg, mesg);
3045 }
3046 SWIG_Py_XDECREF(bytes);
3047 SWIG_Py_DECREF(old_str);
3048 }
3049 return 1;
3050 } else {
3051 return 0;
3052 }
3053}
3054
3055SWIGRUNTIME int
3057{
3058 if (PyErr_Occurred()) {
3059 /* add information about failing argument */
3060 char mesg[256];
3061 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3062 return SWIG_Python_AddErrMesg(mesg, 1);
3063 } else {
3064 return 0;
3065 }
3066}
3067
3068SWIGRUNTIMEINLINE const char *
3070{
3071 SwigPyObject *v = (SwigPyObject *)self;
3072 swig_type_info *ty = v ? v->ty : 0;
3073 return ty ? ty->str : "";
3074}
3075
3076SWIGRUNTIME void
3077SWIG_Python_TypeError(const char *type, PyObject *obj)
3078{
3079 (void) obj;
3080 if (type) {
3081#if defined(SWIG_COBJECT_TYPES)
3082 if (obj && SwigPyObject_Check(obj)) {
3083 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3084 if (otype) {
3085 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3086 type, otype);
3087 return;
3088 }
3089 } else
3090#endif
3091 {
3092#ifndef Py_LIMITED_API
3093 /* tp_name is not accessible */
3094 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3095 if (otype) {
3096 PyObject *str = PyObject_Str(obj);
3097 PyObject *bytes = NULL;
3098 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3099 if (cstr) {
3100 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3101 type, otype, cstr);
3102 } else {
3103 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3104 type, otype);
3105 }
3106 SWIG_Py_XDECREF(bytes);
3107 SWIG_Py_XDECREF(str);
3108 return;
3109 }
3110#endif
3111 }
3112 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3113 } else {
3114 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3115 }
3116}
3117
3118
3119/* Convert a pointer value, signal an exception on a type mismatch */
3120SWIGRUNTIME void *
3121SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3122 void *result;
3123 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3124 PyErr_Clear();
3125 }
3126 return result;
3127}
3128
3129#ifdef SWIGPYTHON_BUILTIN
3130SWIGRUNTIME int
3131SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3132 PyTypeObject *tp = obj->ob_type;
3133 PyObject *descr;
3134 PyObject *encoded_name;
3135 descrsetfunc f;
3136 int res = -1;
3137
3138# ifdef Py_USING_UNICODE
3139 if (PyString_Check(name)) {
3140 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3141 if (!name)
3142 return -1;
3143 } else if (!PyUnicode_Check(name))
3144# else
3145 if (!PyString_Check(name))
3146# endif
3147 {
3148 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3149 return -1;
3150 } else {
3152 }
3153
3154 if (!tp->tp_dict) {
3155 if (PyType_Ready(tp) != 0)
3156 goto done;
3157 }
3158
3159 descr = _PyType_Lookup(tp, name);
3160 f = NULL;
3161 if (descr != NULL)
3162 f = descr->ob_type->tp_descr_set;
3163 if (!f) {
3164 if (PyString_Check(name)) {
3165 encoded_name = name;
3167 } else {
3168 encoded_name = PyUnicode_AsUTF8String(name);
3169 if (!encoded_name)
3170 goto done;
3171 }
3172 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3173 SWIG_Py_DECREF(encoded_name);
3174 } else {
3175 res = f(descr, obj, value);
3176 }
3177
3178 done:
3180 return res;
3181}
3182#endif
3183
3184
3185#ifdef __cplusplus
3186}
3187#endif
3188
3189
3190
3191#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3192
3193#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3194
3195
3196
3197/* -------- TYPES TABLE (BEGIN) -------- */
3198
3199#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3200#define SWIGTYPE_p_PLcGrid swig_types[1]
3201#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3202#define SWIGTYPE_p_char swig_types[3]
3203#define SWIGTYPE_p_double swig_types[4]
3204#define SWIGTYPE_p_f_double_double__int swig_types[5]
3205#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3206#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3207#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3208#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3209#define SWIGTYPE_p_int swig_types[10]
3210#define SWIGTYPE_p_p_char swig_types[11]
3211#define SWIGTYPE_p_p_double swig_types[12]
3212#define SWIGTYPE_p_unsigned_int swig_types[13]
3214static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3215#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3216#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3217
3218/* -------- TYPES TABLE (END) -------- */
3219
3220#ifdef SWIG_TypeQuery
3221# undef SWIG_TypeQuery
3222#endif
3223#define SWIG_TypeQuery SWIG_Python_TypeQuery
3224
3225/*-----------------------------------------------
3226 @(target):= _plplotc.so
3227 ------------------------------------------------*/
3228#if PY_VERSION_HEX >= 0x03000000
3229# define SWIG_init PyInit__plplotc
3230
3231#else
3232# define SWIG_init init_plplotc
3233
3234#endif
3235
3236#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3237#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3238
3239
3240#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3241#include <arrayobject.h>
3242#include "plplot.h"
3243#include "plplotP.h"
3244
3245#define NPY_PLINT NPY_INT32
3246
3247#ifdef PL_DOUBLE
3248#define NPY_PLFLT NPY_FLOAT64
3249#else
3250#define NPY_PLFLT NPY_FLOAT32
3251#endif
3252
3253// python-1.5 compatibility mode?
3254#if !defined ( PySequence_Fast_GET_ITEM )
3255 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3256#endif
3257#define PySequence_Size PySequence_Length
3258
3259
3260 static PLINT Alen = 0;
3261 static PLINT Xlen = 0, Ylen = 0;
3262
3263
3264SWIGINTERN int
3265SWIG_AsVal_double (PyObject *obj, double *val)
3266{
3267 int res = SWIG_TypeError;
3268 if (PyFloat_Check(obj)) {
3269 if (val) *val = PyFloat_AsDouble(obj);
3270 return SWIG_OK;
3271#if PY_VERSION_HEX < 0x03000000
3272 } else if (PyInt_Check(obj)) {
3273 if (val) *val = (double) PyInt_AsLong(obj);
3274 return SWIG_OK;
3275#endif
3276 } else if (PyLong_Check(obj)) {
3277 double v = PyLong_AsDouble(obj);
3278 if (!PyErr_Occurred()) {
3279 if (val) *val = v;
3280 return SWIG_OK;
3281 } else {
3282 PyErr_Clear();
3283 }
3284 }
3285#ifdef SWIG_PYTHON_CAST_MODE
3286 {
3287 int dispatch = 0;
3288 double d = PyFloat_AsDouble(obj);
3289 if (!PyErr_Occurred()) {
3290 if (val) *val = d;
3291 return SWIG_AddCast(SWIG_OK);
3292 } else {
3293 PyErr_Clear();
3294 }
3295 if (!dispatch) {
3296 long v = PyLong_AsLong(obj);
3297 if (!PyErr_Occurred()) {
3298 if (val) *val = v;
3300 } else {
3301 PyErr_Clear();
3302 }
3303 }
3304 }
3305#endif
3306 return res;
3307}
3308
3309
3310 #define SWIG_From_double PyFloat_FromDouble
3311
3312
3313 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3314 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3315 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3316 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3317 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3319 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3320
3321
3322SWIGINTERNINLINE PyObject*
3324{
3325 return PyInt_FromLong((long) value);
3326}
3327
3328
3329#include <limits.h>
3330#if !defined(SWIG_NO_LLONG_MAX)
3331# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3332# define LLONG_MAX __LONG_LONG_MAX__
3333# define LLONG_MIN (-LLONG_MAX - 1LL)
3334# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3335# endif
3336#endif
3337
3338
3339#include <float.h>
3340
3341
3342#include <math.h>
3343
3344
3346SWIG_CanCastAsInteger(double *d, double min, double max) {
3347 double x = *d;
3348 if ((min <= x && x <= max)) {
3349 double fx, cx, rd;
3350 errno = 0;
3351 fx = floor(x);
3352 cx = ceil(x);
3353 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3354 if ((errno == EDOM) || (errno == ERANGE)) {
3355 errno = 0;
3356 } else {
3357 double summ, reps, diff;
3358 if (rd < x) {
3359 diff = x - rd;
3360 } else if (rd > x) {
3361 diff = rd - x;
3362 } else {
3363 return 1;
3364 }
3365 summ = rd + x;
3366 reps = diff/summ;
3367 if (reps < 8*DBL_EPSILON) {
3368 *d = rd;
3369 return 1;
3370 }
3371 }
3372 }
3373 return 0;
3374}
3375
3376
3377SWIGINTERN int
3378SWIG_AsVal_long (PyObject *obj, long* val)
3379{
3380#if PY_VERSION_HEX < 0x03000000
3381 if (PyInt_Check(obj)) {
3382 if (val) *val = PyInt_AsLong(obj);
3383 return SWIG_OK;
3384 } else
3385#endif
3386 if (PyLong_Check(obj)) {
3387 long v = PyLong_AsLong(obj);
3388 if (!PyErr_Occurred()) {
3389 if (val) *val = v;
3390 return SWIG_OK;
3391 } else {
3392 PyErr_Clear();
3393 return SWIG_OverflowError;
3394 }
3395 }
3396#ifdef SWIG_PYTHON_CAST_MODE
3397 {
3398 int dispatch = 0;
3399 long v = PyInt_AsLong(obj);
3400 if (!PyErr_Occurred()) {
3401 if (val) *val = v;
3402 return SWIG_AddCast(SWIG_OK);
3403 } else {
3404 PyErr_Clear();
3405 }
3406 if (!dispatch) {
3407 double d;
3408 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3409 // Largest double not larger than LONG_MAX (not portably calculated easily)
3410 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3411 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3412 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3413 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3414 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3415 if (val) *val = (long)(d);
3416 return res;
3417 }
3418 }
3419 }
3420#endif
3421 return SWIG_TypeError;
3422}
3423
3424
3425SWIGINTERN int
3426SWIG_AsVal_int (PyObject * obj, int *val)
3427{
3428 long v;
3429 int res = SWIG_AsVal_long (obj, &v);
3430 if (SWIG_IsOK(res)) {
3431 if ((v < INT_MIN || v > INT_MAX)) {
3432 return SWIG_OverflowError;
3433 } else {
3434 if (val) *val = (int)(v);
3435 }
3436 }
3437 return res;
3438}
3439
3440
3441SWIGINTERN int
3442SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3443{
3444#if PY_VERSION_HEX < 0x03000000
3445 if (PyInt_Check(obj)) {
3446 long v = PyInt_AsLong(obj);
3447 if (v >= 0) {
3448 if (val) *val = v;
3449 return SWIG_OK;
3450 } else {
3451 return SWIG_OverflowError;
3452 }
3453 } else
3454#endif
3455 if (PyLong_Check(obj)) {
3456 unsigned long v = PyLong_AsUnsignedLong(obj);
3457 if (!PyErr_Occurred()) {
3458 if (val) *val = v;
3459 return SWIG_OK;
3460 } else {
3461 PyErr_Clear();
3462 return SWIG_OverflowError;
3463 }
3464 }
3465#ifdef SWIG_PYTHON_CAST_MODE
3466 {
3467 int dispatch = 0;
3468 unsigned long v = PyLong_AsUnsignedLong(obj);
3469 if (!PyErr_Occurred()) {
3470 if (val) *val = v;
3471 return SWIG_AddCast(SWIG_OK);
3472 } else {
3473 PyErr_Clear();
3474 }
3475 if (!dispatch) {
3476 double d;
3477 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3478 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3479 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3480 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3481 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3482 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3483 if (val) *val = (unsigned long)(d);
3484 return res;
3485 }
3486 }
3487 }
3488#endif
3489 return SWIG_TypeError;
3490}
3491
3492
3493SWIGINTERN int
3494SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3495{
3496 unsigned long v;
3497 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3498 if (SWIG_IsOK(res)) {
3499 if ((v > UINT_MAX)) {
3500 return SWIG_OverflowError;
3501 } else {
3502 if (val) *val = (unsigned int)(v);
3503 }
3504 }
3505 return res;
3506}
3507
3508
3509SWIGINTERNINLINE PyObject*
3511{
3512 return PyInt_FromSize_t((size_t) value);
3513}
3514
3515
3518{
3519 static int init = 0;
3520 static swig_type_info* info = 0;
3521 if (!init) {
3522 info = SWIG_TypeQuery("_p_char");
3523 init = 1;
3524 }
3525 return info;
3526}
3527
3528
3529/* Return string from Python obj. NOTE: obj must remain in scope in order
3530 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3531SWIGINTERN int
3532SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3533{
3534#if PY_VERSION_HEX>=0x03000000
3535#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3536 if (PyBytes_Check(obj))
3537#else
3538 if (PyUnicode_Check(obj))
3539#endif
3540#else
3541 if (PyString_Check(obj))
3542#endif
3543 {
3544 char *cstr; Py_ssize_t len;
3545 PyObject *bytes = NULL;
3546 int ret = SWIG_OK;
3547 if (alloc)
3548 *alloc = SWIG_OLDOBJ;
3549#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3550 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3551 return SWIG_TypeError;
3552#else
3553 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3554 if (!cstr)
3555 return SWIG_TypeError;
3556 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3557 if (bytes && cptr) {
3558 if (alloc) {
3559 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3560 *alloc = SWIG_NEWOBJ;
3561 } else {
3562 /* alloc must be set in order to clean up allocated memory */
3563 return SWIG_RuntimeError;
3564 }
3565 }
3566#endif
3567 if (cptr) *cptr = cstr;
3568 if (psize) *psize = len + 1;
3569 SWIG_Py_XDECREF(bytes);
3570 return ret;
3571 } else {
3572#if defined(SWIG_PYTHON_2_UNICODE)
3573#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3574#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3575#endif
3576#if PY_VERSION_HEX<0x03000000
3577 if (PyUnicode_Check(obj)) {
3578 char *cstr; Py_ssize_t len;
3579 if (!alloc && cptr) {
3580 return SWIG_RuntimeError;
3581 }
3582 obj = PyUnicode_AsUTF8String(obj);
3583 if (!obj)
3584 return SWIG_TypeError;
3585 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3586 if (cptr) {
3587 if (alloc) *alloc = SWIG_NEWOBJ;
3588 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3589 }
3590 if (psize) *psize = len + 1;
3591
3592 SWIG_Py_XDECREF(obj);
3593 return SWIG_OK;
3594 } else {
3595 SWIG_Py_XDECREF(obj);
3596 }
3597 }
3598#endif
3599#endif
3600
3601 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3602 if (pchar_descriptor) {
3603 void* vptr = 0;
3604 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3605 if (cptr) *cptr = (char *) vptr;
3606 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3607 if (alloc) *alloc = SWIG_OLDOBJ;
3608 return SWIG_OK;
3609 }
3610 }
3611 }
3612 return SWIG_TypeError;
3613}
3614
3615
3616SWIGINTERN int
3617SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3618{
3619 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3620 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3621 if (SWIG_IsOK(res)) {
3622 /* special case of single char conversion when we don't need space for NUL */
3623 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3624 if (csize <= size) {
3625 if (val) {
3626 if (csize) memcpy(val, cptr, csize*sizeof(char));
3627 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3628 }
3629 if (alloc == SWIG_NEWOBJ) {
3630 free((char*)cptr);
3631 res = SWIG_DelNewMask(res);
3632 }
3633 return res;
3634 }
3635 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3636 }
3637 return SWIG_TypeError;
3638}
3639
3640
3641SWIGINTERNINLINE PyObject *
3642SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3643{
3644 if (carray) {
3645 if (size > INT_MAX) {
3646 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3647 return pchar_descriptor ?
3648 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3649 } else {
3650#if PY_VERSION_HEX >= 0x03000000
3651#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3652 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3653#else
3654 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3655#endif
3656#else
3657 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3658#endif
3659 }
3660 } else {
3661 return SWIG_Py_Void();
3662 }
3663}
3664
3665
3666SWIGINTERN size_t
3667SWIG_strnlen(const char* s, size_t maxlen)
3668{
3669 const char *p;
3670 for (p = s; maxlen-- && *p; p++)
3671 ;
3672 return p - s;
3673}
3674
3675
3676
3677
3678
3679SWIGINTERN int
3680SWIG_AsVal_char (PyObject * obj, char *val)
3681{
3682 int res = SWIG_AsCharArray(obj, val, 1);
3683 if (!SWIG_IsOK(res)) {
3684 long v;
3685 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3686 if (SWIG_IsOK(res)) {
3687 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3688 if (val) *val = (char)(v);
3689 } else {
3690 res = SWIG_OverflowError;
3691 }
3692 }
3693 }
3694 return res;
3695}
3696
3697#ifdef __cplusplus
3698extern "C" {
3699#endif
3700
3701 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3702
3703// some really twisted stuff to allow calling a single precision library from python
3704 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3705 {
3706 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3707 mindims, maxdims );
3708 if ( !tmp )
3709 {
3710 // could be an incoming long array which can't be "safely" converted, do it anyway
3711 if ( PyArray_Check( in ) )
3712 {
3713 PyErr_Clear();
3714 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3715 }
3716 }
3717 return tmp;
3718 }
3719
3720
3721#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3722
3723SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3724 PyObject *resultobj = 0;
3725 PLFLT arg1 ;
3726 PLFLT arg2 ;
3727 PLFLT *arg3 = (PLFLT *) 0 ;
3728 PLFLT *arg4 = (PLFLT *) 0 ;
3729 PLPointer arg5 = (PLPointer) 0 ;
3730 double val1 ;
3731 int ecode1 = 0 ;
3732 double val2 ;
3733 int ecode2 = 0 ;
3734 PLFLT temp3 ;
3735 int res3 = SWIG_TMPOBJ ;
3736 PLFLT temp4 ;
3737 int res4 = SWIG_TMPOBJ ;
3738 PyObject *swig_obj[2] ;
3739
3740 arg3 = &temp3;
3741 arg4 = &temp4;
3742 {
3743 arg5 = NULL;
3744 }
3745 (void)self;
3746 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3747 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3748 if (!SWIG_IsOK(ecode1)) {
3749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3750 }
3751 arg1 = (PLFLT)(val1);
3752 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3753 if (!SWIG_IsOK(ecode2)) {
3754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3755 }
3756 arg2 = (PLFLT)(val2);
3757 pltr0(arg1,arg2,arg3,arg4,arg5);
3758 resultobj = SWIG_Py_Void();
3759 if (SWIG_IsTmpObj(res3)) {
3760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3761 } else {
3762 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3764 }
3765 if (SWIG_IsTmpObj(res4)) {
3766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3767 } else {
3768 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3770 }
3771 return resultobj;
3772fail:
3773 return NULL;
3774}
3775
3776
3777
3778 PyArrayObject *pltr_xg, *pltr_yg;
3781
3782 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3783 void cleanup_PLcGrid1( void );
3784 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3785 void cleanup_PLcGrid2( void );
3786
3787 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3788 {
3789 // fprintf(stderr, "marshal PLcGrid1\n");
3790 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3791 {
3792 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3793 return NULL;
3794 }
3795 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3796 NPY_PLFLT, 1, 1 );
3797 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3798 NPY_PLFLT, 1, 1 );
3799 if ( pltr_xg == 0 || pltr_yg == 0 )
3800 {
3801 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3802 return NULL;
3803 }
3804 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3805 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3806 if ( isimg == 0 )
3807 {
3808 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3809 {
3810 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3811 return NULL;
3812 }
3813 }
3814 else
3815 {
3816 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3817 {
3818 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3819 return NULL;
3820 }
3821 }
3822 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3823 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3824 return &tmpGrid1;
3825 }
3826
3827 void cleanup_PLcGrid1( void )
3828 {
3829 // fprintf(stderr, "cleanup PLcGrid1\n");
3830 Py_CLEAR( pltr_xg );
3831 Py_CLEAR( pltr_yg );
3832 }
3833
3834 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3835 {
3836 int i, size;
3837 // fprintf(stderr, "marshal PLcGrid2\n");
3838 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3839 {
3840 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3841 return NULL;
3842 }
3843 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3844 NPY_PLFLT, 2, 2 );
3845 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3846 NPY_PLFLT, 2, 2 );
3847 if ( pltr_xg == 0 || pltr_yg == 0 )
3848 {
3849 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3850 return NULL;
3851 }
3852 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3853 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3854 {
3855 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3856 return NULL;
3857 }
3858 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3859 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3860 if ( isimg == 0 )
3861 {
3862 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3863 {
3864 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3865 return NULL;
3866 }
3867 }
3868 else
3869 {
3870 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3871 {
3872 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3873 return NULL;
3874 }
3875 }
3876 size = tmpGrid2.ny;
3877 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3878 for ( i = 0; i < tmpGrid2.nx; i++ )
3879 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3880 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3881 for ( i = 0; i < tmpGrid2.nx; i++ )
3882 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3883 return &tmpGrid2;
3884 }
3885
3886 void cleanup_PLcGrid2( void )
3887 {
3888 // fprintf(stderr, "cleanup PLcGrid2\n");
3889 free( tmpGrid2.xg );
3890 free( tmpGrid2.yg );
3891 Py_CLEAR( pltr_xg );
3892 Py_CLEAR( pltr_yg );
3893 }
3894
3895SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3896 PyObject *resultobj = 0;
3897 PLFLT arg1 ;
3898 PLFLT arg2 ;
3899 PLFLT *arg3 = (PLFLT *) 0 ;
3900 PLFLT *arg4 = (PLFLT *) 0 ;
3901 PLcGrid *arg5 = (PLcGrid *) 0 ;
3902 double val1 ;
3903 int ecode1 = 0 ;
3904 double val2 ;
3905 int ecode2 = 0 ;
3906 PLFLT temp3 ;
3907 int res3 = SWIG_TMPOBJ ;
3908 PLFLT temp4 ;
3909 int res4 = SWIG_TMPOBJ ;
3910 PyObject *swig_obj[3] ;
3911
3912 arg3 = &temp3;
3913 arg4 = &temp4;
3914 (void)self;
3915 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3916 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3917 if (!SWIG_IsOK(ecode1)) {
3918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3919 }
3920 arg1 = (PLFLT)(val1);
3921 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3922 if (!SWIG_IsOK(ecode2)) {
3923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3924 }
3925 arg2 = (PLFLT)(val2);
3926 {
3927 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3928 if ( !arg5 )
3929 return NULL;
3930 }
3931 pltr1(arg1,arg2,arg3,arg4,arg5);
3932 resultobj = SWIG_Py_Void();
3933 if (SWIG_IsTmpObj(res3)) {
3934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3935 } else {
3936 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3938 }
3939 if (SWIG_IsTmpObj(res4)) {
3940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3941 } else {
3942 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3944 }
3945 {
3947 }
3948 return resultobj;
3949fail:
3950 {
3952 }
3953 return NULL;
3954}
3955
3956
3957SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3958 PyObject *resultobj = 0;
3959 PLFLT arg1 ;
3960 PLFLT arg2 ;
3961 PLFLT *arg3 = (PLFLT *) 0 ;
3962 PLFLT *arg4 = (PLFLT *) 0 ;
3963 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3964 double val1 ;
3965 int ecode1 = 0 ;
3966 double val2 ;
3967 int ecode2 = 0 ;
3968 PLFLT temp3 ;
3969 int res3 = SWIG_TMPOBJ ;
3970 PLFLT temp4 ;
3971 int res4 = SWIG_TMPOBJ ;
3972 PyObject *swig_obj[3] ;
3973
3974 arg3 = &temp3;
3975 arg4 = &temp4;
3976 (void)self;
3977 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3978 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3979 if (!SWIG_IsOK(ecode1)) {
3980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3981 }
3982 arg1 = (PLFLT)(val1);
3983 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3984 if (!SWIG_IsOK(ecode2)) {
3985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3986 }
3987 arg2 = (PLFLT)(val2);
3988 {
3989 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3990 if ( !arg5 )
3991 return NULL;
3992 }
3993 pltr2(arg1,arg2,arg3,arg4,arg5);
3994 resultobj = SWIG_Py_Void();
3995 if (SWIG_IsTmpObj(res3)) {
3996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3997 } else {
3998 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
4000 }
4001 if (SWIG_IsTmpObj(res4)) {
4002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
4003 } else {
4004 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
4006 }
4007 {
4009 }
4010 return resultobj;
4011fail:
4012 {
4014 }
4015 return NULL;
4016}
4017
4018
4019
4020 // helper code for handling the callback
4021#if 0
4022 static PyInterpreterState *save_interp = NULL;
4023#endif
4025 PyObject* python_pltr = NULL;
4026 PyObject* python_f2eval = NULL;
4027 PyObject* python_ct = NULL;
4028 PyObject* python_mapform = NULL;
4029 PyObject* python_label = NULL;
4030
4031#if 0
4032#define MY_BLOCK_THREADS { \
4033 PyThreadState *prev_state, *new_state; \
4034 /* need to have started a thread at some stage */ \
4035 /* for the following to work */ \
4036 PyEval_AcquireLock(); \
4037 new_state = PyThreadState_New( save_interp ); \
4038 prev_state = PyThreadState_Swap( new_state );
4039#define MY_UNBLOCK_THREADS \
4040 new_state = PyThreadState_Swap( prev_state ); \
4041 PyThreadState_Clear( new_state ); \
4042 PyEval_ReleaseLock(); \
4043 PyThreadState_Delete( new_state ); \
4044 }
4045#else
4046#define MY_BLOCK_THREADS
4047#define MY_UNBLOCK_THREADS
4048#endif
4049
4050// Function prototypes
4051 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4053 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4054 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4055 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4056 pltr_func marshal_pltr( PyObject* input );
4057 void cleanup_pltr( void );
4058 ct_func marshal_ct( PyObject* input );
4059 void cleanup_ct( void );
4060 mapform_func marshal_mapform( PyObject* input );
4061 void cleanup_mapform( void );
4062 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4063 void cleanup_PLPointer( void );
4064
4065
4066// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4067
4068 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4069 {
4070 PyObject *pdata, *arglist, *result;
4071 PyArrayObject *tmp;
4072
4073 // the data argument is acutally a pointer to a python object
4074 pdata = (PyObject *) data;
4075 if ( data == NULL )
4076 {
4077 pdata = Py_None;
4078 }
4079 if ( python_pltr ) // if not something is terribly wrong
4080 { // hold a reference to the data object
4081 Py_XINCREF( pdata );
4082 // grab the Global Interpreter Lock to be sure threads don't mess us up
4084 // build the argument list
4085#ifdef PL_DOUBLE
4086 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4087#else
4088 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4089#endif
4090 if ( arglist == NULL )
4091 {
4092 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4093 *tx = *ty = 0;
4094 return;
4095 }
4096 // call the python function
4097 result = PyObject_CallObject( python_pltr, arglist );
4098 // release the argument list
4099 Py_CLEAR( arglist );
4100 // check and unpack the result
4101 if ( result == NULL )
4102 {
4103 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4104 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4105 *tx = *ty = 0;
4106 }
4107 else
4108 {
4109 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4110 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4111 {
4112 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4113 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4114 *tx = *ty = 0;
4115 }
4116 else
4117 {
4118 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4119 *tx = t[0];
4120 *ty = t[1];
4121 Py_CLEAR( tmp );
4122 }
4123 }
4124 // release the result
4125 Py_CLEAR( result );
4126 // release the global interpreter lock
4128 }
4129 }
4130
4132 {
4133 PyObject *pdata, *arglist, *result;
4134 PLFLT fresult = 0.0;
4135
4136 // the data argument is acutally a pointer to a python object
4137 pdata = (PyObject *) data;
4138 if ( python_f2eval ) // if not something is terribly wrong
4139 { // hold a reference to the data object
4140 Py_XINCREF( pdata );
4141 // grab the Global Interpreter Lock to be sure threads don't mess us up
4143 // build the argument list
4144 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4145 // call the python function
4146 result = PyObject_CallObject( python_f2eval, arglist );
4147 // release the argument list
4148 Py_CLEAR( arglist );
4149 // check and unpack the result
4150 if ( !PyFloat_Check( result ) )
4151 {
4152 fprintf( stderr, "f2eval callback must return a float\n" );
4153 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4154 }
4155 else
4156 {
4157 // should I test the type here?
4158 fresult = (PLFLT) PyFloat_AsDouble( result );
4159 }
4160 // release the result
4161 Py_CLEAR( result );
4162 // release the global interpreter lock
4164 }
4165 return fresult;
4166 }
4167
4168 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4169 {
4170 PyObject *pdata, *arglist, *result, *unicode_string;
4171 char *pystring;
4172
4173 // the data argument is acutally a pointer to a python object
4174 if ( data )
4175 pdata = (PyObject *) data;
4176 else
4177 pdata = Py_None;
4178 if ( python_label ) // if not something is terribly wrong
4179 { // hold a reference to the data object
4180 Py_XINCREF( pdata );
4181 // grab the Global Interpreter Lock to be sure threads don't mess us up
4183 // build the argument list
4184#ifdef PL_DOUBLE
4185 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4186#else
4187 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4188#endif
4189 // call the python function
4190 result = PyObject_CallObject( python_label, arglist );
4191 // release the argument list
4192 //Py_CLEAR(arglist);
4193 // check and unpack the result
4194 if ( result == NULL )
4195 {
4196 fprintf( stderr, "label callback failed with 3 arguments\n" );
4197 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4198 }
4199 else if ( PyString_Check( result ) )
4200 {
4201 // should I test the type here?
4202 pystring = PyString_AsString( result );
4203 strncpy( string, pystring, len );
4204 }
4205 else if ( PyUnicode_Check( result ) )
4206 {
4207 // unicode_string is never freed? memory leak here?
4208 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4209 pystring = PyBytes_AS_STRING( unicode_string );
4210 // len may be different then the byte string length w/ unicode?
4211 strncpy( string, pystring, len );
4212 }
4213 else
4214 {
4215 fprintf( stderr, "label callback must return a string\n" );
4216 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4217 }
4218 // release the result
4219 Py_CLEAR( result );
4220 // release the global interpreter lock
4222 }
4223 }
4224
4225 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4226 {
4227 PyObject *px, *py, *pdata, *arglist, *result;
4228 npy_intp n;
4229 n = 1;
4230
4231 // the data argument is acutally a pointer to a python object
4232 pdata = (PyObject *) data;
4233 if ( data == NULL )
4234 {
4235 pdata = Py_None;
4236 }
4237 if ( python_ct ) // if not something is terribly wrong
4238 { // hold a reference to the data object
4239 Py_XINCREF( pdata );
4240 // grab the Global Interpreter Lock to be sure threads don't mess us up
4242 // build the argument list
4243 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4244 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4245 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4246 // call the python function
4247 result = PyObject_CallObject( python_ct, arglist );
4248 // release the argument list
4249 Py_CLEAR( arglist );
4250 Py_CLEAR( px );
4251 Py_CLEAR( py );
4252 Py_CLEAR( pdata );
4253 // check and unpack the result
4254 if ( result == NULL )
4255 {
4256 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4257 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4258 }
4259 // release the result
4260 Py_CLEAR( result );
4261 // release the global interpreter lock
4263 }
4264 }
4265
4267 {
4268 PyObject *px, *py, *arglist, *result;
4269 // PyArrayObject *tmpx, *tmpy;
4270// PLFLT *xx, *yy;
4271// PLINT i;
4272 npy_intp nn;
4273 nn = n;
4274
4275 if ( python_mapform ) // if not something is terribly wrong
4276 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4278 // build the argument list
4279#ifdef PL_HAVE_PTHREAD
4280 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4281 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4282#else
4283 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4284 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4285#endif
4286 arglist = Py_BuildValue( "(iOO)", n, px, py );
4287 // call the python function
4288 result = PyObject_CallObject( python_mapform, arglist );
4289 // release the argument list
4290 Py_CLEAR( arglist );
4291 Py_CLEAR( px );
4292 Py_CLEAR( py );
4293 // check and unpack the result
4294 if ( result == NULL )
4295 {
4296 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4297 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4298 }
4299 // release the result
4300 Py_CLEAR( result );
4301 // release the global interpreter lock
4303 }
4304 }
4305
4306// marshal the pltr function pointer argument
4307 pltr_func marshal_pltr( PyObject* input )
4308 {
4309 pltr_func result = do_pltr_callback;
4310 PyObject * rep = PyObject_Repr( input );
4311 if ( rep )
4312 {
4313 // Memory leaks here? str and uni_str are not freed?
4314 char* str;
4315 if ( PyUnicode_Check( rep ) )
4316 {
4317 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4318 str = PyBytes_AS_STRING( uni_str );
4319 }
4320 else
4321 {
4322 str = PyString_AsString( rep );
4323 }
4324 if ( strstr( str, "function pltr0" ) != 0 )
4325 {
4326 result = pltr0;
4327 pltr_type = CB_0;
4328 python_pltr = NULL;
4329 }
4330 else if ( strstr( str, "function pltr1" ) != 0 )
4331 {
4332 result = pltr1;
4333 pltr_type = CB_1;
4334 python_pltr = NULL;
4335 }
4336 else if ( strstr( str, "function pltr2" ) != 0 )
4337 {
4338 result = pltr2;
4339 pltr_type = CB_2;
4340 python_pltr = NULL;
4341 }
4342 else
4343 {
4344 python_pltr = input;
4346 Py_XINCREF( input );
4347 }
4348 Py_CLEAR( rep );
4349 }
4350 else
4351 {
4352 python_pltr = input;
4354 Py_XINCREF( input );
4355 }
4356 return result;
4357 }
4358
4359 void cleanup_pltr( void )
4360 {
4361 Py_CLEAR( python_pltr );
4362 python_pltr = 0;
4363 }
4364
4365// marshal the ct function pointer argument
4366 ct_func marshal_ct( PyObject* input )
4367 {
4368 ct_func result = do_ct_callback;
4369 python_ct = input;
4370 Py_XINCREF( input );
4371 return result;
4372 }
4373
4374 void cleanup_ct( void )
4375 {
4376 Py_CLEAR( python_ct );
4377 python_ct = 0;
4378 }
4379
4380// marshal the mapform function pointer argument
4382 {
4384 python_mapform = input;
4385 Py_XINCREF( input );
4386 return result;
4387 }
4388
4389 void cleanup_mapform( void )
4390 {
4391 Py_CLEAR( python_mapform );
4392 python_mapform = 0;
4393 }
4394
4395 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4396 {
4397 PLPointer result = NULL;
4398 switch ( pltr_type )
4399 {
4400 case CB_0:
4401 break;
4402 case CB_1:
4403 if ( input != Py_None )
4404 result = marshal_PLcGrid1( input, isimg );
4405 break;
4406 case CB_2:
4407 if ( input != Py_None )
4408 result = marshal_PLcGrid2( input, isimg );
4409 break;
4410 case CB_Python:
4411 Py_XINCREF( input );
4412 result = (PLPointer *) input;
4413 break;
4414 default:
4415 fprintf( stderr, "pltr_type is invalid\n" );
4416 }
4417 return result;
4418 }
4419
4421 {
4422 switch ( pltr_type )
4423 {
4424 case CB_0:
4425 break;
4426 case CB_1:
4428 break;
4429 case CB_2:
4431 break;
4432 case CB_Python:
4433 Py_CLEAR( python_pltr );
4434 break;
4435 default:
4436 fprintf( stderr, "pltr_type is invalid\n" );
4437 }
4438 python_pltr = 0;
4439 pltr_type = CB_0;
4440 }
4441
4442
4443
4444SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4445 PyObject *resultobj = 0;
4446 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4447 int arg2 ;
4448 void *argp1 = 0 ;
4449 int res1 = 0 ;
4450 int val2 ;
4451 int ecode2 = 0 ;
4452 PyObject *swig_obj[2] ;
4453
4454 (void)self;
4455 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4459 }
4460 arg1 = (PLGraphicsIn *)(argp1);
4461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4462 if (!SWIG_IsOK(ecode2)) {
4463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4464 }
4465 arg2 = (int)(val2);
4466 if (arg1) (arg1)->type = arg2;
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469fail:
4470 return NULL;
4471}
4472
4473
4474SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4475 PyObject *resultobj = 0;
4476 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4477 void *argp1 = 0 ;
4478 int res1 = 0 ;
4479 PyObject *swig_obj[1] ;
4480 int result;
4481
4482 (void)self;
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4488 }
4489 arg1 = (PLGraphicsIn *)(argp1);
4490 result = (int) ((arg1)->type);
4491 resultobj = SWIG_From_int((int)(result));
4492 return resultobj;
4493fail:
4494 return NULL;
4495}
4496
4497
4498SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4499 PyObject *resultobj = 0;
4500 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4501 unsigned int arg2 ;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 unsigned int val2 ;
4505 int ecode2 = 0 ;
4506 PyObject *swig_obj[2] ;
4507
4508 (void)self;
4509 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4511 if (!SWIG_IsOK(res1)) {
4512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4513 }
4514 arg1 = (PLGraphicsIn *)(argp1);
4515 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4516 if (!SWIG_IsOK(ecode2)) {
4517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4518 }
4519 arg2 = (unsigned int)(val2);
4520 if (arg1) (arg1)->state = arg2;
4521 resultobj = SWIG_Py_Void();
4522 return resultobj;
4523fail:
4524 return NULL;
4525}
4526
4527
4528SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4529 PyObject *resultobj = 0;
4530 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4531 void *argp1 = 0 ;
4532 int res1 = 0 ;
4533 PyObject *swig_obj[1] ;
4534 unsigned int result;
4535
4536 (void)self;
4537 if (!args) SWIG_fail;
4538 swig_obj[0] = args;
4539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4540 if (!SWIG_IsOK(res1)) {
4541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4542 }
4543 arg1 = (PLGraphicsIn *)(argp1);
4544 result = (unsigned int) ((arg1)->state);
4545 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4546 return resultobj;
4547fail:
4548 return NULL;
4549}
4550
4551
4552SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4553 PyObject *resultobj = 0;
4554 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4555 unsigned int arg2 ;
4556 void *argp1 = 0 ;
4557 int res1 = 0 ;
4558 unsigned int val2 ;
4559 int ecode2 = 0 ;
4560 PyObject *swig_obj[2] ;
4561
4562 (void)self;
4563 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4567 }
4568 arg1 = (PLGraphicsIn *)(argp1);
4569 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4570 if (!SWIG_IsOK(ecode2)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4572 }
4573 arg2 = (unsigned int)(val2);
4574 if (arg1) (arg1)->keysym = arg2;
4575 resultobj = SWIG_Py_Void();
4576 return resultobj;
4577fail:
4578 return NULL;
4579}
4580
4581
4582SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4583 PyObject *resultobj = 0;
4584 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4585 void *argp1 = 0 ;
4586 int res1 = 0 ;
4587 PyObject *swig_obj[1] ;
4588 unsigned int result;
4589
4590 (void)self;
4591 if (!args) SWIG_fail;
4592 swig_obj[0] = args;
4593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4596 }
4597 arg1 = (PLGraphicsIn *)(argp1);
4598 result = (unsigned int) ((arg1)->keysym);
4599 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4600 return resultobj;
4601fail:
4602 return NULL;
4603}
4604
4605
4606SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4607 PyObject *resultobj = 0;
4608 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4609 unsigned int arg2 ;
4610 void *argp1 = 0 ;
4611 int res1 = 0 ;
4612 unsigned int val2 ;
4613 int ecode2 = 0 ;
4614 PyObject *swig_obj[2] ;
4615
4616 (void)self;
4617 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4619 if (!SWIG_IsOK(res1)) {
4620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4621 }
4622 arg1 = (PLGraphicsIn *)(argp1);
4623 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4624 if (!SWIG_IsOK(ecode2)) {
4625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4626 }
4627 arg2 = (unsigned int)(val2);
4628 if (arg1) (arg1)->button = arg2;
4629 resultobj = SWIG_Py_Void();
4630 return resultobj;
4631fail:
4632 return NULL;
4633}
4634
4635
4636SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4637 PyObject *resultobj = 0;
4638 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 PyObject *swig_obj[1] ;
4642 unsigned int result;
4643
4644 (void)self;
4645 if (!args) SWIG_fail;
4646 swig_obj[0] = args;
4647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4648 if (!SWIG_IsOK(res1)) {
4649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4650 }
4651 arg1 = (PLGraphicsIn *)(argp1);
4652 result = (unsigned int) ((arg1)->button);
4653 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4654 return resultobj;
4655fail:
4656 return NULL;
4657}
4658
4659
4660SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4661 PyObject *resultobj = 0;
4662 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4663 PLINT arg2 ;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 int val2 ;
4667 int ecode2 = 0 ;
4668 PyObject *swig_obj[2] ;
4669
4670 (void)self;
4671 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4675 }
4676 arg1 = (PLGraphicsIn *)(argp1);
4677 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4678 if (!SWIG_IsOK(ecode2)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4680 }
4681 arg2 = (PLINT)(val2);
4682 if (arg1) (arg1)->subwindow = arg2;
4683 resultobj = SWIG_Py_Void();
4684 return resultobj;
4685fail:
4686 return NULL;
4687}
4688
4689
4690SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4691 PyObject *resultobj = 0;
4692 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4693 void *argp1 = 0 ;
4694 int res1 = 0 ;
4695 PyObject *swig_obj[1] ;
4696 PLINT result;
4697
4698 (void)self;
4699 if (!args) SWIG_fail;
4700 swig_obj[0] = args;
4701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4702 if (!SWIG_IsOK(res1)) {
4703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4704 }
4705 arg1 = (PLGraphicsIn *)(argp1);
4706 result = (PLINT) ((arg1)->subwindow);
4707 resultobj = SWIG_From_int((int)(result));
4708 return resultobj;
4709fail:
4710 return NULL;
4711}
4712
4713
4714SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4715 PyObject *resultobj = 0;
4716 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4717 char *arg2 = (char *) (char *)0 ;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 char temp2[16] ;
4721 int res2 ;
4722 PyObject *swig_obj[2] ;
4723
4724 (void)self;
4725 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4727 if (!SWIG_IsOK(res1)) {
4728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4729 }
4730 arg1 = (PLGraphicsIn *)(argp1);
4731 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4732 if (!SWIG_IsOK(res2)) {
4733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4734 }
4735 arg2 = (char *)(temp2);
4736 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4737 else memset(arg1->string,0,16*sizeof(char));
4738 resultobj = SWIG_Py_Void();
4739 return resultobj;
4740fail:
4741 return NULL;
4742}
4743
4744
4745SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4746 PyObject *resultobj = 0;
4747 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4748 void *argp1 = 0 ;
4749 int res1 = 0 ;
4750 PyObject *swig_obj[1] ;
4751 char *result = 0 ;
4752
4753 (void)self;
4754 if (!args) SWIG_fail;
4755 swig_obj[0] = args;
4756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4759 }
4760 arg1 = (PLGraphicsIn *)(argp1);
4761 result = (char *)(char *) ((arg1)->string);
4762 {
4763 size_t size = SWIG_strnlen(result, 16);
4764
4765
4766
4767 resultobj = SWIG_FromCharPtrAndSize(result, size);
4768 }
4769 return resultobj;
4770fail:
4771 return NULL;
4772}
4773
4774
4775SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4776 PyObject *resultobj = 0;
4777 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4778 int arg2 ;
4779 void *argp1 = 0 ;
4780 int res1 = 0 ;
4781 int val2 ;
4782 int ecode2 = 0 ;
4783 PyObject *swig_obj[2] ;
4784
4785 (void)self;
4786 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4788 if (!SWIG_IsOK(res1)) {
4789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4790 }
4791 arg1 = (PLGraphicsIn *)(argp1);
4792 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4793 if (!SWIG_IsOK(ecode2)) {
4794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4795 }
4796 arg2 = (int)(val2);
4797 if (arg1) (arg1)->pX = arg2;
4798 resultobj = SWIG_Py_Void();
4799 return resultobj;
4800fail:
4801 return NULL;
4802}
4803
4804
4805SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4806 PyObject *resultobj = 0;
4807 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4808 void *argp1 = 0 ;
4809 int res1 = 0 ;
4810 PyObject *swig_obj[1] ;
4811 int result;
4812
4813 (void)self;
4814 if (!args) SWIG_fail;
4815 swig_obj[0] = args;
4816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4817 if (!SWIG_IsOK(res1)) {
4818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4819 }
4820 arg1 = (PLGraphicsIn *)(argp1);
4821 result = (int) ((arg1)->pX);
4822 resultobj = SWIG_From_int((int)(result));
4823 return resultobj;
4824fail:
4825 return NULL;
4826}
4827
4828
4829SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4830 PyObject *resultobj = 0;
4831 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4832 int arg2 ;
4833 void *argp1 = 0 ;
4834 int res1 = 0 ;
4835 int val2 ;
4836 int ecode2 = 0 ;
4837 PyObject *swig_obj[2] ;
4838
4839 (void)self;
4840 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4842 if (!SWIG_IsOK(res1)) {
4843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4844 }
4845 arg1 = (PLGraphicsIn *)(argp1);
4846 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4847 if (!SWIG_IsOK(ecode2)) {
4848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4849 }
4850 arg2 = (int)(val2);
4851 if (arg1) (arg1)->pY = arg2;
4852 resultobj = SWIG_Py_Void();
4853 return resultobj;
4854fail:
4855 return NULL;
4856}
4857
4858
4859SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4860 PyObject *resultobj = 0;
4861 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4862 void *argp1 = 0 ;
4863 int res1 = 0 ;
4864 PyObject *swig_obj[1] ;
4865 int result;
4866
4867 (void)self;
4868 if (!args) SWIG_fail;
4869 swig_obj[0] = args;
4870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4873 }
4874 arg1 = (PLGraphicsIn *)(argp1);
4875 result = (int) ((arg1)->pY);
4876 resultobj = SWIG_From_int((int)(result));
4877 return resultobj;
4878fail:
4879 return NULL;
4880}
4881
4882
4883SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4884 PyObject *resultobj = 0;
4885 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4886 PLFLT arg2 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 double val2 ;
4890 int ecode2 = 0 ;
4891 PyObject *swig_obj[2] ;
4892
4893 (void)self;
4894 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4896 if (!SWIG_IsOK(res1)) {
4897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4898 }
4899 arg1 = (PLGraphicsIn *)(argp1);
4900 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4901 if (!SWIG_IsOK(ecode2)) {
4902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4903 }
4904 arg2 = (PLFLT)(val2);
4905 if (arg1) (arg1)->dX = arg2;
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908fail:
4909 return NULL;
4910}
4911
4912
4913SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4914 PyObject *resultobj = 0;
4915 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4916 void *argp1 = 0 ;
4917 int res1 = 0 ;
4918 PyObject *swig_obj[1] ;
4919 PLFLT result;
4920
4921 (void)self;
4922 if (!args) SWIG_fail;
4923 swig_obj[0] = args;
4924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4925 if (!SWIG_IsOK(res1)) {
4926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4927 }
4928 arg1 = (PLGraphicsIn *)(argp1);
4929 result = (PLFLT) ((arg1)->dX);
4930 resultobj = SWIG_From_double((double)(result));
4931 return resultobj;
4932fail:
4933 return NULL;
4934}
4935
4936
4937SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4938 PyObject *resultobj = 0;
4939 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4940 PLFLT arg2 ;
4941 void *argp1 = 0 ;
4942 int res1 = 0 ;
4943 double val2 ;
4944 int ecode2 = 0 ;
4945 PyObject *swig_obj[2] ;
4946
4947 (void)self;
4948 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4952 }
4953 arg1 = (PLGraphicsIn *)(argp1);
4954 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4957 }
4958 arg2 = (PLFLT)(val2);
4959 if (arg1) (arg1)->dY = arg2;
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962fail:
4963 return NULL;
4964}
4965
4966
4967SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4968 PyObject *resultobj = 0;
4969 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4970 void *argp1 = 0 ;
4971 int res1 = 0 ;
4972 PyObject *swig_obj[1] ;
4973 PLFLT result;
4974
4975 (void)self;
4976 if (!args) SWIG_fail;
4977 swig_obj[0] = args;
4978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4981 }
4982 arg1 = (PLGraphicsIn *)(argp1);
4983 result = (PLFLT) ((arg1)->dY);
4984 resultobj = SWIG_From_double((double)(result));
4985 return resultobj;
4986fail:
4987 return NULL;
4988}
4989
4990
4991SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4992 PyObject *resultobj = 0;
4993 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4994 PLFLT arg2 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 double val2 ;
4998 int ecode2 = 0 ;
4999 PyObject *swig_obj[2] ;
5000
5001 (void)self;
5002 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
5003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5004 if (!SWIG_IsOK(res1)) {
5005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5006 }
5007 arg1 = (PLGraphicsIn *)(argp1);
5008 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5009 if (!SWIG_IsOK(ecode2)) {
5010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
5011 }
5012 arg2 = (PLFLT)(val2);
5013 if (arg1) (arg1)->wX = arg2;
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016fail:
5017 return NULL;
5018}
5019
5020
5021SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
5022 PyObject *resultobj = 0;
5023 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 PyObject *swig_obj[1] ;
5027 PLFLT result;
5028
5029 (void)self;
5030 if (!args) SWIG_fail;
5031 swig_obj[0] = args;
5032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5033 if (!SWIG_IsOK(res1)) {
5034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5035 }
5036 arg1 = (PLGraphicsIn *)(argp1);
5037 result = (PLFLT) ((arg1)->wX);
5038 resultobj = SWIG_From_double((double)(result));
5039 return resultobj;
5040fail:
5041 return NULL;
5042}
5043
5044
5045SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5046 PyObject *resultobj = 0;
5047 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5048 PLFLT arg2 ;
5049 void *argp1 = 0 ;
5050 int res1 = 0 ;
5051 double val2 ;
5052 int ecode2 = 0 ;
5053 PyObject *swig_obj[2] ;
5054
5055 (void)self;
5056 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5058 if (!SWIG_IsOK(res1)) {
5059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5060 }
5061 arg1 = (PLGraphicsIn *)(argp1);
5062 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5063 if (!SWIG_IsOK(ecode2)) {
5064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5065 }
5066 arg2 = (PLFLT)(val2);
5067 if (arg1) (arg1)->wY = arg2;
5068 resultobj = SWIG_Py_Void();
5069 return resultobj;
5070fail:
5071 return NULL;
5072}
5073
5074
5075SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5076 PyObject *resultobj = 0;
5077 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5078 void *argp1 = 0 ;
5079 int res1 = 0 ;
5080 PyObject *swig_obj[1] ;
5081 PLFLT result;
5082
5083 (void)self;
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5089 }
5090 arg1 = (PLGraphicsIn *)(argp1);
5091 result = (PLFLT) ((arg1)->wY);
5092 resultobj = SWIG_From_double((double)(result));
5093 return resultobj;
5094fail:
5095 return NULL;
5096}
5097
5098
5099SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5100 PyObject *resultobj = 0;
5101 PLGraphicsIn *result = 0 ;
5102
5103 (void)self;
5104 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5105 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5107 return resultobj;
5108fail:
5109 return NULL;
5110}
5111
5112
5113SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5114 PyObject *resultobj = 0;
5115 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5116 void *argp1 = 0 ;
5117 int res1 = 0 ;
5118 PyObject *swig_obj[1] ;
5119
5120 (void)self;
5121 if (!args) SWIG_fail;
5122 swig_obj[0] = args;
5123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5124 if (!SWIG_IsOK(res1)) {
5125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5126 }
5127 arg1 = (PLGraphicsIn *)(argp1);
5128 free((char *) arg1);
5129 resultobj = SWIG_Py_Void();
5130 return resultobj;
5131fail:
5132 return NULL;
5133}
5134
5135
5136SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *obj;
5138 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5140 return SWIG_Py_Void();
5141}
5142
5143SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5144 return SWIG_Python_InitShadowInstance(args);
5145}
5146
5147SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5148 PyObject *resultobj = 0;
5149 PLINT arg1 ;
5150 int val1 ;
5151 int ecode1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 (void)self;
5155 if (!args) SWIG_fail;
5156 swig_obj[0] = args;
5157 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5158 if (!SWIG_IsOK(ecode1)) {
5159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5160 }
5161 arg1 = (PLINT)(val1);
5162 plsxwin(arg1);
5163 resultobj = SWIG_Py_Void();
5164 return resultobj;
5165fail:
5166 return NULL;
5167}
5168
5169
5170SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5171 PyObject *resultobj = 0;
5172 PLINT arg1 ;
5173 PLINT arg2 ;
5174 int val1 ;
5175 int ecode1 = 0 ;
5176 int val2 ;
5177 int ecode2 = 0 ;
5178 PyObject *swig_obj[2] ;
5179
5180 (void)self;
5181 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5182 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5183 if (!SWIG_IsOK(ecode1)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5185 }
5186 arg1 = (PLINT)(val1);
5187 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5188 if (!SWIG_IsOK(ecode2)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5190 }
5191 arg2 = (PLINT)(val2);
5192 pl_setcontlabelformat(arg1,arg2);
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195fail:
5196 return NULL;
5197}
5198
5199
5200SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5201 PyObject *resultobj = 0;
5202 PLFLT arg1 ;
5203 PLFLT arg2 ;
5204 PLFLT arg3 ;
5205 PLINT arg4 ;
5206 double val1 ;
5207 int ecode1 = 0 ;
5208 double val2 ;
5209 int ecode2 = 0 ;
5210 double val3 ;
5211 int ecode3 = 0 ;
5212 int val4 ;
5213 int ecode4 = 0 ;
5214 PyObject *swig_obj[4] ;
5215
5216 (void)self;
5217 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5218 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5219 if (!SWIG_IsOK(ecode1)) {
5220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5221 }
5222 arg1 = (PLFLT)(val1);
5223 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5224 if (!SWIG_IsOK(ecode2)) {
5225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5226 }
5227 arg2 = (PLFLT)(val2);
5228 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5229 if (!SWIG_IsOK(ecode3)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5231 }
5232 arg3 = (PLFLT)(val3);
5233 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5234 if (!SWIG_IsOK(ecode4)) {
5235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5236 }
5237 arg4 = (PLINT)(val4);
5238 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5239 resultobj = SWIG_Py_Void();
5240 return resultobj;
5241fail:
5242 return NULL;
5243}
5244
5245
5246SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5247 PyObject *resultobj = 0;
5248 PLINT arg1 ;
5249 int val1 ;
5250 int ecode1 = 0 ;
5251 PyObject *swig_obj[1] ;
5252
5253 (void)self;
5254 if (!args) SWIG_fail;
5255 swig_obj[0] = args;
5256 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5257 if (!SWIG_IsOK(ecode1)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5259 }
5260 arg1 = (PLINT)(val1);
5261 pladv(arg1);
5262 resultobj = SWIG_Py_Void();
5263 return resultobj;
5264fail:
5265 return NULL;
5266}
5267
5268
5269SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5270 PyObject *resultobj = 0;
5271 PLFLT arg1 ;
5272 PLFLT arg2 ;
5273 PLFLT arg3 ;
5274 PLFLT arg4 ;
5275 PLFLT arg5 ;
5276 PLFLT arg6 ;
5277 PLFLT arg7 ;
5278 PLBOOL arg8 ;
5279 double val1 ;
5280 int ecode1 = 0 ;
5281 double val2 ;
5282 int ecode2 = 0 ;
5283 double val3 ;
5284 int ecode3 = 0 ;
5285 double val4 ;
5286 int ecode4 = 0 ;
5287 double val5 ;
5288 int ecode5 = 0 ;
5289 double val6 ;
5290 int ecode6 = 0 ;
5291 double val7 ;
5292 int ecode7 = 0 ;
5293 int val8 ;
5294 int ecode8 = 0 ;
5295 PyObject *swig_obj[8] ;
5296
5297 (void)self;
5298 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5299 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5300 if (!SWIG_IsOK(ecode1)) {
5301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5302 }
5303 arg1 = (PLFLT)(val1);
5304 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5305 if (!SWIG_IsOK(ecode2)) {
5306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5307 }
5308 arg2 = (PLFLT)(val2);
5309 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5310 if (!SWIG_IsOK(ecode3)) {
5311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5312 }
5313 arg3 = (PLFLT)(val3);
5314 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5315 if (!SWIG_IsOK(ecode4)) {
5316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5317 }
5318 arg4 = (PLFLT)(val4);
5319 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5320 if (!SWIG_IsOK(ecode5)) {
5321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5322 }
5323 arg5 = (PLFLT)(val5);
5324 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5325 if (!SWIG_IsOK(ecode6)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5327 }
5328 arg6 = (PLFLT)(val6);
5329 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5330 if (!SWIG_IsOK(ecode7)) {
5331 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5332 }
5333 arg7 = (PLFLT)(val7);
5334 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5335 if (!SWIG_IsOK(ecode8)) {
5336 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5337 }
5338 arg8 = (PLBOOL)(val8);
5339 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5340 resultobj = SWIG_Py_Void();
5341 return resultobj;
5342fail:
5343 return NULL;
5344}
5345
5346
5347SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5348 PyObject *resultobj = 0;
5349 PLFLT arg1 ;
5350 PLFLT arg2 ;
5351 char *arg3 = (char *) 0 ;
5352 PLFLT arg4 ;
5353 PLINT arg5 ;
5354 char *arg6 = (char *) 0 ;
5355 PLFLT arg7 ;
5356 PLINT arg8 ;
5357 double val1 ;
5358 int ecode1 = 0 ;
5359 double val2 ;
5360 int ecode2 = 0 ;
5361 int res3 ;
5362 char *buf3 = 0 ;
5363 int alloc3 = 0 ;
5364 double val4 ;
5365 int ecode4 = 0 ;
5366 int val5 ;
5367 int ecode5 = 0 ;
5368 int res6 ;
5369 char *buf6 = 0 ;
5370 int alloc6 = 0 ;
5371 double val7 ;
5372 int ecode7 = 0 ;
5373 int val8 ;
5374 int ecode8 = 0 ;
5375 PyObject *swig_obj[8] ;
5376
5377 (void)self;
5378 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5379 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5380 if (!SWIG_IsOK(ecode1)) {
5381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5382 }
5383 arg1 = (PLFLT)(val1);
5384 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5385 if (!SWIG_IsOK(ecode2)) {
5386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5387 }
5388 arg2 = (PLFLT)(val2);
5389 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5390 if (!SWIG_IsOK(res3)) {
5391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5392 }
5393 arg3 = (char *)(buf3);
5394 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5395 if (!SWIG_IsOK(ecode4)) {
5396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5397 }
5398 arg4 = (PLFLT)(val4);
5399 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5400 if (!SWIG_IsOK(ecode5)) {
5401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5402 }
5403 arg5 = (PLINT)(val5);
5404 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5405 if (!SWIG_IsOK(res6)) {
5406 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5407 }
5408 arg6 = (char *)(buf6);
5409 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5410 if (!SWIG_IsOK(ecode7)) {
5411 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5412 }
5413 arg7 = (PLFLT)(val7);
5414 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5415 if (!SWIG_IsOK(ecode8)) {
5416 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5417 }
5418 arg8 = (PLINT)(val8);
5419 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5420 resultobj = SWIG_Py_Void();
5421 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5422 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5423 return resultobj;
5424fail:
5425 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5426 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5427 return NULL;
5428}
5429
5430
5431SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5432 PyObject *resultobj = 0;
5433 PLINT arg1 ;
5434 PLFLT *arg2 = (PLFLT *) 0 ;
5435 PLFLT *arg3 = (PLFLT *) 0 ;
5436 PLINT arg4 ;
5437 PyArrayObject *tmp1 = NULL ;
5438 PyArrayObject *tmp3 = NULL ;
5439 int val4 ;
5440 int ecode4 = 0 ;
5441 PyObject *swig_obj[3] ;
5442
5443 (void)self;
5444 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5445 {
5446 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5447 if ( tmp1 == NULL )
5448 return NULL;
5449 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5450 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5451 }
5452 {
5453 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5454 if ( tmp3 == NULL )
5455 return NULL;
5456 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5457 {
5458 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5459 return NULL;
5460 }
5461 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5462 }
5463 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5464 if (!SWIG_IsOK(ecode4)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5466 }
5467 arg4 = (PLINT)(val4);
5468 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5469 resultobj = SWIG_Py_Void();
5470 {
5471 Py_CLEAR( tmp1 );
5472 }
5473 {
5474 Py_CLEAR( tmp3 );
5475 }
5476 return resultobj;
5477fail:
5478 {
5479 Py_CLEAR( tmp1 );
5480 }
5481 {
5482 Py_CLEAR( tmp3 );
5483 }
5484 return NULL;
5485}
5486
5487
5488SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5489 PyObject *resultobj = 0;
5490 PLINT *arg1 = (PLINT *) 0 ;
5491 PLINT *arg2 = (PLINT *) 0 ;
5492 PLINT *arg3 = (PLINT *) 0 ;
5493 PLINT *arg4 = (PLINT *) 0 ;
5494 PLINT *arg5 = (PLINT *) 0 ;
5495 PLFLT *arg6 = (PLFLT *) 0 ;
5496 PLFLT arg7 ;
5497 PLINT temp1 ;
5498 int res1 = SWIG_TMPOBJ ;
5499 PLINT temp2 ;
5500 int res2 = SWIG_TMPOBJ ;
5501 PLINT temp3 ;
5502 int res3 = SWIG_TMPOBJ ;
5503 PLINT temp4 ;
5504 int res4 = SWIG_TMPOBJ ;
5505 PLINT temp5 ;
5506 int res5 = SWIG_TMPOBJ ;
5507 PLFLT temp6 ;
5508 int res6 = SWIG_TMPOBJ ;
5509 double val7 ;
5510 int ecode7 = 0 ;
5511 PyObject *swig_obj[1] ;
5512
5513 arg1 = &temp1;
5514 arg2 = &temp2;
5515 arg3 = &temp3;
5516 arg4 = &temp4;
5517 arg5 = &temp5;
5518 arg6 = &temp6;
5519 (void)self;
5520 if (!args) SWIG_fail;
5521 swig_obj[0] = args;
5522 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5523 if (!SWIG_IsOK(ecode7)) {
5524 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5525 }
5526 arg7 = (PLFLT)(val7);
5527 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5528 resultobj = SWIG_Py_Void();
5529 if (SWIG_IsTmpObj(res1)) {
5530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
5531 } else {
5532 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
5534 }
5535 if (SWIG_IsTmpObj(res2)) {
5536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
5537 } else {
5538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
5540 }
5541 if (SWIG_IsTmpObj(res3)) {
5542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
5543 } else {
5544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
5546 }
5547 if (SWIG_IsTmpObj(res4)) {
5548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
5549 } else {
5550 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
5552 }
5553 if (SWIG_IsTmpObj(res5)) {
5554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5555 } else {
5556 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5558 }
5559 if (SWIG_IsTmpObj(res6)) {
5560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
5561 } else {
5562 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
5564 }
5565 return resultobj;
5566fail:
5567 return NULL;
5568}
5569
5570
5571SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5572 PyObject *resultobj = 0;
5573
5574 (void)self;
5575 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5576 plbop();
5577 resultobj = SWIG_Py_Void();
5578 return resultobj;
5579fail:
5580 return NULL;
5581}
5582
5583
5584SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5585 PyObject *resultobj = 0;
5586 char *arg1 = (char *) 0 ;
5587 PLFLT arg2 ;
5588 PLINT arg3 ;
5589 char *arg4 = (char *) 0 ;
5590 PLFLT arg5 ;
5591 PLINT arg6 ;
5592 int res1 ;
5593 char *buf1 = 0 ;
5594 int alloc1 = 0 ;
5595 double val2 ;
5596 int ecode2 = 0 ;
5597 int val3 ;
5598 int ecode3 = 0 ;
5599 int res4 ;
5600 char *buf4 = 0 ;
5601 int alloc4 = 0 ;
5602 double val5 ;
5603 int ecode5 = 0 ;
5604 int val6 ;
5605 int ecode6 = 0 ;
5606 PyObject *swig_obj[6] ;
5607
5608 (void)self;
5609 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5610 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5613 }
5614 arg1 = (char *)(buf1);
5615 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5616 if (!SWIG_IsOK(ecode2)) {
5617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5618 }
5619 arg2 = (PLFLT)(val2);
5620 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5621 if (!SWIG_IsOK(ecode3)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5623 }
5624 arg3 = (PLINT)(val3);
5625 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5626 if (!SWIG_IsOK(res4)) {
5627 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5628 }
5629 arg4 = (char *)(buf4);
5630 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5631 if (!SWIG_IsOK(ecode5)) {
5632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5633 }
5634 arg5 = (PLFLT)(val5);
5635 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5636 if (!SWIG_IsOK(ecode6)) {
5637 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5638 }
5639 arg6 = (PLINT)(val6);
5640 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5641 resultobj = SWIG_Py_Void();
5642 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5643 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5644 return resultobj;
5645fail:
5646 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5647 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5648 return NULL;
5649}
5650
5651
5652SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5653 PyObject *resultobj = 0;
5654 char *arg1 = (char *) 0 ;
5655 char *arg2 = (char *) 0 ;
5656 PLFLT arg3 ;
5657 PLINT arg4 ;
5658 char *arg5 = (char *) 0 ;
5659 char *arg6 = (char *) 0 ;
5660 PLFLT arg7 ;
5661 PLINT arg8 ;
5662 char *arg9 = (char *) 0 ;
5663 char *arg10 = (char *) 0 ;
5664 PLFLT arg11 ;
5665 PLINT arg12 ;
5666 int res1 ;
5667 char *buf1 = 0 ;
5668 int alloc1 = 0 ;
5669 int res2 ;
5670 char *buf2 = 0 ;
5671 int alloc2 = 0 ;
5672 double val3 ;
5673 int ecode3 = 0 ;
5674 int val4 ;
5675 int ecode4 = 0 ;
5676 int res5 ;
5677 char *buf5 = 0 ;
5678 int alloc5 = 0 ;
5679 int res6 ;
5680 char *buf6 = 0 ;
5681 int alloc6 = 0 ;
5682 double val7 ;
5683 int ecode7 = 0 ;
5684 int val8 ;
5685 int ecode8 = 0 ;
5686 int res9 ;
5687 char *buf9 = 0 ;
5688 int alloc9 = 0 ;
5689 int res10 ;
5690 char *buf10 = 0 ;
5691 int alloc10 = 0 ;
5692 double val11 ;
5693 int ecode11 = 0 ;
5694 int val12 ;
5695 int ecode12 = 0 ;
5696 PyObject *swig_obj[12] ;
5697
5698 (void)self;
5699 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5700 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5701 if (!SWIG_IsOK(res1)) {
5702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5703 }
5704 arg1 = (char *)(buf1);
5705 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5706 if (!SWIG_IsOK(res2)) {
5707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5708 }
5709 arg2 = (char *)(buf2);
5710 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5711 if (!SWIG_IsOK(ecode3)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5713 }
5714 arg3 = (PLFLT)(val3);
5715 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5716 if (!SWIG_IsOK(ecode4)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5718 }
5719 arg4 = (PLINT)(val4);
5720 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5721 if (!SWIG_IsOK(res5)) {
5722 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5723 }
5724 arg5 = (char *)(buf5);
5725 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5726 if (!SWIG_IsOK(res6)) {
5727 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5728 }
5729 arg6 = (char *)(buf6);
5730 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5731 if (!SWIG_IsOK(ecode7)) {
5732 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5733 }
5734 arg7 = (PLFLT)(val7);
5735 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5736 if (!SWIG_IsOK(ecode8)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5738 }
5739 arg8 = (PLINT)(val8);
5740 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5741 if (!SWIG_IsOK(res9)) {
5742 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5743 }
5744 arg9 = (char *)(buf9);
5745 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5746 if (!SWIG_IsOK(res10)) {
5747 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5748 }
5749 arg10 = (char *)(buf10);
5750 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5751 if (!SWIG_IsOK(ecode11)) {
5752 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5753 }
5754 arg11 = (PLFLT)(val11);
5755 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5756 if (!SWIG_IsOK(ecode12)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5758 }
5759 arg12 = (PLINT)(val12);
5760 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);
5761 resultobj = SWIG_Py_Void();
5762 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5763 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5764 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5765 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5766 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5767 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5768 return resultobj;
5769fail:
5770 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5771 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5772 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5773 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5774 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5775 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5776 return NULL;
5777}
5778
5779
5780SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5781 PyObject *resultobj = 0;
5782 PLFLT arg1 ;
5783 PLFLT arg2 ;
5784 PLFLT *arg3 = (PLFLT *) 0 ;
5785 PLFLT *arg4 = (PLFLT *) 0 ;
5786 PLINT *arg5 = (PLINT *) 0 ;
5787 double val1 ;
5788 int ecode1 = 0 ;
5789 double val2 ;
5790 int ecode2 = 0 ;
5791 PLFLT temp3 ;
5792 int res3 = SWIG_TMPOBJ ;
5793 PLFLT temp4 ;
5794 int res4 = SWIG_TMPOBJ ;
5795 PLINT temp5 ;
5796 int res5 = SWIG_TMPOBJ ;
5797 PyObject *swig_obj[2] ;
5798
5799 arg3 = &temp3;
5800 arg4 = &temp4;
5801 arg5 = &temp5;
5802 (void)self;
5803 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5804 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5805 if (!SWIG_IsOK(ecode1)) {
5806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5807 }
5808 arg1 = (PLFLT)(val1);
5809 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5810 if (!SWIG_IsOK(ecode2)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5812 }
5813 arg2 = (PLFLT)(val2);
5814 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5815 resultobj = SWIG_Py_Void();
5816 if (SWIG_IsTmpObj(res3)) {
5817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
5818 } else {
5819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
5821 }
5822 if (SWIG_IsTmpObj(res4)) {
5823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
5824 } else {
5825 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
5827 }
5828 if (SWIG_IsTmpObj(res5)) {
5829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5830 } else {
5831 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5833 }
5834 return resultobj;
5835fail:
5836 return NULL;
5837}
5838
5839
5840SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5841 PyObject *resultobj = 0;
5842
5843 (void)self;
5844 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5845 plclear();
5846 resultobj = SWIG_Py_Void();
5847 return resultobj;
5848fail:
5849 return NULL;
5850}
5851
5852
5853SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5854 PyObject *resultobj = 0;
5855 PLINT arg1 ;
5856 int val1 ;
5857 int ecode1 = 0 ;
5858 PyObject *swig_obj[1] ;
5859
5860 (void)self;
5861 if (!args) SWIG_fail;
5862 swig_obj[0] = args;
5863 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5864 if (!SWIG_IsOK(ecode1)) {
5865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5866 }
5867 arg1 = (PLINT)(val1);
5868 plcol0(arg1);
5869 resultobj = SWIG_Py_Void();
5870 return resultobj;
5871fail:
5872 return NULL;
5873}
5874
5875
5876SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5877 PyObject *resultobj = 0;
5878 PLFLT arg1 ;
5879 double val1 ;
5880 int ecode1 = 0 ;
5881 PyObject *swig_obj[1] ;
5882
5883 (void)self;
5884 if (!args) SWIG_fail;
5885 swig_obj[0] = args;
5886 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5887 if (!SWIG_IsOK(ecode1)) {
5888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5889 }
5890 arg1 = (PLFLT)(val1);
5891 plcol1(arg1);
5892 resultobj = SWIG_Py_Void();
5893 return resultobj;
5894fail:
5895 return NULL;
5896}
5897
5898
5899SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5900 PyObject *resultobj = 0;
5901 PLFLT arg1 ;
5902 PLFLT arg2 ;
5903 PLFLT arg3 ;
5904 PLINT arg4 ;
5905 PLBOOL arg5 ;
5906 PLINT arg6 ;
5907 PLINT arg7 ;
5908 PLINT arg8 ;
5909 PLINT arg9 ;
5910 PLINT arg10 ;
5911 PLFLT arg11 ;
5912 double val1 ;
5913 int ecode1 = 0 ;
5914 double val2 ;
5915 int ecode2 = 0 ;
5916 double val3 ;
5917 int ecode3 = 0 ;
5918 int val4 ;
5919 int ecode4 = 0 ;
5920 int val5 ;
5921 int ecode5 = 0 ;
5922 int val6 ;
5923 int ecode6 = 0 ;
5924 int val7 ;
5925 int ecode7 = 0 ;
5926 int val8 ;
5927 int ecode8 = 0 ;
5928 int val9 ;
5929 int ecode9 = 0 ;
5930 int val10 ;
5931 int ecode10 = 0 ;
5932 double val11 ;
5933 int ecode11 = 0 ;
5934 PyObject *swig_obj[11] ;
5935
5936 (void)self;
5937 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5938 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5939 if (!SWIG_IsOK(ecode1)) {
5940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5941 }
5942 arg1 = (PLFLT)(val1);
5943 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5944 if (!SWIG_IsOK(ecode2)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5946 }
5947 arg2 = (PLFLT)(val2);
5948 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5949 if (!SWIG_IsOK(ecode3)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5951 }
5952 arg3 = (PLFLT)(val3);
5953 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5954 if (!SWIG_IsOK(ecode4)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5956 }
5957 arg4 = (PLINT)(val4);
5958 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5959 if (!SWIG_IsOK(ecode5)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5961 }
5962 arg5 = (PLBOOL)(val5);
5963 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5964 if (!SWIG_IsOK(ecode6)) {
5965 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5966 }
5967 arg6 = (PLINT)(val6);
5968 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5969 if (!SWIG_IsOK(ecode7)) {
5970 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5971 }
5972 arg7 = (PLINT)(val7);
5973 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5974 if (!SWIG_IsOK(ecode8)) {
5975 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5976 }
5977 arg8 = (PLINT)(val8);
5978 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5979 if (!SWIG_IsOK(ecode9)) {
5980 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5981 }
5982 arg9 = (PLINT)(val9);
5983 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5984 if (!SWIG_IsOK(ecode10)) {
5985 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5986 }
5987 arg10 = (PLINT)(val10);
5988 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5989 if (!SWIG_IsOK(ecode11)) {
5990 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5991 }
5992 arg11 = (PLFLT)(val11);
5993 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5994 resultobj = SWIG_Py_Void();
5995 return resultobj;
5996fail:
5997 return NULL;
5998}
5999
6000
6001SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
6002 PyObject *resultobj = 0;
6003 PLFLT **arg1 = (PLFLT **) 0 ;
6004 PLINT arg2 ;
6005 PLINT arg3 ;
6006 PLINT arg4 ;
6007 PLINT arg5 ;
6008 PLINT arg6 ;
6009 PLINT arg7 ;
6010 PLFLT *arg8 = (PLFLT *) 0 ;
6011 PLINT arg9 ;
6012 pltr_func arg10 = (pltr_func) 0 ;
6013 PLPointer arg11 = (PLPointer) 0 ;
6014 PyArrayObject *tmp1 = NULL ;
6015 int val4 ;
6016 int ecode4 = 0 ;
6017 int val5 ;
6018 int ecode5 = 0 ;
6019 int val6 ;
6020 int ecode6 = 0 ;
6021 int val7 ;
6022 int ecode7 = 0 ;
6023 PyArrayObject *tmp8 = NULL ;
6024 PyObject *swig_obj[8] ;
6025
6026 {
6027 python_pltr = 0;
6028 arg10 = NULL;
6029 }
6030 {
6031 arg11 = NULL;
6032 }
6033 (void)self;
6034 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6035 {
6036 int i, size;
6037 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6038 if ( tmp1 == NULL )
6039 return NULL;
6040 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6041 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6042 size = arg3;
6043 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6044 for ( i = 0; i < arg2; i++ )
6045 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6046 }
6047 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6048 if (!SWIG_IsOK(ecode4)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6050 }
6051 arg4 = (PLINT)(val4);
6052 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6053 if (!SWIG_IsOK(ecode5)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6055 }
6056 arg5 = (PLINT)(val5);
6057 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6058 if (!SWIG_IsOK(ecode6)) {
6059 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6060 }
6061 arg6 = (PLINT)(val6);
6062 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6063 if (!SWIG_IsOK(ecode7)) {
6064 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6065 }
6066 arg7 = (PLINT)(val7);
6067 {
6068 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6069 if ( tmp8 == NULL )
6070 return NULL;
6071 arg9 = PyArray_DIMS( tmp8 )[0];
6072 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6073 }
6074 if (swig_obj[6]) {
6075 {
6076 // it must be a callable or None
6077 if ( swig_obj[6] == Py_None )
6078 {
6079 arg10 = NULL;
6080 }
6081 else
6082 {
6083 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6084 {
6085 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6086 return NULL;
6087 }
6088 arg10 = marshal_pltr( swig_obj[6] );
6089 }
6090 }
6091 }
6092 if (swig_obj[7]) {
6093 {
6094 if ( swig_obj[7] == Py_None )
6095 arg11 = NULL;
6096 else
6097 {
6098 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6099 }
6100 }
6101 }
6102 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6103 resultobj = SWIG_Py_Void();
6104 {
6105 Py_CLEAR( tmp1 );
6106 free( arg1 );
6107 }
6108 {
6109 Py_CLEAR( tmp8 );
6110 }
6111 {
6112 cleanup_pltr();
6113 }
6114 {
6116 }
6117 return resultobj;
6118fail:
6119 {
6120 Py_CLEAR( tmp1 );
6121 free( arg1 );
6122 }
6123 {
6124 Py_CLEAR( tmp8 );
6125 }
6126 {
6127 cleanup_pltr();
6128 }
6129 {
6131 }
6132 return NULL;
6133}
6134
6135
6136SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6137 PyObject *resultobj = 0;
6138 PLINT arg1 ;
6139 PLINT arg2 ;
6140 PLINT arg3 ;
6141 PLINT arg4 ;
6142 PLINT arg5 ;
6143 PLFLT arg6 ;
6144 PLFLT *arg7 = (PLFLT *) 0 ;
6145 int val1 ;
6146 int ecode1 = 0 ;
6147 int val2 ;
6148 int ecode2 = 0 ;
6149 int val3 ;
6150 int ecode3 = 0 ;
6151 int val4 ;
6152 int ecode4 = 0 ;
6153 int val5 ;
6154 int ecode5 = 0 ;
6155 double val6 ;
6156 int ecode6 = 0 ;
6157 PLFLT temp7 ;
6158 int res7 = SWIG_TMPOBJ ;
6159 PyObject *swig_obj[6] ;
6160
6161 arg7 = &temp7;
6162 (void)self;
6163 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6164 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6165 if (!SWIG_IsOK(ecode1)) {
6166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6167 }
6168 arg1 = (PLINT)(val1);
6169 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6170 if (!SWIG_IsOK(ecode2)) {
6171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6172 }
6173 arg2 = (PLINT)(val2);
6174 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6175 if (!SWIG_IsOK(ecode3)) {
6176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6177 }
6178 arg3 = (PLINT)(val3);
6179 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6180 if (!SWIG_IsOK(ecode4)) {
6181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6182 }
6183 arg4 = (PLINT)(val4);
6184 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6185 if (!SWIG_IsOK(ecode5)) {
6186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6187 }
6188 arg5 = (PLINT)(val5);
6189 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6190 if (!SWIG_IsOK(ecode6)) {
6191 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6192 }
6193 arg6 = (PLFLT)(val6);
6194 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6195 resultobj = SWIG_Py_Void();
6196 if (SWIG_IsTmpObj(res7)) {
6197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)), 1);
6198 } else {
6199 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags), 1);
6201 }
6202 return resultobj;
6203fail:
6204 return NULL;
6205}
6206
6207
6208SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6209 PyObject *resultobj = 0;
6210 PLINT arg1 ;
6211 PLBOOL arg2 ;
6212 int val1 ;
6213 int ecode1 = 0 ;
6214 int val2 ;
6215 int ecode2 = 0 ;
6216 PyObject *swig_obj[2] ;
6217
6218 (void)self;
6219 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6220 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6221 if (!SWIG_IsOK(ecode1)) {
6222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6223 }
6224 arg1 = (PLINT)(val1);
6225 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6226 if (!SWIG_IsOK(ecode2)) {
6227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6228 }
6229 arg2 = (PLBOOL)(val2);
6230 plcpstrm(arg1,arg2);
6231 resultobj = SWIG_Py_Void();
6232 return resultobj;
6233fail:
6234 return NULL;
6235}
6236
6237
6238SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6239 PyObject *resultobj = 0;
6240
6241 (void)self;
6242 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6243 plend();
6244 resultobj = SWIG_Py_Void();
6245 return resultobj;
6246fail:
6247 return NULL;
6248}
6249
6250
6251SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6252 PyObject *resultobj = 0;
6253
6254 (void)self;
6255 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6256 plend1();
6257 resultobj = SWIG_Py_Void();
6258 return resultobj;
6259fail:
6260 return NULL;
6261}
6262
6263
6264SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6265 PyObject *resultobj = 0;
6266 PLFLT arg1 ;
6267 PLFLT arg2 ;
6268 PLFLT arg3 ;
6269 PLFLT arg4 ;
6270 PLINT arg5 ;
6271 PLINT arg6 ;
6272 double val1 ;
6273 int ecode1 = 0 ;
6274 double val2 ;
6275 int ecode2 = 0 ;
6276 double val3 ;
6277 int ecode3 = 0 ;
6278 double val4 ;
6279 int ecode4 = 0 ;
6280 int val5 ;
6281 int ecode5 = 0 ;
6282 int val6 ;
6283 int ecode6 = 0 ;
6284 PyObject *swig_obj[6] ;
6285
6286 (void)self;
6287 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6288 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6289 if (!SWIG_IsOK(ecode1)) {
6290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6291 }
6292 arg1 = (PLFLT)(val1);
6293 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6294 if (!SWIG_IsOK(ecode2)) {
6295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6296 }
6297 arg2 = (PLFLT)(val2);
6298 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6299 if (!SWIG_IsOK(ecode3)) {
6300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6301 }
6302 arg3 = (PLFLT)(val3);
6303 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6304 if (!SWIG_IsOK(ecode4)) {
6305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6306 }
6307 arg4 = (PLFLT)(val4);
6308 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6309 if (!SWIG_IsOK(ecode5)) {
6310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6311 }
6312 arg5 = (PLINT)(val5);
6313 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6314 if (!SWIG_IsOK(ecode6)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6316 }
6317 arg6 = (PLINT)(val6);
6318 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6319 resultobj = SWIG_Py_Void();
6320 return resultobj;
6321fail:
6322 return NULL;
6323}
6324
6325
6326SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6327 PyObject *resultobj = 0;
6328 PLFLT arg1 ;
6329 PLFLT arg2 ;
6330 PLFLT arg3 ;
6331 PLFLT arg4 ;
6332 PLINT arg5 ;
6333 PLINT arg6 ;
6334 double val1 ;
6335 int ecode1 = 0 ;
6336 double val2 ;
6337 int ecode2 = 0 ;
6338 double val3 ;
6339 int ecode3 = 0 ;
6340 double val4 ;
6341 int ecode4 = 0 ;
6342 int val5 ;
6343 int ecode5 = 0 ;
6344 int val6 ;
6345 int ecode6 = 0 ;
6346 PyObject *swig_obj[6] ;
6347
6348 (void)self;
6349 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6350 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6351 if (!SWIG_IsOK(ecode1)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6353 }
6354 arg1 = (PLFLT)(val1);
6355 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6356 if (!SWIG_IsOK(ecode2)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6358 }
6359 arg2 = (PLFLT)(val2);
6360 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6361 if (!SWIG_IsOK(ecode3)) {
6362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6363 }
6364 arg3 = (PLFLT)(val3);
6365 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6366 if (!SWIG_IsOK(ecode4)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6368 }
6369 arg4 = (PLFLT)(val4);
6370 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6371 if (!SWIG_IsOK(ecode5)) {
6372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6373 }
6374 arg5 = (PLINT)(val5);
6375 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6376 if (!SWIG_IsOK(ecode6)) {
6377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6378 }
6379 arg6 = (PLINT)(val6);
6380 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6381 resultobj = SWIG_Py_Void();
6382 return resultobj;
6383fail:
6384 return NULL;
6385}
6386
6387
6388SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6389 PyObject *resultobj = 0;
6390
6391 (void)self;
6392 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6393 pleop();
6394 resultobj = SWIG_Py_Void();
6395 return resultobj;
6396fail:
6397 return NULL;
6398}
6399
6400
6401SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6402 PyObject *resultobj = 0;
6403 PLINT arg1 ;
6404 PLFLT *arg2 = (PLFLT *) 0 ;
6405 PLFLT *arg3 = (PLFLT *) 0 ;
6406 PLFLT *arg4 = (PLFLT *) 0 ;
6407 PyArrayObject *tmp1 = NULL ;
6408 PyArrayObject *tmp3 = NULL ;
6409 PyArrayObject *tmp4 = NULL ;
6410 PyObject *swig_obj[3] ;
6411
6412 (void)self;
6413 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6414 {
6415 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6416 if ( tmp1 == NULL )
6417 return NULL;
6418 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6419 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6420 }
6421 {
6422 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6423 if ( tmp3 == NULL )
6424 return NULL;
6425 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6426 {
6427 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6428 return NULL;
6429 }
6430 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6431 }
6432 {
6433 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6434 if ( tmp4 == NULL )
6435 return NULL;
6436 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6437 {
6438 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6439 return NULL;
6440 }
6441 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6442 }
6443 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6444 resultobj = SWIG_Py_Void();
6445 {
6446 Py_CLEAR( tmp1 );
6447 }
6448 {
6449 Py_CLEAR( tmp3 );
6450 }
6451 {
6452 Py_CLEAR( tmp4 );
6453 }
6454 return resultobj;
6455fail:
6456 {
6457 Py_CLEAR( tmp1 );
6458 }
6459 {
6460 Py_CLEAR( tmp3 );
6461 }
6462 {
6463 Py_CLEAR( tmp4 );
6464 }
6465 return NULL;
6466}
6467
6468
6469SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6470 PyObject *resultobj = 0;
6471 PLINT arg1 ;
6472 PLFLT *arg2 = (PLFLT *) 0 ;
6473 PLFLT *arg3 = (PLFLT *) 0 ;
6474 PLFLT *arg4 = (PLFLT *) 0 ;
6475 PyArrayObject *tmp1 = NULL ;
6476 PyArrayObject *tmp3 = NULL ;
6477 PyArrayObject *tmp4 = NULL ;
6478 PyObject *swig_obj[3] ;
6479
6480 (void)self;
6481 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6482 {
6483 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6484 if ( tmp1 == NULL )
6485 return NULL;
6486 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6487 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6488 }
6489 {
6490 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6491 if ( tmp3 == NULL )
6492 return NULL;
6493 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6494 {
6495 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6496 return NULL;
6497 }
6498 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6499 }
6500 {
6501 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6502 if ( tmp4 == NULL )
6503 return NULL;
6504 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6505 {
6506 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6507 return NULL;
6508 }
6509 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6510 }
6511 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6512 resultobj = SWIG_Py_Void();
6513 {
6514 Py_CLEAR( tmp1 );
6515 }
6516 {
6517 Py_CLEAR( tmp3 );
6518 }
6519 {
6520 Py_CLEAR( tmp4 );
6521 }
6522 return resultobj;
6523fail:
6524 {
6525 Py_CLEAR( tmp1 );
6526 }
6527 {
6528 Py_CLEAR( tmp3 );
6529 }
6530 {
6531 Py_CLEAR( tmp4 );
6532 }
6533 return NULL;
6534}
6535
6536
6537SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6538 PyObject *resultobj = 0;
6539
6540 (void)self;
6541 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6542 plfamadv();
6543 resultobj = SWIG_Py_Void();
6544 return resultobj;
6545fail:
6546 return NULL;
6547}
6548
6549
6550SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6551 PyObject *resultobj = 0;
6552 PLINT arg1 ;
6553 PLFLT *arg2 = (PLFLT *) 0 ;
6554 PLFLT *arg3 = (PLFLT *) 0 ;
6555 PyArrayObject *tmp1 = NULL ;
6556 PyArrayObject *tmp3 = NULL ;
6557 PyObject *swig_obj[2] ;
6558
6559 (void)self;
6560 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6561 {
6562 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6563 if ( tmp1 == NULL )
6564 return NULL;
6565 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6566 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6567 }
6568 {
6569 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6570 if ( tmp3 == NULL )
6571 return NULL;
6572 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6573 {
6574 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6575 return NULL;
6576 }
6577 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6578 }
6579 plfill(arg1,(double const *)arg2,(double const *)arg3);
6580 resultobj = SWIG_Py_Void();
6581 {
6582 Py_CLEAR( tmp1 );
6583 }
6584 {
6585 Py_CLEAR( tmp3 );
6586 }
6587 return resultobj;
6588fail:
6589 {
6590 Py_CLEAR( tmp1 );
6591 }
6592 {
6593 Py_CLEAR( tmp3 );
6594 }
6595 return NULL;
6596}
6597
6598
6599SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6600 PyObject *resultobj = 0;
6601 PLINT arg1 ;
6602 PLFLT *arg2 = (PLFLT *) 0 ;
6603 PLFLT *arg3 = (PLFLT *) 0 ;
6604 PLFLT *arg4 = (PLFLT *) 0 ;
6605 PyArrayObject *tmp1 = NULL ;
6606 PyArrayObject *tmp3 = NULL ;
6607 PyArrayObject *tmp4 = NULL ;
6608 PyObject *swig_obj[3] ;
6609
6610 (void)self;
6611 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6612 {
6613 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6614 if ( tmp1 == NULL )
6615 return NULL;
6616 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6617 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6618 }
6619 {
6620 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6621 if ( tmp3 == NULL )
6622 return NULL;
6623 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6624 {
6625 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6626 return NULL;
6627 }
6628 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6629 }
6630 {
6631 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6632 if ( tmp4 == NULL )
6633 return NULL;
6634 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6635 {
6636 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6637 return NULL;
6638 }
6639 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6640 }
6641 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6642 resultobj = SWIG_Py_Void();
6643 {
6644 Py_CLEAR( tmp1 );
6645 }
6646 {
6647 Py_CLEAR( tmp3 );
6648 }
6649 {
6650 Py_CLEAR( tmp4 );
6651 }
6652 return resultobj;
6653fail:
6654 {
6655 Py_CLEAR( tmp1 );
6656 }
6657 {
6658 Py_CLEAR( tmp3 );
6659 }
6660 {
6661 Py_CLEAR( tmp4 );
6662 }
6663 return NULL;
6664}
6665
6666
6667SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6668 PyObject *resultobj = 0;
6669 PLINT arg1 ;
6670 PLFLT *arg2 = (PLFLT *) 0 ;
6671 PLFLT *arg3 = (PLFLT *) 0 ;
6672 PLFLT arg4 ;
6673 PyArrayObject *tmp1 = NULL ;
6674 PyArrayObject *tmp3 = NULL ;
6675 double val4 ;
6676 int ecode4 = 0 ;
6677 PyObject *swig_obj[3] ;
6678
6679 (void)self;
6680 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6681 {
6682 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6683 if ( tmp1 == NULL )
6684 return NULL;
6685 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6686 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6687 }
6688 {
6689 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6690 if ( tmp3 == NULL )
6691 return NULL;
6692 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6693 {
6694 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6695 return NULL;
6696 }
6697 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6698 }
6699 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6700 if (!SWIG_IsOK(ecode4)) {
6701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6702 }
6703 arg4 = (PLFLT)(val4);
6704 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6705 resultobj = SWIG_Py_Void();
6706 {
6707 Py_CLEAR( tmp1 );
6708 }
6709 {
6710 Py_CLEAR( tmp3 );
6711 }
6712 return resultobj;
6713fail:
6714 {
6715 Py_CLEAR( tmp1 );
6716 }
6717 {
6718 Py_CLEAR( tmp3 );
6719 }
6720 return NULL;
6721}
6722
6723
6724SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6725 PyObject *resultobj = 0;
6726
6727 (void)self;
6728 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6729 plflush();
6730 resultobj = SWIG_Py_Void();
6731 return resultobj;
6732fail:
6733 return NULL;
6734}
6735
6736
6737SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6738 PyObject *resultobj = 0;
6739 PLINT arg1 ;
6740 int val1 ;
6741 int ecode1 = 0 ;
6742 PyObject *swig_obj[1] ;
6743
6744 (void)self;
6745 if (!args) SWIG_fail;
6746 swig_obj[0] = args;
6747 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6748 if (!SWIG_IsOK(ecode1)) {
6749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6750 }
6751 arg1 = (PLINT)(val1);
6752 plfont(arg1);
6753 resultobj = SWIG_Py_Void();
6754 return resultobj;
6755fail:
6756 return NULL;
6757}
6758
6759
6760SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6761 PyObject *resultobj = 0;
6762 PLINT arg1 ;
6763 int val1 ;
6764 int ecode1 = 0 ;
6765 PyObject *swig_obj[1] ;
6766
6767 (void)self;
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6771 if (!SWIG_IsOK(ecode1)) {
6772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6773 }
6774 arg1 = (PLINT)(val1);
6775 plfontld(arg1);
6776 resultobj = SWIG_Py_Void();
6777 return resultobj;
6778fail:
6779 return NULL;
6780}
6781
6782
6783SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6784 PyObject *resultobj = 0;
6785 PLFLT *arg1 = (PLFLT *) 0 ;
6786 PLFLT *arg2 = (PLFLT *) 0 ;
6787 PLFLT temp1 ;
6788 int res1 = SWIG_TMPOBJ ;
6789 PLFLT temp2 ;
6790 int res2 = SWIG_TMPOBJ ;
6791
6792 arg1 = &temp1;
6793 arg2 = &temp2;
6794 (void)self;
6795 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6796 plgchr(arg1,arg2);
6797 resultobj = SWIG_Py_Void();
6798 if (SWIG_IsTmpObj(res1)) {
6799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
6800 } else {
6801 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
6803 }
6804 if (SWIG_IsTmpObj(res2)) {
6805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
6806 } else {
6807 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
6809 }
6810 return resultobj;
6811fail:
6812 return NULL;
6813}
6814
6815
6816SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6817 PyObject *resultobj = 0;
6818 PLINT arg1 ;
6819 PLINT *arg2 = (PLINT *) 0 ;
6820 PLINT *arg3 = (PLINT *) 0 ;
6821 PLINT *arg4 = (PLINT *) 0 ;
6822 int val1 ;
6823 int ecode1 = 0 ;
6824 PLINT temp2 ;
6825 int res2 = SWIG_TMPOBJ ;
6826 PLINT temp3 ;
6827 int res3 = SWIG_TMPOBJ ;
6828 PLINT temp4 ;
6829 int res4 = SWIG_TMPOBJ ;
6830 PyObject *swig_obj[1] ;
6831
6832 arg2 = &temp2;
6833 arg3 = &temp3;
6834 arg4 = &temp4;
6835 (void)self;
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6839 if (!SWIG_IsOK(ecode1)) {
6840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6841 }
6842 arg1 = (PLINT)(val1);
6843 plgcol0(arg1,arg2,arg3,arg4);
6844 resultobj = SWIG_Py_Void();
6845 if (SWIG_IsTmpObj(res2)) {
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6847 } else {
6848 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6850 }
6851 if (SWIG_IsTmpObj(res3)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6856 }
6857 if (SWIG_IsTmpObj(res4)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6862 }
6863 return resultobj;
6864fail:
6865 return NULL;
6866}
6867
6868
6869SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6870 PyObject *resultobj = 0;
6871 PLINT arg1 ;
6872 PLINT *arg2 = (PLINT *) 0 ;
6873 PLINT *arg3 = (PLINT *) 0 ;
6874 PLINT *arg4 = (PLINT *) 0 ;
6875 PLFLT *arg5 = (PLFLT *) 0 ;
6876 int val1 ;
6877 int ecode1 = 0 ;
6878 PLINT temp2 ;
6879 int res2 = SWIG_TMPOBJ ;
6880 PLINT temp3 ;
6881 int res3 = SWIG_TMPOBJ ;
6882 PLINT temp4 ;
6883 int res4 = SWIG_TMPOBJ ;
6884 PLFLT temp5 ;
6885 int res5 = SWIG_TMPOBJ ;
6886 PyObject *swig_obj[1] ;
6887
6888 arg2 = &temp2;
6889 arg3 = &temp3;
6890 arg4 = &temp4;
6891 arg5 = &temp5;
6892 (void)self;
6893 if (!args) SWIG_fail;
6894 swig_obj[0] = args;
6895 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6896 if (!SWIG_IsOK(ecode1)) {
6897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6898 }
6899 arg1 = (PLINT)(val1);
6900 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6901 resultobj = SWIG_Py_Void();
6902 if (SWIG_IsTmpObj(res2)) {
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6904 } else {
6905 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6907 }
6908 if (SWIG_IsTmpObj(res3)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6913 }
6914 if (SWIG_IsTmpObj(res4)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6919 }
6920 if (SWIG_IsTmpObj(res5)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
6925 }
6926 return resultobj;
6927fail:
6928 return NULL;
6929}
6930
6931
6932SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6933 PyObject *resultobj = 0;
6934 PLINT *arg1 = (PLINT *) 0 ;
6935 PLINT *arg2 = (PLINT *) 0 ;
6936 PLINT *arg3 = (PLINT *) 0 ;
6937 PLINT temp1 ;
6938 int res1 = SWIG_TMPOBJ ;
6939 PLINT temp2 ;
6940 int res2 = SWIG_TMPOBJ ;
6941 PLINT temp3 ;
6942 int res3 = SWIG_TMPOBJ ;
6943
6944 arg1 = &temp1;
6945 arg2 = &temp2;
6946 arg3 = &temp3;
6947 (void)self;
6948 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6949 plgcolbg(arg1,arg2,arg3);
6950 resultobj = SWIG_Py_Void();
6951 if (SWIG_IsTmpObj(res1)) {
6952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
6953 } else {
6954 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
6956 }
6957 if (SWIG_IsTmpObj(res2)) {
6958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6959 } else {
6960 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6962 }
6963 if (SWIG_IsTmpObj(res3)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6968 }
6969 return resultobj;
6970fail:
6971 return NULL;
6972}
6973
6974
6975SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6976 PyObject *resultobj = 0;
6977 PLINT *arg1 = (PLINT *) 0 ;
6978 PLINT *arg2 = (PLINT *) 0 ;
6979 PLINT *arg3 = (PLINT *) 0 ;
6980 PLFLT *arg4 = (PLFLT *) 0 ;
6981 PLINT temp1 ;
6982 int res1 = SWIG_TMPOBJ ;
6983 PLINT temp2 ;
6984 int res2 = SWIG_TMPOBJ ;
6985 PLINT temp3 ;
6986 int res3 = SWIG_TMPOBJ ;
6987 PLFLT temp4 ;
6988 int res4 = SWIG_TMPOBJ ;
6989
6990 arg1 = &temp1;
6991 arg2 = &temp2;
6992 arg3 = &temp3;
6993 arg4 = &temp4;
6994 (void)self;
6995 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6996 plgcolbga(arg1,arg2,arg3,arg4);
6997 resultobj = SWIG_Py_Void();
6998 if (SWIG_IsTmpObj(res1)) {
6999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7000 } else {
7001 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7003 }
7004 if (SWIG_IsTmpObj(res2)) {
7005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7006 } else {
7007 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7009 }
7010 if (SWIG_IsTmpObj(res3)) {
7011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7012 } else {
7013 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7015 }
7016 if (SWIG_IsTmpObj(res4)) {
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7018 } else {
7019 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7021 }
7022 return resultobj;
7023fail:
7024 return NULL;
7025}
7026
7027
7028SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
7029 PyObject *resultobj = 0;
7030 PLINT *arg1 = (PLINT *) 0 ;
7031 PLINT temp1 ;
7032 int res1 = SWIG_TMPOBJ ;
7033
7034 arg1 = &temp1;
7035 (void)self;
7036 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7037 plgcompression(arg1);
7038 resultobj = SWIG_Py_Void();
7039 if (SWIG_IsTmpObj(res1)) {
7040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7041 } else {
7042 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7044 }
7045 return resultobj;
7046fail:
7047 return NULL;
7048}
7049
7050
7051SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7052 PyObject *resultobj = 0;
7053 char *arg1 = (char *) 0 ;
7054 char buff1[1000] ;
7055
7056 {
7057 arg1 = buff1;
7058 }
7059 (void)self;
7060 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7061 plgdev(arg1);
7062 resultobj = SWIG_Py_Void();
7063 {
7064 PyObject *o = PyString_FromString( arg1 );
7065 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7066 }
7067 return resultobj;
7068fail:
7069 return NULL;
7070}
7071
7072
7073SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7074 PyObject *resultobj = 0;
7075 PLFLT *arg1 = (PLFLT *) 0 ;
7076 PLFLT *arg2 = (PLFLT *) 0 ;
7077 PLFLT *arg3 = (PLFLT *) 0 ;
7078 PLFLT *arg4 = (PLFLT *) 0 ;
7079 PLFLT temp1 ;
7080 int res1 = SWIG_TMPOBJ ;
7081 PLFLT temp2 ;
7082 int res2 = SWIG_TMPOBJ ;
7083 PLFLT temp3 ;
7084 int res3 = SWIG_TMPOBJ ;
7085 PLFLT temp4 ;
7086 int res4 = SWIG_TMPOBJ ;
7087
7088 arg1 = &temp1;
7089 arg2 = &temp2;
7090 arg3 = &temp3;
7091 arg4 = &temp4;
7092 (void)self;
7093 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7094 plgdidev(arg1,arg2,arg3,arg4);
7095 resultobj = SWIG_Py_Void();
7096 if (SWIG_IsTmpObj(res1)) {
7097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7098 } else {
7099 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7101 }
7102 if (SWIG_IsTmpObj(res2)) {
7103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7104 } else {
7105 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7107 }
7108 if (SWIG_IsTmpObj(res3)) {
7109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7110 } else {
7111 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7113 }
7114 if (SWIG_IsTmpObj(res4)) {
7115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7116 } else {
7117 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7119 }
7120 return resultobj;
7121fail:
7122 return NULL;
7123}
7124
7125
7126SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7127 PyObject *resultobj = 0;
7128 PLFLT *arg1 = (PLFLT *) 0 ;
7129 PLFLT temp1 ;
7130 int res1 = SWIG_TMPOBJ ;
7131
7132 arg1 = &temp1;
7133 (void)self;
7134 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7135 plgdiori(arg1);
7136 resultobj = SWIG_Py_Void();
7137 if (SWIG_IsTmpObj(res1)) {
7138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7139 } else {
7140 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7142 }
7143 return resultobj;
7144fail:
7145 return NULL;
7146}
7147
7148
7149SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7150 PyObject *resultobj = 0;
7151 PLFLT *arg1 = (PLFLT *) 0 ;
7152 PLFLT *arg2 = (PLFLT *) 0 ;
7153 PLFLT *arg3 = (PLFLT *) 0 ;
7154 PLFLT *arg4 = (PLFLT *) 0 ;
7155 PLFLT temp1 ;
7156 int res1 = SWIG_TMPOBJ ;
7157 PLFLT temp2 ;
7158 int res2 = SWIG_TMPOBJ ;
7159 PLFLT temp3 ;
7160 int res3 = SWIG_TMPOBJ ;
7161 PLFLT temp4 ;
7162 int res4 = SWIG_TMPOBJ ;
7163
7164 arg1 = &temp1;
7165 arg2 = &temp2;
7166 arg3 = &temp3;
7167 arg4 = &temp4;
7168 (void)self;
7169 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7170 plgdiplt(arg1,arg2,arg3,arg4);
7171 resultobj = SWIG_Py_Void();
7172 if (SWIG_IsTmpObj(res1)) {
7173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7174 } else {
7175 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7177 }
7178 if (SWIG_IsTmpObj(res2)) {
7179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7180 } else {
7181 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7183 }
7184 if (SWIG_IsTmpObj(res3)) {
7185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7186 } else {
7187 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7189 }
7190 if (SWIG_IsTmpObj(res4)) {
7191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7192 } else {
7193 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7195 }
7196 return resultobj;
7197fail:
7198 return NULL;
7199}
7200
7201
7202SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7203 PyObject *resultobj = 0;
7204 PLINT *arg1 = (PLINT *) 0 ;
7205 PLINT *arg2 = (PLINT *) 0 ;
7206 PLINT *arg3 = (PLINT *) 0 ;
7207 PLINT temp1 ;
7208 int res1 = SWIG_TMPOBJ ;
7209 PLINT temp2 ;
7210 int res2 = SWIG_TMPOBJ ;
7211 PLINT temp3 ;
7212 int res3 = SWIG_TMPOBJ ;
7213
7214 arg1 = &temp1;
7215 arg2 = &temp2;
7216 arg3 = &temp3;
7217 (void)self;
7218 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7219 plgfam(arg1,arg2,arg3);
7220 resultobj = SWIG_Py_Void();
7221 if (SWIG_IsTmpObj(res1)) {
7222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7223 } else {
7224 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7226 }
7227 if (SWIG_IsTmpObj(res2)) {
7228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7229 } else {
7230 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7232 }
7233 if (SWIG_IsTmpObj(res3)) {
7234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7235 } else {
7236 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7238 }
7239 return resultobj;
7240fail:
7241 return NULL;
7242}
7243
7244
7245SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7246 PyObject *resultobj = 0;
7247 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7248 PLUNICODE temp1 ;
7249 int res1 = SWIG_TMPOBJ ;
7250
7251 arg1 = &temp1;
7252 (void)self;
7253 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7254 plgfci(arg1);
7255 resultobj = SWIG_Py_Void();
7256 if (SWIG_IsTmpObj(res1)) {
7257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)), 1);
7258 } else {
7259 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7260 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags), 1);
7261 }
7262 return resultobj;
7263fail:
7264 return NULL;
7265}
7266
7267
7268SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7269 PyObject *resultobj = 0;
7270 char *arg1 = (char *) 0 ;
7271 char buff1[1000] ;
7272
7273 {
7274 arg1 = buff1;
7275 }
7276 (void)self;
7277 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7278 plgfnam(arg1);
7279 resultobj = SWIG_Py_Void();
7280 {
7281 PyObject *o = PyString_FromString( arg1 );
7282 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7283 }
7284 return resultobj;
7285fail:
7286 return NULL;
7287}
7288
7289
7290SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7291 PyObject *resultobj = 0;
7292 PLINT *arg1 = (PLINT *) 0 ;
7293 PLINT *arg2 = (PLINT *) 0 ;
7294 PLINT *arg3 = (PLINT *) 0 ;
7295 PLINT temp1 ;
7296 int res1 = SWIG_TMPOBJ ;
7297 PLINT temp2 ;
7298 int res2 = SWIG_TMPOBJ ;
7299 PLINT temp3 ;
7300 int res3 = SWIG_TMPOBJ ;
7301
7302 arg1 = &temp1;
7303 arg2 = &temp2;
7304 arg3 = &temp3;
7305 (void)self;
7306 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7307 plgfont(arg1,arg2,arg3);
7308 resultobj = SWIG_Py_Void();
7309 if (SWIG_IsTmpObj(res1)) {
7310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7311 } else {
7312 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7314 }
7315 if (SWIG_IsTmpObj(res2)) {
7316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7317 } else {
7318 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7320 }
7321 if (SWIG_IsTmpObj(res3)) {
7322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7323 } else {
7324 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7326 }
7327 return resultobj;
7328fail:
7329 return NULL;
7330}
7331
7332
7333SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7334 PyObject *resultobj = 0;
7335 PLINT *arg1 = (PLINT *) 0 ;
7336 PLINT temp1 ;
7337 int res1 = SWIG_TMPOBJ ;
7338
7339 arg1 = &temp1;
7340 (void)self;
7341 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7342 plglevel(arg1);
7343 resultobj = SWIG_Py_Void();
7344 if (SWIG_IsTmpObj(res1)) {
7345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7346 } else {
7347 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7349 }
7350 return resultobj;
7351fail:
7352 return NULL;
7353}
7354
7355
7356SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7357 PyObject *resultobj = 0;
7358 PLFLT *arg1 = (PLFLT *) 0 ;
7359 PLFLT *arg2 = (PLFLT *) 0 ;
7360 PLINT *arg3 = (PLINT *) 0 ;
7361 PLINT *arg4 = (PLINT *) 0 ;
7362 PLINT *arg5 = (PLINT *) 0 ;
7363 PLINT *arg6 = (PLINT *) 0 ;
7364 PLFLT temp1 ;
7365 int res1 = SWIG_TMPOBJ ;
7366 PLFLT temp2 ;
7367 int res2 = SWIG_TMPOBJ ;
7368 PLINT temp3 ;
7369 int res3 = SWIG_TMPOBJ ;
7370 PLINT temp4 ;
7371 int res4 = SWIG_TMPOBJ ;
7372 PLINT temp5 ;
7373 int res5 = SWIG_TMPOBJ ;
7374 PLINT temp6 ;
7375 int res6 = SWIG_TMPOBJ ;
7376
7377 arg1 = &temp1;
7378 arg2 = &temp2;
7379 arg3 = &temp3;
7380 arg4 = &temp4;
7381 arg5 = &temp5;
7382 arg6 = &temp6;
7383 (void)self;
7384 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7385 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7386 resultobj = SWIG_Py_Void();
7387 if (SWIG_IsTmpObj(res1)) {
7388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7389 } else {
7390 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7392 }
7393 if (SWIG_IsTmpObj(res2)) {
7394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7395 } else {
7396 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7398 }
7399 if (SWIG_IsTmpObj(res3)) {
7400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7401 } else {
7402 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7404 }
7405 if (SWIG_IsTmpObj(res4)) {
7406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
7407 } else {
7408 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
7410 }
7411 if (SWIG_IsTmpObj(res5)) {
7412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
7413 } else {
7414 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
7416 }
7417 if (SWIG_IsTmpObj(res6)) {
7418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
7419 } else {
7420 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
7422 }
7423 return resultobj;
7424fail:
7425 return NULL;
7426}
7427
7428
7429SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7430 PyObject *resultobj = 0;
7431
7432 (void)self;
7433 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7434 plgra();
7435 resultobj = SWIG_Py_Void();
7436 return resultobj;
7437fail:
7438 return NULL;
7439}
7440
7441
7442SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7443 PyObject *resultobj = 0;
7444 PLFLT *arg1 = (PLFLT *) 0 ;
7445 PLFLT *arg2 = (PLFLT *) 0 ;
7446 PLFLT *arg3 = (PLFLT *) 0 ;
7447 PLINT arg4 ;
7448 PLFLT *arg5 = (PLFLT *) 0 ;
7449 PLINT arg6 ;
7450 PLFLT *arg7 = (PLFLT *) 0 ;
7451 PLINT arg8 ;
7452 PLFLT **arg9 = (PLFLT **) 0 ;
7453 PLINT arg10 ;
7454 PLFLT arg11 ;
7455 PyArrayObject *tmp1 = NULL ;
7456 PyArrayObject *tmp2 = NULL ;
7457 PyArrayObject *tmp3 = NULL ;
7458 PyArrayObject *tmp5 = NULL ;
7459 PyArrayObject *tmp7 = NULL ;
7460 PyObject *array7 = NULL ;
7461 int val10 ;
7462 int ecode10 = 0 ;
7463 double val11 ;
7464 int ecode11 = 0 ;
7465 PyObject *swig_obj[7] ;
7466
7467 (void)self;
7468 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7469 {
7470 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7471 if ( tmp1 == NULL )
7472 return NULL;
7473 Alen = PyArray_DIMS( tmp1 )[0];
7474 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7475 }
7476 {
7477 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7478 if ( tmp2 == NULL )
7479 return NULL;
7480 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7481 {
7482 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7483 return NULL;
7484 }
7485 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7486 }
7487 {
7488 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7489 if ( tmp3 == NULL )
7490 return NULL;
7491 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7492 {
7493 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7494 return NULL;
7495 }
7496 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7497 arg4 = PyArray_DIMS( tmp3 )[0];
7498 }
7499 {
7500 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7501 if ( tmp5 == NULL )
7502 return NULL;
7503 Xlen = PyArray_DIMS( tmp5 )[0];
7504 arg6 = Xlen;
7505 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7506 }
7507 {
7508 int i, size;
7509 npy_intp dims[2];
7510 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7511 if ( tmp7 == NULL )
7512 return NULL;
7513 Ylen = PyArray_DIMS( tmp7 )[0];
7514 arg8 = Ylen;
7515 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7516 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7517 // list and this ArrayY.
7518 dims[0] = Xlen;
7519 dims[1] = Ylen;
7520 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7521 if ( !array7 )
7522 return NULL;
7523 size = Ylen;
7524 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7525 for ( i = 0; i < Xlen; i++ )
7526 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7527 }
7528 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7529 if (!SWIG_IsOK(ecode10)) {
7530 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7531 }
7532 arg10 = (PLINT)(val10);
7533 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7534 if (!SWIG_IsOK(ecode11)) {
7535 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7536 }
7537 arg11 = (PLFLT)(val11);
7538 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7539 resultobj = SWIG_Py_Void();
7540 {
7541 resultobj = SWIG_Python_AppendOutput(resultobj, array7, 1);
7542 }
7543 {
7544 Py_CLEAR( tmp1 );
7545 }
7546 {
7547 Py_CLEAR( tmp2 );
7548 }
7549 {
7550 Py_CLEAR( tmp3 );
7551 }
7552 {
7553 Py_CLEAR( tmp5 );
7554 }
7555 {
7556 Py_CLEAR( tmp7 );
7557 free( arg9 );
7558 }
7559 return resultobj;
7560fail:
7561 {
7562 Py_CLEAR( tmp1 );
7563 }
7564 {
7565 Py_CLEAR( tmp2 );
7566 }
7567 {
7568 Py_CLEAR( tmp3 );
7569 }
7570 {
7571 Py_CLEAR( tmp5 );
7572 }
7573 {
7574 Py_CLEAR( tmp7 );
7575 free( arg9 );
7576 }
7577 return NULL;
7578}
7579
7580
7581SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7582 PyObject *resultobj = 0;
7583 PLFLT *arg1 = (PLFLT *) 0 ;
7584 PLFLT *arg2 = (PLFLT *) 0 ;
7585 PLFLT *arg3 = (PLFLT *) 0 ;
7586 PLFLT *arg4 = (PLFLT *) 0 ;
7587 PLFLT temp1 ;
7588 int res1 = SWIG_TMPOBJ ;
7589 PLFLT temp2 ;
7590 int res2 = SWIG_TMPOBJ ;
7591 PLFLT temp3 ;
7592 int res3 = SWIG_TMPOBJ ;
7593 PLFLT temp4 ;
7594 int res4 = SWIG_TMPOBJ ;
7595
7596 arg1 = &temp1;
7597 arg2 = &temp2;
7598 arg3 = &temp3;
7599 arg4 = &temp4;
7600 (void)self;
7601 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7602 plgspa(arg1,arg2,arg3,arg4);
7603 resultobj = SWIG_Py_Void();
7604 if (SWIG_IsTmpObj(res1)) {
7605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7606 } else {
7607 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7609 }
7610 if (SWIG_IsTmpObj(res2)) {
7611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7612 } else {
7613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7615 }
7616 if (SWIG_IsTmpObj(res3)) {
7617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7618 } else {
7619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7621 }
7622 if (SWIG_IsTmpObj(res4)) {
7623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7624 } else {
7625 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7627 }
7628 return resultobj;
7629fail:
7630 return NULL;
7631}
7632
7633
7634SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7635 PyObject *resultobj = 0;
7636 PLINT *arg1 = (PLINT *) 0 ;
7637 PLINT temp1 ;
7638 int res1 = SWIG_TMPOBJ ;
7639
7640 arg1 = &temp1;
7641 (void)self;
7642 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7643 plgstrm(arg1);
7644 resultobj = SWIG_Py_Void();
7645 if (SWIG_IsTmpObj(res1)) {
7646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7647 } else {
7648 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7650 }
7651 return resultobj;
7652fail:
7653 return NULL;
7654}
7655
7656
7657SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7658 PyObject *resultobj = 0;
7659 char *arg1 = (char *) 0 ;
7660 char buff1[1000] ;
7661
7662 {
7663 arg1 = buff1;
7664 }
7665 (void)self;
7666 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7667 plgver(arg1);
7668 resultobj = SWIG_Py_Void();
7669 {
7670 PyObject *o = PyString_FromString( arg1 );
7671 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7672 }
7673 return resultobj;
7674fail:
7675 return NULL;
7676}
7677
7678
7679SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7680 PyObject *resultobj = 0;
7681 PLFLT *arg1 = (PLFLT *) 0 ;
7682 PLFLT *arg2 = (PLFLT *) 0 ;
7683 PLFLT *arg3 = (PLFLT *) 0 ;
7684 PLFLT *arg4 = (PLFLT *) 0 ;
7685 PLFLT temp1 ;
7686 int res1 = SWIG_TMPOBJ ;
7687 PLFLT temp2 ;
7688 int res2 = SWIG_TMPOBJ ;
7689 PLFLT temp3 ;
7690 int res3 = SWIG_TMPOBJ ;
7691 PLFLT temp4 ;
7692 int res4 = SWIG_TMPOBJ ;
7693
7694 arg1 = &temp1;
7695 arg2 = &temp2;
7696 arg3 = &temp3;
7697 arg4 = &temp4;
7698 (void)self;
7699 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7700 plgvpd(arg1,arg2,arg3,arg4);
7701 resultobj = SWIG_Py_Void();
7702 if (SWIG_IsTmpObj(res1)) {
7703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7704 } else {
7705 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7707 }
7708 if (SWIG_IsTmpObj(res2)) {
7709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7710 } else {
7711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7713 }
7714 if (SWIG_IsTmpObj(res3)) {
7715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7716 } else {
7717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7719 }
7720 if (SWIG_IsTmpObj(res4)) {
7721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7722 } else {
7723 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7725 }
7726 return resultobj;
7727fail:
7728 return NULL;
7729}
7730
7731
7732SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7733 PyObject *resultobj = 0;
7734 PLFLT *arg1 = (PLFLT *) 0 ;
7735 PLFLT *arg2 = (PLFLT *) 0 ;
7736 PLFLT *arg3 = (PLFLT *) 0 ;
7737 PLFLT *arg4 = (PLFLT *) 0 ;
7738 PLFLT temp1 ;
7739 int res1 = SWIG_TMPOBJ ;
7740 PLFLT temp2 ;
7741 int res2 = SWIG_TMPOBJ ;
7742 PLFLT temp3 ;
7743 int res3 = SWIG_TMPOBJ ;
7744 PLFLT temp4 ;
7745 int res4 = SWIG_TMPOBJ ;
7746
7747 arg1 = &temp1;
7748 arg2 = &temp2;
7749 arg3 = &temp3;
7750 arg4 = &temp4;
7751 (void)self;
7752 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7753 plgvpw(arg1,arg2,arg3,arg4);
7754 resultobj = SWIG_Py_Void();
7755 if (SWIG_IsTmpObj(res1)) {
7756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7757 } else {
7758 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7760 }
7761 if (SWIG_IsTmpObj(res2)) {
7762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7763 } else {
7764 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7766 }
7767 if (SWIG_IsTmpObj(res3)) {
7768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7769 } else {
7770 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7772 }
7773 if (SWIG_IsTmpObj(res4)) {
7774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7775 } else {
7776 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7778 }
7779 return resultobj;
7780fail:
7781 return NULL;
7782}
7783
7784
7785SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7786 PyObject *resultobj = 0;
7787 PLINT *arg1 = (PLINT *) 0 ;
7788 PLINT *arg2 = (PLINT *) 0 ;
7789 PLINT temp1 ;
7790 int res1 = SWIG_TMPOBJ ;
7791 PLINT temp2 ;
7792 int res2 = SWIG_TMPOBJ ;
7793
7794 arg1 = &temp1;
7795 arg2 = &temp2;
7796 (void)self;
7797 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7798 plgxax(arg1,arg2);
7799 resultobj = SWIG_Py_Void();
7800 if (SWIG_IsTmpObj(res1)) {
7801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7802 } else {
7803 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7805 }
7806 if (SWIG_IsTmpObj(res2)) {
7807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7808 } else {
7809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7811 }
7812 return resultobj;
7813fail:
7814 return NULL;
7815}
7816
7817
7818SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7819 PyObject *resultobj = 0;
7820 PLINT *arg1 = (PLINT *) 0 ;
7821 PLINT *arg2 = (PLINT *) 0 ;
7822 PLINT temp1 ;
7823 int res1 = SWIG_TMPOBJ ;
7824 PLINT temp2 ;
7825 int res2 = SWIG_TMPOBJ ;
7826
7827 arg1 = &temp1;
7828 arg2 = &temp2;
7829 (void)self;
7830 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7831 plgyax(arg1,arg2);
7832 resultobj = SWIG_Py_Void();
7833 if (SWIG_IsTmpObj(res1)) {
7834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7835 } else {
7836 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7838 }
7839 if (SWIG_IsTmpObj(res2)) {
7840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7841 } else {
7842 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7844 }
7845 return resultobj;
7846fail:
7847 return NULL;
7848}
7849
7850
7851SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7852 PyObject *resultobj = 0;
7853 PLINT *arg1 = (PLINT *) 0 ;
7854 PLINT *arg2 = (PLINT *) 0 ;
7855 PLINT temp1 ;
7856 int res1 = SWIG_TMPOBJ ;
7857 PLINT temp2 ;
7858 int res2 = SWIG_TMPOBJ ;
7859
7860 arg1 = &temp1;
7861 arg2 = &temp2;
7862 (void)self;
7863 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7864 plgzax(arg1,arg2);
7865 resultobj = SWIG_Py_Void();
7866 if (SWIG_IsTmpObj(res1)) {
7867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7868 } else {
7869 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7871 }
7872 if (SWIG_IsTmpObj(res2)) {
7873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7874 } else {
7875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7877 }
7878 return resultobj;
7879fail:
7880 return NULL;
7881}
7882
7883
7884SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7885 PyObject *resultobj = 0;
7886 PLINT arg1 ;
7887 PLFLT *arg2 = (PLFLT *) 0 ;
7888 PLFLT arg3 ;
7889 PLFLT arg4 ;
7890 PLINT arg5 ;
7891 PLINT arg6 ;
7892 PyArrayObject *tmp1 = NULL ;
7893 double val3 ;
7894 int ecode3 = 0 ;
7895 double val4 ;
7896 int ecode4 = 0 ;
7897 int val5 ;
7898 int ecode5 = 0 ;
7899 int val6 ;
7900 int ecode6 = 0 ;
7901 PyObject *swig_obj[5] ;
7902
7903 (void)self;
7904 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7905 {
7906 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7907 if ( tmp1 == NULL )
7908 return NULL;
7909 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7910 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7911 }
7912 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7913 if (!SWIG_IsOK(ecode3)) {
7914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7915 }
7916 arg3 = (PLFLT)(val3);
7917 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7918 if (!SWIG_IsOK(ecode4)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7920 }
7921 arg4 = (PLFLT)(val4);
7922 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7923 if (!SWIG_IsOK(ecode5)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7925 }
7926 arg5 = (PLINT)(val5);
7927 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7928 if (!SWIG_IsOK(ecode6)) {
7929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7930 }
7931 arg6 = (PLINT)(val6);
7932 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7933 resultobj = SWIG_Py_Void();
7934 {
7935 Py_CLEAR( tmp1 );
7936 }
7937 return resultobj;
7938fail:
7939 {
7940 Py_CLEAR( tmp1 );
7941 }
7942 return NULL;
7943}
7944
7945
7946SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7947 PyObject *resultobj = 0;
7948 PLFLT arg1 ;
7949 PLFLT arg2 ;
7950 PLFLT arg3 ;
7951 PLFLT *arg4 = (PLFLT *) 0 ;
7952 PLFLT *arg5 = (PLFLT *) 0 ;
7953 PLFLT *arg6 = (PLFLT *) 0 ;
7954 double val1 ;
7955 int ecode1 = 0 ;
7956 double val2 ;
7957 int ecode2 = 0 ;
7958 double val3 ;
7959 int ecode3 = 0 ;
7960 PLFLT temp4 ;
7961 int res4 = SWIG_TMPOBJ ;
7962 PLFLT temp5 ;
7963 int res5 = SWIG_TMPOBJ ;
7964 PLFLT temp6 ;
7965 int res6 = SWIG_TMPOBJ ;
7966 PyObject *swig_obj[3] ;
7967
7968 arg4 = &temp4;
7969 arg5 = &temp5;
7970 arg6 = &temp6;
7971 (void)self;
7972 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7973 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7974 if (!SWIG_IsOK(ecode1)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7976 }
7977 arg1 = (PLFLT)(val1);
7978 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7979 if (!SWIG_IsOK(ecode2)) {
7980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7981 }
7982 arg2 = (PLFLT)(val2);
7983 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7984 if (!SWIG_IsOK(ecode3)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7986 }
7987 arg3 = (PLFLT)(val3);
7988 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7989 resultobj = SWIG_Py_Void();
7990 if (SWIG_IsTmpObj(res4)) {
7991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7992 } else {
7993 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7995 }
7996 if (SWIG_IsTmpObj(res5)) {
7997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
7998 } else {
7999 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
8001 }
8002 if (SWIG_IsTmpObj(res6)) {
8003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
8004 } else {
8005 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
8007 }
8008 return resultobj;
8009fail:
8010 return NULL;
8011}
8012
8013
8014SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
8015 PyObject *resultobj = 0;
8016
8017 (void)self;
8018 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
8019 plinit();
8020 resultobj = SWIG_Py_Void();
8021 return resultobj;
8022fail:
8023 return NULL;
8024}
8025
8026
8027SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
8028 PyObject *resultobj = 0;
8029 PLFLT arg1 ;
8030 PLFLT arg2 ;
8031 PLFLT arg3 ;
8032 PLFLT arg4 ;
8033 double val1 ;
8034 int ecode1 = 0 ;
8035 double val2 ;
8036 int ecode2 = 0 ;
8037 double val3 ;
8038 int ecode3 = 0 ;
8039 double val4 ;
8040 int ecode4 = 0 ;
8041 PyObject *swig_obj[4] ;
8042
8043 (void)self;
8044 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8045 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8046 if (!SWIG_IsOK(ecode1)) {
8047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8048 }
8049 arg1 = (PLFLT)(val1);
8050 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8051 if (!SWIG_IsOK(ecode2)) {
8052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8053 }
8054 arg2 = (PLFLT)(val2);
8055 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8056 if (!SWIG_IsOK(ecode3)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8058 }
8059 arg3 = (PLFLT)(val3);
8060 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8061 if (!SWIG_IsOK(ecode4)) {
8062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8063 }
8064 arg4 = (PLFLT)(val4);
8065 pljoin(arg1,arg2,arg3,arg4);
8066 resultobj = SWIG_Py_Void();
8067 return resultobj;
8068fail:
8069 return NULL;
8070}
8071
8072
8073SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8074 PyObject *resultobj = 0;
8075 char *arg1 = (char *) 0 ;
8076 char *arg2 = (char *) 0 ;
8077 char *arg3 = (char *) 0 ;
8078 int res1 ;
8079 char *buf1 = 0 ;
8080 int alloc1 = 0 ;
8081 int res2 ;
8082 char *buf2 = 0 ;
8083 int alloc2 = 0 ;
8084 int res3 ;
8085 char *buf3 = 0 ;
8086 int alloc3 = 0 ;
8087 PyObject *swig_obj[3] ;
8088
8089 (void)self;
8090 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8091 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8094 }
8095 arg1 = (char *)(buf1);
8096 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8097 if (!SWIG_IsOK(res2)) {
8098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8099 }
8100 arg2 = (char *)(buf2);
8101 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8102 if (!SWIG_IsOK(res3)) {
8103 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8104 }
8105 arg3 = (char *)(buf3);
8106 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8107 resultobj = SWIG_Py_Void();
8108 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8109 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8110 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8111 return resultobj;
8112fail:
8113 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8114 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8115 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8116 return NULL;
8117}
8118
8119
8120SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8121 PyObject *resultobj = 0;
8122 PLFLT *arg1 = (PLFLT *) 0 ;
8123 PLFLT *arg2 = (PLFLT *) 0 ;
8124 PLINT arg3 ;
8125 PLINT arg4 ;
8126 PLFLT arg5 ;
8127 PLFLT arg6 ;
8128 PLFLT arg7 ;
8129 PLINT arg8 ;
8130 PLINT arg9 ;
8131 PLINT arg10 ;
8132 PLINT arg11 ;
8133 PLINT arg12 ;
8134 PLINT arg13 ;
8135 PLINT *arg14 = (PLINT *) 0 ;
8136 PLFLT arg15 ;
8137 PLFLT arg16 ;
8138 PLFLT arg17 ;
8139 PLFLT arg18 ;
8140 PLINT *arg19 = (PLINT *) 0 ;
8141 char **arg20 = (char **) 0 ;
8142 PLINT *arg21 = (PLINT *) 0 ;
8143 PLINT *arg22 = (PLINT *) 0 ;
8144 PLFLT *arg23 = (PLFLT *) 0 ;
8145 PLFLT *arg24 = (PLFLT *) 0 ;
8146 PLINT *arg25 = (PLINT *) 0 ;
8147 PLINT *arg26 = (PLINT *) 0 ;
8148 PLFLT *arg27 = (PLFLT *) 0 ;
8149 PLINT *arg28 = (PLINT *) 0 ;
8150 PLFLT *arg29 = (PLFLT *) 0 ;
8151 PLINT *arg30 = (PLINT *) 0 ;
8152 char **arg31 = (char **) 0 ;
8153 PLFLT temp1 ;
8154 int res1 = SWIG_TMPOBJ ;
8155 PLFLT temp2 ;
8156 int res2 = SWIG_TMPOBJ ;
8157 int val3 ;
8158 int ecode3 = 0 ;
8159 int val4 ;
8160 int ecode4 = 0 ;
8161 double val5 ;
8162 int ecode5 = 0 ;
8163 double val6 ;
8164 int ecode6 = 0 ;
8165 double val7 ;
8166 int ecode7 = 0 ;
8167 int val8 ;
8168 int ecode8 = 0 ;
8169 int val9 ;
8170 int ecode9 = 0 ;
8171 int val10 ;
8172 int ecode10 = 0 ;
8173 int val11 ;
8174 int ecode11 = 0 ;
8175 int val12 ;
8176 int ecode12 = 0 ;
8177 PyArrayObject *tmp13 = NULL ;
8178 double val15 ;
8179 int ecode15 = 0 ;
8180 double val16 ;
8181 int ecode16 = 0 ;
8182 double val17 ;
8183 int ecode17 = 0 ;
8184 double val18 ;
8185 int ecode18 = 0 ;
8186 PyArrayObject *tmp19 = NULL ;
8187 PyArrayObject *tmp20 = NULL ;
8188 PyArrayObject *tmp21 = NULL ;
8189 PyArrayObject *tmp22 = NULL ;
8190 PyArrayObject *tmp23 = NULL ;
8191 PyArrayObject *tmp24 = NULL ;
8192 PyArrayObject *tmp25 = NULL ;
8193 PyArrayObject *tmp26 = NULL ;
8194 PyArrayObject *tmp27 = NULL ;
8195 PyArrayObject *tmp28 = NULL ;
8196 PyArrayObject *tmp29 = NULL ;
8197 PyArrayObject *tmp30 = NULL ;
8198 PyArrayObject *tmp31 = NULL ;
8199 PyObject *swig_obj[28] ;
8200
8201 arg1 = &temp1;
8202 arg2 = &temp2;
8203 (void)self;
8204 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8205 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8206 if (!SWIG_IsOK(ecode3)) {
8207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8208 }
8209 arg3 = (PLINT)(val3);
8210 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8211 if (!SWIG_IsOK(ecode4)) {
8212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8213 }
8214 arg4 = (PLINT)(val4);
8215 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8216 if (!SWIG_IsOK(ecode5)) {
8217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8218 }
8219 arg5 = (PLFLT)(val5);
8220 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8221 if (!SWIG_IsOK(ecode6)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8223 }
8224 arg6 = (PLFLT)(val6);
8225 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8226 if (!SWIG_IsOK(ecode7)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8228 }
8229 arg7 = (PLFLT)(val7);
8230 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8231 if (!SWIG_IsOK(ecode8)) {
8232 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8233 }
8234 arg8 = (PLINT)(val8);
8235 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8236 if (!SWIG_IsOK(ecode9)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8238 }
8239 arg9 = (PLINT)(val9);
8240 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8241 if (!SWIG_IsOK(ecode10)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8243 }
8244 arg10 = (PLINT)(val10);
8245 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8246 if (!SWIG_IsOK(ecode11)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8248 }
8249 arg11 = (PLINT)(val11);
8250 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8251 if (!SWIG_IsOK(ecode12)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8253 }
8254 arg12 = (PLINT)(val12);
8255 {
8256 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8257 if ( tmp13 == NULL )
8258 return NULL;
8259 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8260 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8261 }
8262 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8263 if (!SWIG_IsOK(ecode15)) {
8264 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8265 }
8266 arg15 = (PLFLT)(val15);
8267 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8268 if (!SWIG_IsOK(ecode16)) {
8269 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8270 }
8271 arg16 = (PLFLT)(val16);
8272 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8273 if (!SWIG_IsOK(ecode17)) {
8274 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8275 }
8276 arg17 = (PLFLT)(val17);
8277 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8278 if (!SWIG_IsOK(ecode18)) {
8279 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8280 }
8281 arg18 = (PLFLT)(val18);
8282 {
8283 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8284 if ( tmp19 == NULL )
8285 return NULL;
8286 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8287 {
8288 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8289 return NULL;
8290 }
8291 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8292 }
8293 {
8294 int i;
8295 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8296 if ( tmp20 == NULL )
8297 return NULL;
8298 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8299 {
8300 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8301 return NULL;
8302 }
8303 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8304 for ( i = 0; i < Alen; i++ )
8305 {
8306 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8307 if ( arg20[i] == NULL )
8308 {
8309 free( arg20 );
8310 return NULL;
8311 }
8312 }
8313 }
8314 {
8315 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8316 if ( tmp21 == NULL )
8317 return NULL;
8318 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8319 {
8320 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8321 return NULL;
8322 }
8323 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8324 }
8325 {
8326 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8327 if ( tmp22 == NULL )
8328 return NULL;
8329 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8330 {
8331 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8332 return NULL;
8333 }
8334 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8335 }
8336 {
8337 if ( swig_obj[19] != Py_None )
8338 {
8339 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8340 if ( tmp23 == NULL )
8341 return NULL;
8342 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8343 {
8344 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8345 return NULL;
8346 }
8347 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8348 }
8349 else
8350 {
8351 arg23 = NULL;
8352 }
8353 }
8354 {
8355 if ( swig_obj[20] != Py_None )
8356 {
8357 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8358 if ( tmp24 == NULL )
8359 return NULL;
8360 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8361 {
8362 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8363 return NULL;
8364 }
8365 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8366 }
8367 else
8368 {
8369 arg24 = NULL;
8370 }
8371 }
8372 {
8373 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8374 if ( tmp25 == NULL )
8375 return NULL;
8376 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8377 {
8378 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8379 return NULL;
8380 }
8381 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8382 }
8383 {
8384 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8385 if ( tmp26 == NULL )
8386 return NULL;
8387 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8388 {
8389 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8390 return NULL;
8391 }
8392 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8393 }
8394 {
8395 if ( swig_obj[23] != Py_None )
8396 {
8397 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8398 if ( tmp27 == NULL )
8399 return NULL;
8400 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8401 {
8402 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8403 return NULL;
8404 }
8405 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8406 }
8407 else
8408 {
8409 arg27 = NULL;
8410 }
8411 }
8412 {
8413 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8414 if ( tmp28 == NULL )
8415 return NULL;
8416 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8417 {
8418 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8419 return NULL;
8420 }
8421 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8422 }
8423 {
8424 if ( swig_obj[25] != Py_None )
8425 {
8426 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8427 if ( tmp29 == NULL )
8428 return NULL;
8429 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8430 {
8431 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8432 return NULL;
8433 }
8434 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8435 }
8436 else
8437 {
8438 arg29 = NULL;
8439 }
8440 }
8441 {
8442 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8443 if ( tmp30 == NULL )
8444 return NULL;
8445 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8446 {
8447 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8448 return NULL;
8449 }
8450 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8451 }
8452 {
8453 int i;
8454 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8455 if ( tmp31 == NULL )
8456 return NULL;
8457 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8458 {
8459 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8460 return NULL;
8461 }
8462 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8463 for ( i = 0; i < Alen; i++ )
8464 {
8465 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8466 if ( arg31[i] == NULL )
8467 {
8468 free( arg31 );
8469 return NULL;
8470 }
8471 }
8472 }
8473 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);
8474 resultobj = SWIG_Py_Void();
8475 if (SWIG_IsTmpObj(res1)) {
8476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8477 } else {
8478 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8480 }
8481 if (SWIG_IsTmpObj(res2)) {
8482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8483 } else {
8484 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8486 }
8487 {
8488 Py_CLEAR( tmp13 );
8489 }
8490 {
8491 Py_CLEAR( tmp19 );
8492 }
8493 {
8494 Py_CLEAR( tmp20 ); free( arg20 );
8495 }
8496 {
8497 Py_CLEAR( tmp21 );
8498 }
8499 {
8500 Py_CLEAR( tmp22 );
8501 }
8502 {
8503 Py_CLEAR( tmp23 );
8504 }
8505 {
8506 Py_CLEAR( tmp24 );
8507 }
8508 {
8509 Py_CLEAR( tmp25 );
8510 }
8511 {
8512 Py_CLEAR( tmp26 );
8513 }
8514 {
8515 Py_CLEAR( tmp27 );
8516 }
8517 {
8518 Py_CLEAR( tmp28 );
8519 }
8520 {
8521 Py_CLEAR( tmp29 );
8522 }
8523 {
8524 Py_CLEAR( tmp30 );
8525 }
8526 {
8527 Py_CLEAR( tmp31 ); free( arg31 );
8528 }
8529 return resultobj;
8530fail:
8531 {
8532 Py_CLEAR( tmp13 );
8533 }
8534 {
8535 Py_CLEAR( tmp19 );
8536 }
8537 {
8538 Py_CLEAR( tmp20 ); free( arg20 );
8539 }
8540 {
8541 Py_CLEAR( tmp21 );
8542 }
8543 {
8544 Py_CLEAR( tmp22 );
8545 }
8546 {
8547 Py_CLEAR( tmp23 );
8548 }
8549 {
8550 Py_CLEAR( tmp24 );
8551 }
8552 {
8553 Py_CLEAR( tmp25 );
8554 }
8555 {
8556 Py_CLEAR( tmp26 );
8557 }
8558 {
8559 Py_CLEAR( tmp27 );
8560 }
8561 {
8562 Py_CLEAR( tmp28 );
8563 }
8564 {
8565 Py_CLEAR( tmp29 );
8566 }
8567 {
8568 Py_CLEAR( tmp30 );
8569 }
8570 {
8571 Py_CLEAR( tmp31 ); free( arg31 );
8572 }
8573 return NULL;
8574}
8575
8576
8577SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8578 PyObject *resultobj = 0;
8579 PLFLT *arg1 = (PLFLT *) 0 ;
8580 PLFLT *arg2 = (PLFLT *) 0 ;
8581 PLINT arg3 ;
8582 PLINT arg4 ;
8583 PLFLT arg5 ;
8584 PLFLT arg6 ;
8585 PLFLT arg7 ;
8586 PLFLT arg8 ;
8587 PLINT arg9 ;
8588 PLINT arg10 ;
8589 PLINT arg11 ;
8590 PLFLT arg12 ;
8591 PLFLT arg13 ;
8592 PLINT arg14 ;
8593 PLFLT arg15 ;
8594 PLINT arg16 ;
8595 PLINT *arg17 = (PLINT *) 0 ;
8596 char **arg18 = (char **) 0 ;
8597 PLINT arg19 ;
8598 char **arg20 = (char **) 0 ;
8599 PLFLT *arg21 = (PLFLT *) 0 ;
8600 PLINT *arg22 = (PLINT *) 0 ;
8601 PLINT *arg23 = (PLINT *) 0 ;
8602 PLFLT **arg24 = (PLFLT **) 0 ;
8603 PLFLT temp1 ;
8604 int res1 = SWIG_TMPOBJ ;
8605 PLFLT temp2 ;
8606 int res2 = SWIG_TMPOBJ ;
8607 int val3 ;
8608 int ecode3 = 0 ;
8609 int val4 ;
8610 int ecode4 = 0 ;
8611 double val5 ;
8612 int ecode5 = 0 ;
8613 double val6 ;
8614 int ecode6 = 0 ;
8615 double val7 ;
8616 int ecode7 = 0 ;
8617 double val8 ;
8618 int ecode8 = 0 ;
8619 int val9 ;
8620 int ecode9 = 0 ;
8621 int val10 ;
8622 int ecode10 = 0 ;
8623 int val11 ;
8624 int ecode11 = 0 ;
8625 double val12 ;
8626 int ecode12 = 0 ;
8627 double val13 ;
8628 int ecode13 = 0 ;
8629 int val14 ;
8630 int ecode14 = 0 ;
8631 double val15 ;
8632 int ecode15 = 0 ;
8633 PyArrayObject *tmp16 = NULL ;
8634 PyArrayObject *tmp18 = NULL ;
8635 PyArrayObject *tmp19 = NULL ;
8636 PyArrayObject *tmp21 = NULL ;
8637 PyArrayObject *tmp22 = NULL ;
8638 PyArrayObject *tmp23 = NULL ;
8639 PyArrayObject *tmp24 = NULL ;
8640 PyObject *swig_obj[20] ;
8641
8642 arg1 = &temp1;
8643 arg2 = &temp2;
8644 (void)self;
8645 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8646 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8647 if (!SWIG_IsOK(ecode3)) {
8648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8649 }
8650 arg3 = (PLINT)(val3);
8651 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8652 if (!SWIG_IsOK(ecode4)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8654 }
8655 arg4 = (PLINT)(val4);
8656 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8657 if (!SWIG_IsOK(ecode5)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8659 }
8660 arg5 = (PLFLT)(val5);
8661 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8662 if (!SWIG_IsOK(ecode6)) {
8663 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8664 }
8665 arg6 = (PLFLT)(val6);
8666 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8667 if (!SWIG_IsOK(ecode7)) {
8668 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8669 }
8670 arg7 = (PLFLT)(val7);
8671 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8672 if (!SWIG_IsOK(ecode8)) {
8673 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8674 }
8675 arg8 = (PLFLT)(val8);
8676 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8677 if (!SWIG_IsOK(ecode9)) {
8678 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8679 }
8680 arg9 = (PLINT)(val9);
8681 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8682 if (!SWIG_IsOK(ecode10)) {
8683 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8684 }
8685 arg10 = (PLINT)(val10);
8686 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8687 if (!SWIG_IsOK(ecode11)) {
8688 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8689 }
8690 arg11 = (PLINT)(val11);
8691 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8692 if (!SWIG_IsOK(ecode12)) {
8693 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8694 }
8695 arg12 = (PLFLT)(val12);
8696 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8697 if (!SWIG_IsOK(ecode13)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8699 }
8700 arg13 = (PLFLT)(val13);
8701 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8702 if (!SWIG_IsOK(ecode14)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8704 }
8705 arg14 = (PLINT)(val14);
8706 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8707 if (!SWIG_IsOK(ecode15)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8709 }
8710 arg15 = (PLFLT)(val15);
8711 {
8712 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8713 if ( tmp16 == NULL )
8714 return NULL;
8715 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8716 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8717 }
8718 {
8719 int i;
8720 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8721 if ( tmp18 == NULL )
8722 return NULL;
8723 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8724 {
8725 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8726 return NULL;
8727 }
8728 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8729 for ( i = 0; i < Alen; i++ )
8730 {
8731 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8732 if ( arg18[i] == NULL )
8733 {
8734 free( arg18 );
8735 return NULL;
8736 }
8737 }
8738 }
8739 {
8740 int i;
8741 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8742 if ( tmp19 == NULL )
8743 return NULL;
8744 Alen = PyArray_DIMS( tmp19 )[0];
8745 arg19 = Alen;
8746 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8747 for ( i = 0; i < Alen; i++ )
8748 {
8749 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8750 if ( arg20[i] == NULL )
8751 {
8752 free( arg20 );
8753 return NULL;
8754 }
8755 }
8756 }
8757 {
8758 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8759 if ( tmp21 == NULL )
8760 return NULL;
8761 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8762 {
8763 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8764 return NULL;
8765 }
8766 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8767 }
8768 {
8769 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8770 if ( tmp22 == NULL )
8771 return NULL;
8772 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8773 {
8774 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8775 return NULL;
8776 }
8777 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8778 }
8779 {
8780 int i;
8781 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8782 if ( tmp23 == NULL )
8783 return NULL;
8784 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8785 {
8786 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8787 return NULL;
8788 }
8789 Xlen = PyArray_DIMS( tmp23 )[0];
8790 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8791 Ylen = -1;
8792 for ( i = 0; i < Xlen; i++ )
8793 if ( arg23[i] > Ylen )
8794 Ylen = arg23[i];
8795 }
8796 {
8797 int i, size;
8798 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8799 if ( tmp24 == NULL )
8800 return NULL;
8801 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8802 {
8803 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8804 return NULL;
8805 }
8806 size = Ylen;
8807 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8808 for ( i = 0; i < Xlen; i++ )
8809 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8810 }
8811 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);
8812 resultobj = SWIG_Py_Void();
8813 if (SWIG_IsTmpObj(res1)) {
8814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8815 } else {
8816 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8818 }
8819 if (SWIG_IsTmpObj(res2)) {
8820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8821 } else {
8822 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8824 }
8825 {
8826 Py_CLEAR( tmp16 );
8827 }
8828 {
8829 Py_CLEAR( tmp18 ); free( arg18 );
8830 }
8831 {
8832 Py_CLEAR( tmp19 ); free( arg20 );
8833 }
8834 {
8835 Py_CLEAR( tmp21 );
8836 }
8837 {
8838 Py_CLEAR( tmp22 );
8839 }
8840 {
8841 Py_CLEAR( tmp23 );
8842 }
8843 {
8844 Py_CLEAR( tmp24 );
8845 free( arg24 );
8846 }
8847 return resultobj;
8848fail:
8849 {
8850 Py_CLEAR( tmp16 );
8851 }
8852 {
8853 Py_CLEAR( tmp18 ); free( arg18 );
8854 }
8855 {
8856 Py_CLEAR( tmp19 ); free( arg20 );
8857 }
8858 {
8859 Py_CLEAR( tmp21 );
8860 }
8861 {
8862 Py_CLEAR( tmp22 );
8863 }
8864 {
8865 Py_CLEAR( tmp23 );
8866 }
8867 {
8868 Py_CLEAR( tmp24 );
8869 free( arg24 );
8870 }
8871 return NULL;
8872}
8873
8874
8875SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8876 PyObject *resultobj = 0;
8877 PLFLT arg1 ;
8878 PLFLT arg2 ;
8879 PLFLT arg3 ;
8880 double val1 ;
8881 int ecode1 = 0 ;
8882 double val2 ;
8883 int ecode2 = 0 ;
8884 double val3 ;
8885 int ecode3 = 0 ;
8886 PyObject *swig_obj[3] ;
8887
8888 (void)self;
8889 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8890 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8891 if (!SWIG_IsOK(ecode1)) {
8892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8893 }
8894 arg1 = (PLFLT)(val1);
8895 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8896 if (!SWIG_IsOK(ecode2)) {
8897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8898 }
8899 arg2 = (PLFLT)(val2);
8900 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8901 if (!SWIG_IsOK(ecode3)) {
8902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8903 }
8904 arg3 = (PLFLT)(val3);
8905 pllightsource(arg1,arg2,arg3);
8906 resultobj = SWIG_Py_Void();
8907 return resultobj;
8908fail:
8909 return NULL;
8910}
8911
8912
8913SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8914 PyObject *resultobj = 0;
8915 PLINT arg1 ;
8916 PLFLT *arg2 = (PLFLT *) 0 ;
8917 PLFLT *arg3 = (PLFLT *) 0 ;
8918 PyArrayObject *tmp1 = NULL ;
8919 PyArrayObject *tmp3 = NULL ;
8920 PyObject *swig_obj[2] ;
8921
8922 (void)self;
8923 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8924 {
8925 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8926 if ( tmp1 == NULL )
8927 return NULL;
8928 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8929 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8930 }
8931 {
8932 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8933 if ( tmp3 == NULL )
8934 return NULL;
8935 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8936 {
8937 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8938 return NULL;
8939 }
8940 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8941 }
8942 plline(arg1,(double const *)arg2,(double const *)arg3);
8943 resultobj = SWIG_Py_Void();
8944 {
8945 Py_CLEAR( tmp1 );
8946 }
8947 {
8948 Py_CLEAR( tmp3 );
8949 }
8950 return resultobj;
8951fail:
8952 {
8953 Py_CLEAR( tmp1 );
8954 }
8955 {
8956 Py_CLEAR( tmp3 );
8957 }
8958 return NULL;
8959}
8960
8961
8962SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8963 PyObject *resultobj = 0;
8964 PLINT arg1 ;
8965 PLFLT *arg2 = (PLFLT *) 0 ;
8966 PLFLT *arg3 = (PLFLT *) 0 ;
8967 PLFLT *arg4 = (PLFLT *) 0 ;
8968 PyArrayObject *tmp1 = NULL ;
8969 PyArrayObject *tmp3 = NULL ;
8970 PyArrayObject *tmp4 = NULL ;
8971 PyObject *swig_obj[3] ;
8972
8973 (void)self;
8974 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8975 {
8976 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8977 if ( tmp1 == NULL )
8978 return NULL;
8979 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8980 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8981 }
8982 {
8983 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8984 if ( tmp3 == NULL )
8985 return NULL;
8986 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8987 {
8988 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8989 return NULL;
8990 }
8991 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8992 }
8993 {
8994 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8995 if ( tmp4 == NULL )
8996 return NULL;
8997 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8998 {
8999 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9000 return NULL;
9001 }
9002 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9003 }
9004 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
9005 resultobj = SWIG_Py_Void();
9006 {
9007 Py_CLEAR( tmp1 );
9008 }
9009 {
9010 Py_CLEAR( tmp3 );
9011 }
9012 {
9013 Py_CLEAR( tmp4 );
9014 }
9015 return resultobj;
9016fail:
9017 {
9018 Py_CLEAR( tmp1 );
9019 }
9020 {
9021 Py_CLEAR( tmp3 );
9022 }
9023 {
9024 Py_CLEAR( tmp4 );
9025 }
9026 return NULL;
9027}
9028
9029
9030SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
9031 PyObject *resultobj = 0;
9032 PLINT arg1 ;
9033 int val1 ;
9034 int ecode1 = 0 ;
9035 PyObject *swig_obj[1] ;
9036
9037 (void)self;
9038 if (!args) SWIG_fail;
9039 swig_obj[0] = args;
9040 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9041 if (!SWIG_IsOK(ecode1)) {
9042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9043 }
9044 arg1 = (PLINT)(val1);
9045 pllsty(arg1);
9046 resultobj = SWIG_Py_Void();
9047 return resultobj;
9048fail:
9049 return NULL;
9050}
9051
9052
9053SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9054 PyObject *resultobj = 0;
9055 PLFLT *arg1 = (PLFLT *) 0 ;
9056 PLFLT *arg2 = (PLFLT *) 0 ;
9057 PLFLT **arg3 = (PLFLT **) 0 ;
9058 PLINT arg4 ;
9059 PLINT arg5 ;
9060 PLINT arg6 ;
9061 PyArrayObject *tmp1 = NULL ;
9062 PyArrayObject *tmp2 = NULL ;
9063 PyArrayObject *tmp3 = NULL ;
9064 int val6 ;
9065 int ecode6 = 0 ;
9066 PyObject *swig_obj[4] ;
9067
9068 (void)self;
9069 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9070 {
9071 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9072 if ( tmp1 == NULL )
9073 return NULL;
9074 Xlen = PyArray_DIMS( tmp1 )[0];
9075 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9076 }
9077 {
9078 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9079 if ( tmp2 == NULL )
9080 return NULL;
9081 Ylen = PyArray_DIMS( tmp2 )[0];
9082 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9083 }
9084 {
9085 int i, size;
9086 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9087 if ( tmp3 == NULL )
9088 return NULL;
9089 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9090 {
9091 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9092 return NULL;
9093 }
9094 arg4 = PyArray_DIMS( tmp3 )[0];
9095 arg5 = PyArray_DIMS( tmp3 )[1];
9096 size = arg5;
9097 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9098 for ( i = 0; i < arg4; i++ )
9099 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9100 }
9101 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9102 if (!SWIG_IsOK(ecode6)) {
9103 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9104 }
9105 arg6 = (PLINT)(val6);
9106 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9107 resultobj = SWIG_Py_Void();
9108 {
9109 Py_CLEAR( tmp1 );
9110 }
9111 {
9112 Py_CLEAR( tmp2 );
9113 }
9114 {
9115 Py_CLEAR( tmp3 );
9116 free( arg3 );
9117 }
9118 return resultobj;
9119fail:
9120 {
9121 Py_CLEAR( tmp1 );
9122 }
9123 {
9124 Py_CLEAR( tmp2 );
9125 }
9126 {
9127 Py_CLEAR( tmp3 );
9128 free( arg3 );
9129 }
9130 return NULL;
9131}
9132
9133
9134SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9135 PyObject *resultobj = 0;
9136 PLFLT *arg1 = (PLFLT *) 0 ;
9137 PLFLT *arg2 = (PLFLT *) 0 ;
9138 PLFLT **arg3 = (PLFLT **) 0 ;
9139 PLINT arg4 ;
9140 PLINT arg5 ;
9141 PLINT arg6 ;
9142 PLFLT *arg7 = (PLFLT *) 0 ;
9143 PLINT arg8 ;
9144 PyArrayObject *tmp1 = NULL ;
9145 PyArrayObject *tmp2 = NULL ;
9146 PyArrayObject *tmp3 = NULL ;
9147 int val6 ;
9148 int ecode6 = 0 ;
9149 PyArrayObject *tmp7 = NULL ;
9150 PyObject *swig_obj[5] ;
9151
9152 (void)self;
9153 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9154 {
9155 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9156 if ( tmp1 == NULL )
9157 return NULL;
9158 Xlen = PyArray_DIMS( tmp1 )[0];
9159 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9160 }
9161 {
9162 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9163 if ( tmp2 == NULL )
9164 return NULL;
9165 Ylen = PyArray_DIMS( tmp2 )[0];
9166 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9167 }
9168 {
9169 int i, size;
9170 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9171 if ( tmp3 == NULL )
9172 return NULL;
9173 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9174 {
9175 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9176 return NULL;
9177 }
9178 arg4 = PyArray_DIMS( tmp3 )[0];
9179 arg5 = PyArray_DIMS( tmp3 )[1];
9180 size = arg5;
9181 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9182 for ( i = 0; i < arg4; i++ )
9183 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9184 }
9185 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9186 if (!SWIG_IsOK(ecode6)) {
9187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9188 }
9189 arg6 = (PLINT)(val6);
9190 {
9191 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9192 if ( tmp7 == NULL )
9193 return NULL;
9194 arg8 = PyArray_DIMS( tmp7 )[0];
9195 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9196 }
9197 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9198 resultobj = SWIG_Py_Void();
9199 {
9200 Py_CLEAR( tmp1 );
9201 }
9202 {
9203 Py_CLEAR( tmp2 );
9204 }
9205 {
9206 Py_CLEAR( tmp3 );
9207 free( arg3 );
9208 }
9209 {
9210 Py_CLEAR( tmp7 );
9211 }
9212 return resultobj;
9213fail:
9214 {
9215 Py_CLEAR( tmp1 );
9216 }
9217 {
9218 Py_CLEAR( tmp2 );
9219 }
9220 {
9221 Py_CLEAR( tmp3 );
9222 free( arg3 );
9223 }
9224 {
9225 Py_CLEAR( tmp7 );
9226 }
9227 return NULL;
9228}
9229
9230
9231SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9232 PyObject *resultobj = 0;
9233 PLINT *arg1 = (PLINT *) 0 ;
9234 PLINT temp1 ;
9235 int res1 = SWIG_TMPOBJ ;
9236
9237 arg1 = &temp1;
9238 (void)self;
9239 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9240 plmkstrm(arg1);
9241 resultobj = SWIG_Py_Void();
9242 if (SWIG_IsTmpObj(res1)) {
9243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
9244 } else {
9245 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
9247 }
9248 return resultobj;
9249fail:
9250 return NULL;
9251}
9252
9253
9254SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9255 PyObject *resultobj = 0;
9256 char *arg1 = (char *) 0 ;
9257 PLFLT arg2 ;
9258 PLFLT arg3 ;
9259 PLFLT arg4 ;
9260 char *arg5 = (char *) 0 ;
9261 int res1 ;
9262 char *buf1 = 0 ;
9263 int alloc1 = 0 ;
9264 double val2 ;
9265 int ecode2 = 0 ;
9266 double val3 ;
9267 int ecode3 = 0 ;
9268 double val4 ;
9269 int ecode4 = 0 ;
9270 int res5 ;
9271 char *buf5 = 0 ;
9272 int alloc5 = 0 ;
9273 PyObject *swig_obj[5] ;
9274
9275 (void)self;
9276 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9277 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9278 if (!SWIG_IsOK(res1)) {
9279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9280 }
9281 arg1 = (char *)(buf1);
9282 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9283 if (!SWIG_IsOK(ecode2)) {
9284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9285 }
9286 arg2 = (PLFLT)(val2);
9287 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9288 if (!SWIG_IsOK(ecode3)) {
9289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9290 }
9291 arg3 = (PLFLT)(val3);
9292 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9293 if (!SWIG_IsOK(ecode4)) {
9294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9295 }
9296 arg4 = (PLFLT)(val4);
9297 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9298 if (!SWIG_IsOK(res5)) {
9299 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9300 }
9301 arg5 = (char *)(buf5);
9302 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9303 resultobj = SWIG_Py_Void();
9304 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9305 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9306 return resultobj;
9307fail:
9308 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9309 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9310 return NULL;
9311}
9312
9313
9314SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9315 PyObject *resultobj = 0;
9316 char *arg1 = (char *) 0 ;
9317 PLFLT arg2 ;
9318 PLFLT arg3 ;
9319 PLFLT arg4 ;
9320 char *arg5 = (char *) 0 ;
9321 int res1 ;
9322 char *buf1 = 0 ;
9323 int alloc1 = 0 ;
9324 double val2 ;
9325 int ecode2 = 0 ;
9326 double val3 ;
9327 int ecode3 = 0 ;
9328 double val4 ;
9329 int ecode4 = 0 ;
9330 int res5 ;
9331 char *buf5 = 0 ;
9332 int alloc5 = 0 ;
9333 PyObject *swig_obj[5] ;
9334
9335 (void)self;
9336 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9337 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9340 }
9341 arg1 = (char *)(buf1);
9342 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9343 if (!SWIG_IsOK(ecode2)) {
9344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9345 }
9346 arg2 = (PLFLT)(val2);
9347 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9348 if (!SWIG_IsOK(ecode3)) {
9349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9350 }
9351 arg3 = (PLFLT)(val3);
9352 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9353 if (!SWIG_IsOK(ecode4)) {
9354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9355 }
9356 arg4 = (PLFLT)(val4);
9357 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9358 if (!SWIG_IsOK(res5)) {
9359 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9360 }
9361 arg5 = (char *)(buf5);
9362 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9363 resultobj = SWIG_Py_Void();
9364 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9365 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9366 return resultobj;
9367fail:
9368 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9369 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9370 return NULL;
9371}
9372
9373
9374SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9375 PyObject *resultobj = 0;
9376 PLFLT *arg1 = (PLFLT *) 0 ;
9377 PLFLT *arg2 = (PLFLT *) 0 ;
9378 PLFLT **arg3 = (PLFLT **) 0 ;
9379 PLINT arg4 ;
9380 PLINT arg5 ;
9381 PLINT arg6 ;
9382 PLBOOL arg7 ;
9383 PyArrayObject *tmp1 = NULL ;
9384 PyArrayObject *tmp2 = NULL ;
9385 PyArrayObject *tmp3 = NULL ;
9386 int val6 ;
9387 int ecode6 = 0 ;
9388 int val7 ;
9389 int ecode7 = 0 ;
9390 PyObject *swig_obj[5] ;
9391
9392 (void)self;
9393 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9394 {
9395 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9396 if ( tmp1 == NULL )
9397 return NULL;
9398 Xlen = PyArray_DIMS( tmp1 )[0];
9399 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9400 }
9401 {
9402 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9403 if ( tmp2 == NULL )
9404 return NULL;
9405 Ylen = PyArray_DIMS( tmp2 )[0];
9406 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9407 }
9408 {
9409 int i, size;
9410 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9411 if ( tmp3 == NULL )
9412 return NULL;
9413 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9414 {
9415 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9416 return NULL;
9417 }
9418 arg4 = PyArray_DIMS( tmp3 )[0];
9419 arg5 = PyArray_DIMS( tmp3 )[1];
9420 size = arg5;
9421 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9422 for ( i = 0; i < arg4; i++ )
9423 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9424 }
9425 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9426 if (!SWIG_IsOK(ecode6)) {
9427 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9428 }
9429 arg6 = (PLINT)(val6);
9430 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9431 if (!SWIG_IsOK(ecode7)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9433 }
9434 arg7 = (PLBOOL)(val7);
9435 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9436 resultobj = SWIG_Py_Void();
9437 {
9438 Py_CLEAR( tmp1 );
9439 }
9440 {
9441 Py_CLEAR( tmp2 );
9442 }
9443 {
9444 Py_CLEAR( tmp3 );
9445 free( arg3 );
9446 }
9447 return resultobj;
9448fail:
9449 {
9450 Py_CLEAR( tmp1 );
9451 }
9452 {
9453 Py_CLEAR( tmp2 );
9454 }
9455 {
9456 Py_CLEAR( tmp3 );
9457 free( arg3 );
9458 }
9459 return NULL;
9460}
9461
9462
9463SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9464 PyObject *resultobj = 0;
9465 PLFLT *arg1 = (PLFLT *) 0 ;
9466 PLFLT *arg2 = (PLFLT *) 0 ;
9467 PLFLT **arg3 = (PLFLT **) 0 ;
9468 PLINT arg4 ;
9469 PLINT arg5 ;
9470 PLINT arg6 ;
9471 PLFLT *arg7 = (PLFLT *) 0 ;
9472 PLINT arg8 ;
9473 PyArrayObject *tmp1 = NULL ;
9474 PyArrayObject *tmp2 = NULL ;
9475 PyArrayObject *tmp3 = NULL ;
9476 int val6 ;
9477 int ecode6 = 0 ;
9478 PyArrayObject *tmp7 = NULL ;
9479 PyObject *swig_obj[5] ;
9480
9481 (void)self;
9482 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9483 {
9484 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9485 if ( tmp1 == NULL )
9486 return NULL;
9487 Xlen = PyArray_DIMS( tmp1 )[0];
9488 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9489 }
9490 {
9491 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9492 if ( tmp2 == NULL )
9493 return NULL;
9494 Ylen = PyArray_DIMS( tmp2 )[0];
9495 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9496 }
9497 {
9498 int i, size;
9499 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9500 if ( tmp3 == NULL )
9501 return NULL;
9502 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9503 {
9504 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9505 return NULL;
9506 }
9507 arg4 = PyArray_DIMS( tmp3 )[0];
9508 arg5 = PyArray_DIMS( tmp3 )[1];
9509 size = arg5;
9510 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9511 for ( i = 0; i < arg4; i++ )
9512 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9513 }
9514 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9515 if (!SWIG_IsOK(ecode6)) {
9516 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9517 }
9518 arg6 = (PLINT)(val6);
9519 {
9520 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9521 if ( tmp7 == NULL )
9522 return NULL;
9523 arg8 = PyArray_DIMS( tmp7 )[0];
9524 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9525 }
9526 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9527 resultobj = SWIG_Py_Void();
9528 {
9529 Py_CLEAR( tmp1 );
9530 }
9531 {
9532 Py_CLEAR( tmp2 );
9533 }
9534 {
9535 Py_CLEAR( tmp3 );
9536 free( arg3 );
9537 }
9538 {
9539 Py_CLEAR( tmp7 );
9540 }
9541 return resultobj;
9542fail:
9543 {
9544 Py_CLEAR( tmp1 );
9545 }
9546 {
9547 Py_CLEAR( tmp2 );
9548 }
9549 {
9550 Py_CLEAR( tmp3 );
9551 free( arg3 );
9552 }
9553 {
9554 Py_CLEAR( tmp7 );
9555 }
9556 return NULL;
9557}
9558
9559
9560SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9561 PyObject *resultobj = 0;
9562 PLFLT *arg1 = (PLFLT *) 0 ;
9563 PLFLT *arg2 = (PLFLT *) 0 ;
9564 PLFLT **arg3 = (PLFLT **) 0 ;
9565 PLINT arg4 ;
9566 PLINT arg5 ;
9567 PLINT arg6 ;
9568 PLFLT *arg7 = (PLFLT *) 0 ;
9569 PLINT arg8 ;
9570 PLINT arg9 ;
9571 PLINT arg10 ;
9572 PLINT *arg11 = (PLINT *) 0 ;
9573 PLINT *arg12 = (PLINT *) 0 ;
9574 PyArrayObject *tmp1 = NULL ;
9575 PyArrayObject *tmp2 = NULL ;
9576 PyArrayObject *tmp3 = NULL ;
9577 int val6 ;
9578 int ecode6 = 0 ;
9579 PyArrayObject *tmp7 = NULL ;
9580 int val9 ;
9581 int ecode9 = 0 ;
9582 PyArrayObject *tmp10 = NULL ;
9583 PyArrayObject *tmp12 = NULL ;
9584 PyObject *swig_obj[8] ;
9585
9586 (void)self;
9587 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9588 {
9589 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9590 if ( tmp1 == NULL )
9591 return NULL;
9592 Xlen = PyArray_DIMS( tmp1 )[0];
9593 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9594 }
9595 {
9596 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9597 if ( tmp2 == NULL )
9598 return NULL;
9599 Ylen = PyArray_DIMS( tmp2 )[0];
9600 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9601 }
9602 {
9603 int i, size;
9604 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9605 if ( tmp3 == NULL )
9606 return NULL;
9607 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9608 {
9609 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9610 return NULL;
9611 }
9612 arg4 = PyArray_DIMS( tmp3 )[0];
9613 arg5 = PyArray_DIMS( tmp3 )[1];
9614 size = arg5;
9615 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9616 for ( i = 0; i < arg4; i++ )
9617 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9618 }
9619 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9620 if (!SWIG_IsOK(ecode6)) {
9621 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9622 }
9623 arg6 = (PLINT)(val6);
9624 {
9625 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9626 if ( tmp7 == NULL )
9627 return NULL;
9628 arg8 = PyArray_DIMS( tmp7 )[0];
9629 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9630 }
9631 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9632 if (!SWIG_IsOK(ecode9)) {
9633 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9634 }
9635 arg9 = (PLINT)(val9);
9636 {
9637 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9638 if ( tmp10 == NULL )
9639 return NULL;
9640 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9641 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9642 }
9643 {
9644 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9645 if ( tmp12 == NULL )
9646 return NULL;
9647 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9648 {
9649 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9650 return NULL;
9651 }
9652 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9653 }
9654 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);
9655 resultobj = SWIG_Py_Void();
9656 {
9657 Py_CLEAR( tmp1 );
9658 }
9659 {
9660 Py_CLEAR( tmp2 );
9661 }
9662 {
9663 Py_CLEAR( tmp3 );
9664 free( arg3 );
9665 }
9666 {
9667 Py_CLEAR( tmp7 );
9668 }
9669 {
9670 Py_CLEAR( tmp10 );
9671 }
9672 {
9673 Py_CLEAR( tmp12 );
9674 }
9675 return resultobj;
9676fail:
9677 {
9678 Py_CLEAR( tmp1 );
9679 }
9680 {
9681 Py_CLEAR( tmp2 );
9682 }
9683 {
9684 Py_CLEAR( tmp3 );
9685 free( arg3 );
9686 }
9687 {
9688 Py_CLEAR( tmp7 );
9689 }
9690 {
9691 Py_CLEAR( tmp10 );
9692 }
9693 {
9694 Py_CLEAR( tmp12 );
9695 }
9696 return NULL;
9697}
9698
9699
9700SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9701 PyObject *resultobj = 0;
9702 PLFLT *arg1 = (PLFLT *) 0 ;
9703 PLFLT *arg2 = (PLFLT *) 0 ;
9704 PLFLT **arg3 = (PLFLT **) 0 ;
9705 PLINT arg4 ;
9706 PLINT arg5 ;
9707 PLINT arg6 ;
9708 PLFLT *arg7 = (PLFLT *) 0 ;
9709 PLINT arg8 ;
9710 PyArrayObject *tmp1 = NULL ;
9711 PyArrayObject *tmp2 = NULL ;
9712 PyArrayObject *tmp3 = NULL ;
9713 int val6 ;
9714 int ecode6 = 0 ;
9715 PyArrayObject *tmp7 = NULL ;
9716 PyObject *swig_obj[5] ;
9717
9718 (void)self;
9719 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9720 {
9721 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9722 if ( tmp1 == NULL )
9723 return NULL;
9724 Xlen = PyArray_DIMS( tmp1 )[0];
9725 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9726 }
9727 {
9728 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9729 if ( tmp2 == NULL )
9730 return NULL;
9731 Ylen = PyArray_DIMS( tmp2 )[0];
9732 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9733 }
9734 {
9735 int i, size;
9736 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9737 if ( tmp3 == NULL )
9738 return NULL;
9739 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9740 {
9741 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9742 return NULL;
9743 }
9744 arg4 = PyArray_DIMS( tmp3 )[0];
9745 arg5 = PyArray_DIMS( tmp3 )[1];
9746 size = arg5;
9747 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9748 for ( i = 0; i < arg4; i++ )
9749 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9750 }
9751 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9752 if (!SWIG_IsOK(ecode6)) {
9753 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9754 }
9755 arg6 = (PLINT)(val6);
9756 {
9757 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9758 if ( tmp7 == NULL )
9759 return NULL;
9760 arg8 = PyArray_DIMS( tmp7 )[0];
9761 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9762 }
9763 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9764 resultobj = SWIG_Py_Void();
9765 {
9766 Py_CLEAR( tmp1 );
9767 }
9768 {
9769 Py_CLEAR( tmp2 );
9770 }
9771 {
9772 Py_CLEAR( tmp3 );
9773 free( arg3 );
9774 }
9775 {
9776 Py_CLEAR( tmp7 );
9777 }
9778 return resultobj;
9779fail:
9780 {
9781 Py_CLEAR( tmp1 );
9782 }
9783 {
9784 Py_CLEAR( tmp2 );
9785 }
9786 {
9787 Py_CLEAR( tmp3 );
9788 free( arg3 );
9789 }
9790 {
9791 Py_CLEAR( tmp7 );
9792 }
9793 return NULL;
9794}
9795
9796
9797SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9798 PyObject *resultobj = 0;
9799 PLFLT *arg1 = (PLFLT *) 0 ;
9800 PLFLT *arg2 = (PLFLT *) 0 ;
9801 PLFLT **arg3 = (PLFLT **) 0 ;
9802 PLINT arg4 ;
9803 PLINT arg5 ;
9804 PLINT arg6 ;
9805 PLFLT *arg7 = (PLFLT *) 0 ;
9806 PLINT arg8 ;
9807 PLINT arg9 ;
9808 PLINT arg10 ;
9809 PLINT *arg11 = (PLINT *) 0 ;
9810 PLINT *arg12 = (PLINT *) 0 ;
9811 PyArrayObject *tmp1 = NULL ;
9812 PyArrayObject *tmp2 = NULL ;
9813 PyArrayObject *tmp3 = NULL ;
9814 int val6 ;
9815 int ecode6 = 0 ;
9816 PyArrayObject *tmp7 = NULL ;
9817 int val9 ;
9818 int ecode9 = 0 ;
9819 PyArrayObject *tmp10 = NULL ;
9820 PyArrayObject *tmp12 = NULL ;
9821 PyObject *swig_obj[8] ;
9822
9823 (void)self;
9824 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9825 {
9826 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9827 if ( tmp1 == NULL )
9828 return NULL;
9829 Xlen = PyArray_DIMS( tmp1 )[0];
9830 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9831 }
9832 {
9833 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9834 if ( tmp2 == NULL )
9835 return NULL;
9836 Ylen = PyArray_DIMS( tmp2 )[0];
9837 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9838 }
9839 {
9840 int i, size;
9841 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9842 if ( tmp3 == NULL )
9843 return NULL;
9844 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9845 {
9846 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9847 return NULL;
9848 }
9849 arg4 = PyArray_DIMS( tmp3 )[0];
9850 arg5 = PyArray_DIMS( tmp3 )[1];
9851 size = arg5;
9852 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9853 for ( i = 0; i < arg4; i++ )
9854 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9855 }
9856 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9857 if (!SWIG_IsOK(ecode6)) {
9858 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9859 }
9860 arg6 = (PLINT)(val6);
9861 {
9862 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9863 if ( tmp7 == NULL )
9864 return NULL;
9865 arg8 = PyArray_DIMS( tmp7 )[0];
9866 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9867 }
9868 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9869 if (!SWIG_IsOK(ecode9)) {
9870 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9871 }
9872 arg9 = (PLINT)(val9);
9873 {
9874 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9875 if ( tmp10 == NULL )
9876 return NULL;
9877 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9878 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9879 }
9880 {
9881 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9882 if ( tmp12 == NULL )
9883 return NULL;
9884 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9885 {
9886 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9887 return NULL;
9888 }
9889 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9890 }
9891 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);
9892 resultobj = SWIG_Py_Void();
9893 {
9894 Py_CLEAR( tmp1 );
9895 }
9896 {
9897 Py_CLEAR( tmp2 );
9898 }
9899 {
9900 Py_CLEAR( tmp3 );
9901 free( arg3 );
9902 }
9903 {
9904 Py_CLEAR( tmp7 );
9905 }
9906 {
9907 Py_CLEAR( tmp10 );
9908 }
9909 {
9910 Py_CLEAR( tmp12 );
9911 }
9912 return resultobj;
9913fail:
9914 {
9915 Py_CLEAR( tmp1 );
9916 }
9917 {
9918 Py_CLEAR( tmp2 );
9919 }
9920 {
9921 Py_CLEAR( tmp3 );
9922 free( arg3 );
9923 }
9924 {
9925 Py_CLEAR( tmp7 );
9926 }
9927 {
9928 Py_CLEAR( tmp10 );
9929 }
9930 {
9931 Py_CLEAR( tmp12 );
9932 }
9933 return NULL;
9934}
9935
9936
9937SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9938 PyObject *resultobj = 0;
9939 int *arg1 = (int *) 0 ;
9940 char **arg2 = (char **) 0 ;
9941 PLINT arg3 ;
9942 int tmp1 ;
9943 int val3 ;
9944 int ecode3 = 0 ;
9945 PyObject *swig_obj[2] ;
9946 PLINT result;
9947
9948 (void)self;
9949 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9950 {
9951 int i;
9952 PyObject *unicode_string;
9953
9954 if ( !PyList_Check( swig_obj[0] ) )
9955 {
9956 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9957 return NULL;
9958 }
9959 tmp1 = PyList_Size( swig_obj[0] );
9960 arg1 = &tmp1;
9961 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9962 for ( i = 0; i < tmp1; i++ )
9963 {
9964 PyObject *s = PyList_GetItem( swig_obj[0], i );
9965 if ( PyString_Check( s ) )
9966 {
9967 arg2[i] = PyString_AsString( s );
9968 }
9969 else if ( PyUnicode_Check( s ) )
9970 {
9971 // unicode_string is never freed? memory leak here?
9972 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9973 arg2[i] = PyBytes_AS_STRING( unicode_string );
9974 }
9975 else
9976 {
9977 free( arg2 );
9978 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9979 return NULL;
9980 }
9981 }
9982 arg2[i] = 0;
9983 }
9984 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9985 if (!SWIG_IsOK(ecode3)) {
9986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9987 }
9988 arg3 = (PLINT)(val3);
9989 result = (PLINT)plparseopts(arg1,arg2,arg3);
9990 resultobj = SWIG_From_int((int)(result));
9991 {
9992 if ( arg2 )
9993 free( arg2 );
9994 }
9995 return resultobj;
9996fail:
9997 {
9998 if ( arg2 )
9999 free( arg2 );
10000 }
10001 return NULL;
10002}
10003
10004
10005SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
10006 PyObject *resultobj = 0;
10007 PLINT arg1 ;
10008 PLINT *arg2 = (PLINT *) 0 ;
10009 PLINT *arg3 = (PLINT *) 0 ;
10010 PyArrayObject *tmp1 = NULL ;
10011 PyArrayObject *tmp3 = NULL ;
10012 PyObject *swig_obj[2] ;
10013
10014 (void)self;
10015 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
10016 {
10017 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10018 if ( tmp1 == NULL )
10019 return NULL;
10020 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10021 arg2 = (PLINT *) PyArray_DATA( tmp1 );
10022 }
10023 {
10024 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10025 if ( tmp3 == NULL )
10026 return NULL;
10027 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10028 {
10029 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10030 return NULL;
10031 }
10032 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10033 }
10034 plpat(arg1,(int const *)arg2,(int const *)arg3);
10035 resultobj = SWIG_Py_Void();
10036 {
10037 Py_CLEAR( tmp1 );
10038 }
10039 {
10040 Py_CLEAR( tmp3 );
10041 }
10042 return resultobj;
10043fail:
10044 {
10045 Py_CLEAR( tmp1 );
10046 }
10047 {
10048 Py_CLEAR( tmp3 );
10049 }
10050 return NULL;
10051}
10052
10053
10054SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10055 PyObject *resultobj = 0;
10056 PLINT arg1 ;
10057 PLFLT arg2 ;
10058 PLFLT arg3 ;
10059 PLFLT arg4 ;
10060 PLFLT arg5 ;
10061 int val1 ;
10062 int ecode1 = 0 ;
10063 double val2 ;
10064 int ecode2 = 0 ;
10065 double val3 ;
10066 int ecode3 = 0 ;
10067 double val4 ;
10068 int ecode4 = 0 ;
10069 double val5 ;
10070 int ecode5 = 0 ;
10071 PyObject *swig_obj[5] ;
10072
10073 (void)self;
10074 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10075 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10076 if (!SWIG_IsOK(ecode1)) {
10077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10078 }
10079 arg1 = (PLINT)(val1);
10080 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10081 if (!SWIG_IsOK(ecode2)) {
10082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10083 }
10084 arg2 = (PLFLT)(val2);
10085 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10086 if (!SWIG_IsOK(ecode3)) {
10087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10088 }
10089 arg3 = (PLFLT)(val3);
10090 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10091 if (!SWIG_IsOK(ecode4)) {
10092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10093 }
10094 arg4 = (PLFLT)(val4);
10095 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10096 if (!SWIG_IsOK(ecode5)) {
10097 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10098 }
10099 arg5 = (PLFLT)(val5);
10100 plpath(arg1,arg2,arg3,arg4,arg5);
10101 resultobj = SWIG_Py_Void();
10102 return resultobj;
10103fail:
10104 return NULL;
10105}
10106
10107
10108SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10109 PyObject *resultobj = 0;
10110 PLINT arg1 ;
10111 PLFLT *arg2 = (PLFLT *) 0 ;
10112 PLFLT *arg3 = (PLFLT *) 0 ;
10113 PLINT arg4 ;
10114 PyArrayObject *tmp1 = NULL ;
10115 PyArrayObject *tmp3 = NULL ;
10116 int val4 ;
10117 int ecode4 = 0 ;
10118 PyObject *swig_obj[3] ;
10119
10120 (void)self;
10121 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10122 {
10123 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10124 if ( tmp1 == NULL )
10125 return NULL;
10126 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10127 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10128 }
10129 {
10130 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10131 if ( tmp3 == NULL )
10132 return NULL;
10133 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10134 {
10135 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10136 return NULL;
10137 }
10138 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10139 }
10140 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10141 if (!SWIG_IsOK(ecode4)) {
10142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10143 }
10144 arg4 = (PLINT)(val4);
10145 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10146 resultobj = SWIG_Py_Void();
10147 {
10148 Py_CLEAR( tmp1 );
10149 }
10150 {
10151 Py_CLEAR( tmp3 );
10152 }
10153 return resultobj;
10154fail:
10155 {
10156 Py_CLEAR( tmp1 );
10157 }
10158 {
10159 Py_CLEAR( tmp3 );
10160 }
10161 return NULL;
10162}
10163
10164
10165SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10166 PyObject *resultobj = 0;
10167 PLINT arg1 ;
10168 PLFLT *arg2 = (PLFLT *) 0 ;
10169 PLFLT *arg3 = (PLFLT *) 0 ;
10170 PLFLT *arg4 = (PLFLT *) 0 ;
10171 PLINT arg5 ;
10172 PyArrayObject *tmp1 = NULL ;
10173 PyArrayObject *tmp3 = NULL ;
10174 PyArrayObject *tmp4 = NULL ;
10175 int val5 ;
10176 int ecode5 = 0 ;
10177 PyObject *swig_obj[4] ;
10178
10179 (void)self;
10180 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10181 {
10182 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10183 if ( tmp1 == NULL )
10184 return NULL;
10185 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10186 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10187 }
10188 {
10189 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10190 if ( tmp3 == NULL )
10191 return NULL;
10192 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10193 {
10194 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10195 return NULL;
10196 }
10197 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10198 }
10199 {
10200 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10201 if ( tmp4 == NULL )
10202 return NULL;
10203 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10204 {
10205 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10206 return NULL;
10207 }
10208 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10209 }
10210 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10211 if (!SWIG_IsOK(ecode5)) {
10212 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10213 }
10214 arg5 = (PLINT)(val5);
10215 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10216 resultobj = SWIG_Py_Void();
10217 {
10218 Py_CLEAR( tmp1 );
10219 }
10220 {
10221 Py_CLEAR( tmp3 );
10222 }
10223 {
10224 Py_CLEAR( tmp4 );
10225 }
10226 return resultobj;
10227fail:
10228 {
10229 Py_CLEAR( tmp1 );
10230 }
10231 {
10232 Py_CLEAR( tmp3 );
10233 }
10234 {
10235 Py_CLEAR( tmp4 );
10236 }
10237 return NULL;
10238}
10239
10240
10241SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10242 PyObject *resultobj = 0;
10243 PLINT arg1 ;
10244 PLFLT *arg2 = (PLFLT *) 0 ;
10245 PLFLT *arg3 = (PLFLT *) 0 ;
10246 PLFLT *arg4 = (PLFLT *) 0 ;
10247 PLBOOL *arg5 = (PLBOOL *) 0 ;
10248 PLBOOL arg6 ;
10249 PyArrayObject *tmp1 = NULL ;
10250 PyArrayObject *tmp3 = NULL ;
10251 PyArrayObject *tmp4 = NULL ;
10252 PyArrayObject *tmp5 = NULL ;
10253 int val6 ;
10254 int ecode6 = 0 ;
10255 PyObject *swig_obj[5] ;
10256
10257 (void)self;
10258 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10259 {
10260 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10261 if ( tmp1 == NULL )
10262 return NULL;
10263 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10264 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10265 }
10266 {
10267 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10268 if ( tmp3 == NULL )
10269 return NULL;
10270 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10271 {
10272 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10273 return NULL;
10274 }
10275 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10276 }
10277 {
10278 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10279 if ( tmp4 == NULL )
10280 return NULL;
10281 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10282 {
10283 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10284 return NULL;
10285 }
10286 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10287 }
10288 {
10289 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10290 if ( tmp5 == NULL )
10291 return NULL;
10292 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10293 {
10294 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10295 return NULL;
10296 }
10297 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10298 }
10299 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10300 if (!SWIG_IsOK(ecode6)) {
10301 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10302 }
10303 arg6 = (PLBOOL)(val6);
10304 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10305 resultobj = SWIG_Py_Void();
10306 {
10307 Py_CLEAR( tmp1 );
10308 }
10309 {
10310 Py_CLEAR( tmp3 );
10311 }
10312 {
10313 Py_CLEAR( tmp4 );
10314 }
10315 {
10316 Py_CLEAR( tmp5 );
10317 }
10318 return resultobj;
10319fail:
10320 {
10321 Py_CLEAR( tmp1 );
10322 }
10323 {
10324 Py_CLEAR( tmp3 );
10325 }
10326 {
10327 Py_CLEAR( tmp4 );
10328 }
10329 {
10330 Py_CLEAR( tmp5 );
10331 }
10332 return NULL;
10333}
10334
10335
10336SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10337 PyObject *resultobj = 0;
10338 PLINT arg1 ;
10339 PLINT arg2 ;
10340 int val1 ;
10341 int ecode1 = 0 ;
10342 int val2 ;
10343 int ecode2 = 0 ;
10344 PyObject *swig_obj[2] ;
10345
10346 (void)self;
10347 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10348 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10349 if (!SWIG_IsOK(ecode1)) {
10350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10351 }
10352 arg1 = (PLINT)(val1);
10353 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10354 if (!SWIG_IsOK(ecode2)) {
10355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10356 }
10357 arg2 = (PLINT)(val2);
10358 plprec(arg1,arg2);
10359 resultobj = SWIG_Py_Void();
10360 return resultobj;
10361fail:
10362 return NULL;
10363}
10364
10365
10366SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10367 PyObject *resultobj = 0;
10368 PLINT arg1 ;
10369 int val1 ;
10370 int ecode1 = 0 ;
10371 PyObject *swig_obj[1] ;
10372
10373 (void)self;
10374 if (!args) SWIG_fail;
10375 swig_obj[0] = args;
10376 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10377 if (!SWIG_IsOK(ecode1)) {
10378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10379 }
10380 arg1 = (PLINT)(val1);
10381 plpsty(arg1);
10382 resultobj = SWIG_Py_Void();
10383 return resultobj;
10384fail:
10385 return NULL;
10386}
10387
10388
10389SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10390 PyObject *resultobj = 0;
10391 PLFLT arg1 ;
10392 PLFLT arg2 ;
10393 PLFLT arg3 ;
10394 PLFLT arg4 ;
10395 PLFLT arg5 ;
10396 char *arg6 = (char *) 0 ;
10397 double val1 ;
10398 int ecode1 = 0 ;
10399 double val2 ;
10400 int ecode2 = 0 ;
10401 double val3 ;
10402 int ecode3 = 0 ;
10403 double val4 ;
10404 int ecode4 = 0 ;
10405 double val5 ;
10406 int ecode5 = 0 ;
10407 int res6 ;
10408 char *buf6 = 0 ;
10409 int alloc6 = 0 ;
10410 PyObject *swig_obj[6] ;
10411
10412 (void)self;
10413 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10414 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10415 if (!SWIG_IsOK(ecode1)) {
10416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10417 }
10418 arg1 = (PLFLT)(val1);
10419 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10420 if (!SWIG_IsOK(ecode2)) {
10421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10422 }
10423 arg2 = (PLFLT)(val2);
10424 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10425 if (!SWIG_IsOK(ecode3)) {
10426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10427 }
10428 arg3 = (PLFLT)(val3);
10429 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10430 if (!SWIG_IsOK(ecode4)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10432 }
10433 arg4 = (PLFLT)(val4);
10434 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10435 if (!SWIG_IsOK(ecode5)) {
10436 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10437 }
10438 arg5 = (PLFLT)(val5);
10439 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10440 if (!SWIG_IsOK(res6)) {
10441 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10442 }
10443 arg6 = (char *)(buf6);
10444 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10445 resultobj = SWIG_Py_Void();
10446 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10447 return resultobj;
10448fail:
10449 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10450 return NULL;
10451}
10452
10453
10454SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10455 PyObject *resultobj = 0;
10456 PLFLT arg1 ;
10457 PLFLT arg2 ;
10458 PLFLT arg3 ;
10459 PLFLT arg4 ;
10460 PLFLT arg5 ;
10461 PLFLT arg6 ;
10462 PLFLT arg7 ;
10463 PLFLT arg8 ;
10464 PLFLT arg9 ;
10465 PLFLT arg10 ;
10466 char *arg11 = (char *) 0 ;
10467 double val1 ;
10468 int ecode1 = 0 ;
10469 double val2 ;
10470 int ecode2 = 0 ;
10471 double val3 ;
10472 int ecode3 = 0 ;
10473 double val4 ;
10474 int ecode4 = 0 ;
10475 double val5 ;
10476 int ecode5 = 0 ;
10477 double val6 ;
10478 int ecode6 = 0 ;
10479 double val7 ;
10480 int ecode7 = 0 ;
10481 double val8 ;
10482 int ecode8 = 0 ;
10483 double val9 ;
10484 int ecode9 = 0 ;
10485 double val10 ;
10486 int ecode10 = 0 ;
10487 int res11 ;
10488 char *buf11 = 0 ;
10489 int alloc11 = 0 ;
10490 PyObject *swig_obj[11] ;
10491
10492 (void)self;
10493 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10494 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10495 if (!SWIG_IsOK(ecode1)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10497 }
10498 arg1 = (PLFLT)(val1);
10499 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10500 if (!SWIG_IsOK(ecode2)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10502 }
10503 arg2 = (PLFLT)(val2);
10504 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10505 if (!SWIG_IsOK(ecode3)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10507 }
10508 arg3 = (PLFLT)(val3);
10509 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10510 if (!SWIG_IsOK(ecode4)) {
10511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10512 }
10513 arg4 = (PLFLT)(val4);
10514 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10515 if (!SWIG_IsOK(ecode5)) {
10516 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10517 }
10518 arg5 = (PLFLT)(val5);
10519 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10520 if (!SWIG_IsOK(ecode6)) {
10521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10522 }
10523 arg6 = (PLFLT)(val6);
10524 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10525 if (!SWIG_IsOK(ecode7)) {
10526 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10527 }
10528 arg7 = (PLFLT)(val7);
10529 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10530 if (!SWIG_IsOK(ecode8)) {
10531 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10532 }
10533 arg8 = (PLFLT)(val8);
10534 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10535 if (!SWIG_IsOK(ecode9)) {
10536 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10537 }
10538 arg9 = (PLFLT)(val9);
10539 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10540 if (!SWIG_IsOK(ecode10)) {
10541 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10542 }
10543 arg10 = (PLFLT)(val10);
10544 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10545 if (!SWIG_IsOK(res11)) {
10546 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10547 }
10548 arg11 = (char *)(buf11);
10549 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10550 resultobj = SWIG_Py_Void();
10551 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10552 return resultobj;
10553fail:
10554 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10555 return NULL;
10556}
10557
10558
10559SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10560 PyObject *resultobj = 0;
10561 PLFLT result;
10562
10563 (void)self;
10564 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10565 result = (PLFLT)plrandd();
10566 resultobj = SWIG_From_double((double)(result));
10567 return resultobj;
10568fail:
10569 return NULL;
10570}
10571
10572
10573SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10574 PyObject *resultobj = 0;
10575
10576 (void)self;
10577 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10578 plreplot();
10579 resultobj = SWIG_Py_Void();
10580 return resultobj;
10581fail:
10582 return NULL;
10583}
10584
10585
10586SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10587 PyObject *resultobj = 0;
10588 PLFLT arg1 ;
10589 PLFLT arg2 ;
10590 PLFLT arg3 ;
10591 PLFLT *arg4 = (PLFLT *) 0 ;
10592 PLFLT *arg5 = (PLFLT *) 0 ;
10593 PLFLT *arg6 = (PLFLT *) 0 ;
10594 double val1 ;
10595 int ecode1 = 0 ;
10596 double val2 ;
10597 int ecode2 = 0 ;
10598 double val3 ;
10599 int ecode3 = 0 ;
10600 PLFLT temp4 ;
10601 int res4 = SWIG_TMPOBJ ;
10602 PLFLT temp5 ;
10603 int res5 = SWIG_TMPOBJ ;
10604 PLFLT temp6 ;
10605 int res6 = SWIG_TMPOBJ ;
10606 PyObject *swig_obj[3] ;
10607
10608 arg4 = &temp4;
10609 arg5 = &temp5;
10610 arg6 = &temp6;
10611 (void)self;
10612 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10613 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10614 if (!SWIG_IsOK(ecode1)) {
10615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10616 }
10617 arg1 = (PLFLT)(val1);
10618 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10619 if (!SWIG_IsOK(ecode2)) {
10620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10621 }
10622 arg2 = (PLFLT)(val2);
10623 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10624 if (!SWIG_IsOK(ecode3)) {
10625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10626 }
10627 arg3 = (PLFLT)(val3);
10628 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10629 resultobj = SWIG_Py_Void();
10630 if (SWIG_IsTmpObj(res4)) {
10631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
10632 } else {
10633 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
10635 }
10636 if (SWIG_IsTmpObj(res5)) {
10637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
10638 } else {
10639 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
10641 }
10642 if (SWIG_IsTmpObj(res6)) {
10643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
10644 } else {
10645 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
10647 }
10648 return resultobj;
10649fail:
10650 return NULL;
10651}
10652
10653
10654SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10655 PyObject *resultobj = 0;
10656 PLFLT arg1 ;
10657 PLFLT arg2 ;
10658 double val1 ;
10659 int ecode1 = 0 ;
10660 double val2 ;
10661 int ecode2 = 0 ;
10662 PyObject *swig_obj[2] ;
10663
10664 (void)self;
10665 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10666 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10667 if (!SWIG_IsOK(ecode1)) {
10668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10669 }
10670 arg1 = (PLFLT)(val1);
10671 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10672 if (!SWIG_IsOK(ecode2)) {
10673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10674 }
10675 arg2 = (PLFLT)(val2);
10676 plschr(arg1,arg2);
10677 resultobj = SWIG_Py_Void();
10678 return resultobj;
10679fail:
10680 return NULL;
10681}
10682
10683
10684SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10685 PyObject *resultobj = 0;
10686 PLINT *arg1 = (PLINT *) 0 ;
10687 PLINT *arg2 = (PLINT *) 0 ;
10688 PLINT *arg3 = (PLINT *) 0 ;
10689 PLINT arg4 ;
10690 PyArrayObject *tmp1 = NULL ;
10691 PyArrayObject *tmp2 = NULL ;
10692 PyArrayObject *tmp3 = NULL ;
10693 PyObject *swig_obj[3] ;
10694
10695 (void)self;
10696 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10697 {
10698 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10699 if ( tmp1 == NULL )
10700 return NULL;
10701 Alen = PyArray_DIMS( tmp1 )[0];
10702 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10703 }
10704 {
10705 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10706 if ( tmp2 == NULL )
10707 return NULL;
10708 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10709 {
10710 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10711 return NULL;
10712 }
10713 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10714 }
10715 {
10716 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10717 if ( tmp3 == NULL )
10718 return NULL;
10719 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10720 {
10721 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10722 return NULL;
10723 }
10724 arg4 = PyArray_DIMS( tmp3 )[0];
10725 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10726 }
10727 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10728 resultobj = SWIG_Py_Void();
10729 {
10730 Py_CLEAR( tmp1 );
10731 }
10732 {
10733 Py_CLEAR( tmp2 );
10734 }
10735 {
10736 Py_CLEAR( tmp3 );
10737 }
10738 return resultobj;
10739fail:
10740 {
10741 Py_CLEAR( tmp1 );
10742 }
10743 {
10744 Py_CLEAR( tmp2 );
10745 }
10746 {
10747 Py_CLEAR( tmp3 );
10748 }
10749 return NULL;
10750}
10751
10752
10753SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10754 PyObject *resultobj = 0;
10755 PLINT *arg1 = (PLINT *) 0 ;
10756 PLINT *arg2 = (PLINT *) 0 ;
10757 PLINT *arg3 = (PLINT *) 0 ;
10758 PLFLT *arg4 = (PLFLT *) 0 ;
10759 PLINT arg5 ;
10760 PyArrayObject *tmp1 = NULL ;
10761 PyArrayObject *tmp2 = NULL ;
10762 PyArrayObject *tmp3 = NULL ;
10763 PyArrayObject *tmp4 = NULL ;
10764 PyObject *swig_obj[4] ;
10765
10766 (void)self;
10767 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10768 {
10769 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10770 if ( tmp1 == NULL )
10771 return NULL;
10772 Alen = PyArray_DIMS( tmp1 )[0];
10773 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10774 }
10775 {
10776 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10777 if ( tmp2 == NULL )
10778 return NULL;
10779 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10780 {
10781 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10782 return NULL;
10783 }
10784 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10785 }
10786 {
10787 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10788 if ( tmp3 == NULL )
10789 return NULL;
10790 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10791 {
10792 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10793 return NULL;
10794 }
10795 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10796 }
10797 {
10798 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10799 if ( tmp4 == NULL )
10800 return NULL;
10801 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10802 {
10803 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10804 return NULL;
10805 }
10806 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10807 arg5 = PyArray_DIMS( tmp4 )[0];
10808 }
10809 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10810 resultobj = SWIG_Py_Void();
10811 {
10812 Py_CLEAR( tmp1 );
10813 }
10814 {
10815 Py_CLEAR( tmp2 );
10816 }
10817 {
10818 Py_CLEAR( tmp3 );
10819 }
10820 {
10821 Py_CLEAR( tmp4 );
10822 }
10823 return resultobj;
10824fail:
10825 {
10826 Py_CLEAR( tmp1 );
10827 }
10828 {
10829 Py_CLEAR( tmp2 );
10830 }
10831 {
10832 Py_CLEAR( tmp3 );
10833 }
10834 {
10835 Py_CLEAR( tmp4 );
10836 }
10837 return NULL;
10838}
10839
10840
10841SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10842 PyObject *resultobj = 0;
10843 PLINT arg1 ;
10844 int val1 ;
10845 int ecode1 = 0 ;
10846 PyObject *swig_obj[1] ;
10847
10848 (void)self;
10849 if (!args) SWIG_fail;
10850 swig_obj[0] = args;
10851 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10852 if (!SWIG_IsOK(ecode1)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10854 }
10855 arg1 = (PLINT)(val1);
10856 plscmap0n(arg1);
10857 resultobj = SWIG_Py_Void();
10858 return resultobj;
10859fail:
10860 return NULL;
10861}
10862
10863
10864SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10865 PyObject *resultobj = 0;
10866 PLINT *arg1 = (PLINT *) 0 ;
10867 PLINT *arg2 = (PLINT *) 0 ;
10868 PLINT *arg3 = (PLINT *) 0 ;
10869 PLINT arg4 ;
10870 PyArrayObject *tmp1 = NULL ;
10871 PyArrayObject *tmp2 = NULL ;
10872 PyArrayObject *tmp3 = NULL ;
10873 PyObject *swig_obj[3] ;
10874
10875 (void)self;
10876 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10877 {
10878 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10879 if ( tmp1 == NULL )
10880 return NULL;
10881 Alen = PyArray_DIMS( tmp1 )[0];
10882 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10883 }
10884 {
10885 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10886 if ( tmp2 == NULL )
10887 return NULL;
10888 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10889 {
10890 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10891 return NULL;
10892 }
10893 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10894 }
10895 {
10896 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10897 if ( tmp3 == NULL )
10898 return NULL;
10899 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10900 {
10901 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10902 return NULL;
10903 }
10904 arg4 = PyArray_DIMS( tmp3 )[0];
10905 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10906 }
10907 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10908 resultobj = SWIG_Py_Void();
10909 {
10910 Py_CLEAR( tmp1 );
10911 }
10912 {
10913 Py_CLEAR( tmp2 );
10914 }
10915 {
10916 Py_CLEAR( tmp3 );
10917 }
10918 return resultobj;
10919fail:
10920 {
10921 Py_CLEAR( tmp1 );
10922 }
10923 {
10924 Py_CLEAR( tmp2 );
10925 }
10926 {
10927 Py_CLEAR( tmp3 );
10928 }
10929 return NULL;
10930}
10931
10932
10933SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10934 PyObject *resultobj = 0;
10935 PLINT *arg1 = (PLINT *) 0 ;
10936 PLINT *arg2 = (PLINT *) 0 ;
10937 PLINT *arg3 = (PLINT *) 0 ;
10938 PLFLT *arg4 = (PLFLT *) 0 ;
10939 PLINT arg5 ;
10940 PyArrayObject *tmp1 = NULL ;
10941 PyArrayObject *tmp2 = NULL ;
10942 PyArrayObject *tmp3 = NULL ;
10943 PyArrayObject *tmp4 = NULL ;
10944 PyObject *swig_obj[4] ;
10945
10946 (void)self;
10947 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10948 {
10949 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10950 if ( tmp1 == NULL )
10951 return NULL;
10952 Alen = PyArray_DIMS( tmp1 )[0];
10953 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10954 }
10955 {
10956 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10957 if ( tmp2 == NULL )
10958 return NULL;
10959 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10960 {
10961 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10962 return NULL;
10963 }
10964 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10965 }
10966 {
10967 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10968 if ( tmp3 == NULL )
10969 return NULL;
10970 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10971 {
10972 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10973 return NULL;
10974 }
10975 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10976 }
10977 {
10978 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10979 if ( tmp4 == NULL )
10980 return NULL;
10981 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10982 {
10983 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10984 return NULL;
10985 }
10986 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10987 arg5 = PyArray_DIMS( tmp4 )[0];
10988 }
10989 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10990 resultobj = SWIG_Py_Void();
10991 {
10992 Py_CLEAR( tmp1 );
10993 }
10994 {
10995 Py_CLEAR( tmp2 );
10996 }
10997 {
10998 Py_CLEAR( tmp3 );
10999 }
11000 {
11001 Py_CLEAR( tmp4 );
11002 }
11003 return resultobj;
11004fail:
11005 {
11006 Py_CLEAR( tmp1 );
11007 }
11008 {
11009 Py_CLEAR( tmp2 );
11010 }
11011 {
11012 Py_CLEAR( tmp3 );
11013 }
11014 {
11015 Py_CLEAR( tmp4 );
11016 }
11017 return NULL;
11018}
11019
11020
11021SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
11022 PyObject *resultobj = 0;
11023 PLBOOL arg1 ;
11024 PLINT arg2 ;
11025 PLFLT *arg3 = (PLFLT *) 0 ;
11026 PLFLT *arg4 = (PLFLT *) 0 ;
11027 PLFLT *arg5 = (PLFLT *) 0 ;
11028 PLFLT *arg6 = (PLFLT *) 0 ;
11029 PLBOOL *arg7 = (PLBOOL *) 0 ;
11030 int val1 ;
11031 int ecode1 = 0 ;
11032 PyArrayObject *tmp2 = NULL ;
11033 PyArrayObject *tmp4 = NULL ;
11034 PyArrayObject *tmp5 = NULL ;
11035 PyArrayObject *tmp6 = NULL ;
11036 PyArrayObject *tmp7 = NULL ;
11037 PyObject *swig_obj[6] ;
11038
11039 (void)self;
11040 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11041 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11042 if (!SWIG_IsOK(ecode1)) {
11043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11044 }
11045 arg1 = (PLBOOL)(val1);
11046 {
11047 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11048 if ( tmp2 == NULL )
11049 return NULL;
11050 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11051 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11052 }
11053 {
11054 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11055 if ( tmp4 == NULL )
11056 return NULL;
11057 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11058 {
11059 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11060 return NULL;
11061 }
11062 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11063 }
11064 {
11065 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11066 if ( tmp5 == NULL )
11067 return NULL;
11068 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11069 {
11070 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11071 return NULL;
11072 }
11073 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11074 }
11075 {
11076 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11077 if ( tmp6 == NULL )
11078 return NULL;
11079 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11080 {
11081 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11082 return NULL;
11083 }
11084 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11085 }
11086 {
11087 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11088 if ( tmp7 == NULL )
11089 return NULL;
11090 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11091 {
11092 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11093 return NULL;
11094 }
11095 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11096 }
11097 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11098 resultobj = SWIG_Py_Void();
11099 {
11100 Py_CLEAR( tmp2 );
11101 }
11102 {
11103 Py_CLEAR( tmp4 );
11104 }
11105 {
11106 Py_CLEAR( tmp5 );
11107 }
11108 {
11109 Py_CLEAR( tmp6 );
11110 }
11111 {
11112 Py_CLEAR( tmp7 );
11113 }
11114 return resultobj;
11115fail:
11116 {
11117 Py_CLEAR( tmp2 );
11118 }
11119 {
11120 Py_CLEAR( tmp4 );
11121 }
11122 {
11123 Py_CLEAR( tmp5 );
11124 }
11125 {
11126 Py_CLEAR( tmp6 );
11127 }
11128 {
11129 Py_CLEAR( tmp7 );
11130 }
11131 return NULL;
11132}
11133
11134
11135SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11136 PyObject *resultobj = 0;
11137 PLBOOL arg1 ;
11138 PLINT arg2 ;
11139 PLFLT *arg3 = (PLFLT *) 0 ;
11140 PLFLT *arg4 = (PLFLT *) 0 ;
11141 PLFLT *arg5 = (PLFLT *) 0 ;
11142 PLFLT *arg6 = (PLFLT *) 0 ;
11143 PLFLT *arg7 = (PLFLT *) 0 ;
11144 PLBOOL *arg8 = (PLBOOL *) 0 ;
11145 int val1 ;
11146 int ecode1 = 0 ;
11147 PyArrayObject *tmp2 = NULL ;
11148 PyArrayObject *tmp4 = NULL ;
11149 PyArrayObject *tmp5 = NULL ;
11150 PyArrayObject *tmp6 = NULL ;
11151 PyArrayObject *tmp7 = NULL ;
11152 PyArrayObject *tmp8 = NULL ;
11153 PyObject *swig_obj[7] ;
11154
11155 (void)self;
11156 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11157 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11158 if (!SWIG_IsOK(ecode1)) {
11159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11160 }
11161 arg1 = (PLBOOL)(val1);
11162 {
11163 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11164 if ( tmp2 == NULL )
11165 return NULL;
11166 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11167 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11168 }
11169 {
11170 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11171 if ( tmp4 == NULL )
11172 return NULL;
11173 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11174 {
11175 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11176 return NULL;
11177 }
11178 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11179 }
11180 {
11181 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11182 if ( tmp5 == NULL )
11183 return NULL;
11184 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11185 {
11186 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11187 return NULL;
11188 }
11189 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11190 }
11191 {
11192 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11193 if ( tmp6 == NULL )
11194 return NULL;
11195 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11196 {
11197 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11198 return NULL;
11199 }
11200 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11201 }
11202 {
11203 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11204 if ( tmp7 == NULL )
11205 return NULL;
11206 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11207 {
11208 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11209 return NULL;
11210 }
11211 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11212 }
11213 {
11214 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11215 if ( tmp8 == NULL )
11216 return NULL;
11217 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11218 {
11219 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11220 return NULL;
11221 }
11222 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11223 }
11224 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11225 resultobj = SWIG_Py_Void();
11226 {
11227 Py_CLEAR( tmp2 );
11228 }
11229 {
11230 Py_CLEAR( tmp4 );
11231 }
11232 {
11233 Py_CLEAR( tmp5 );
11234 }
11235 {
11236 Py_CLEAR( tmp6 );
11237 }
11238 {
11239 Py_CLEAR( tmp7 );
11240 }
11241 {
11242 Py_CLEAR( tmp8 );
11243 }
11244 return resultobj;
11245fail:
11246 {
11247 Py_CLEAR( tmp2 );
11248 }
11249 {
11250 Py_CLEAR( tmp4 );
11251 }
11252 {
11253 Py_CLEAR( tmp5 );
11254 }
11255 {
11256 Py_CLEAR( tmp6 );
11257 }
11258 {
11259 Py_CLEAR( tmp7 );
11260 }
11261 {
11262 Py_CLEAR( tmp8 );
11263 }
11264 return NULL;
11265}
11266
11267
11268SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11269 PyObject *resultobj = 0;
11270 PLINT arg1 ;
11271 int val1 ;
11272 int ecode1 = 0 ;
11273 PyObject *swig_obj[1] ;
11274
11275 (void)self;
11276 if (!args) SWIG_fail;
11277 swig_obj[0] = args;
11278 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11279 if (!SWIG_IsOK(ecode1)) {
11280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11281 }
11282 arg1 = (PLINT)(val1);
11283 plscmap1n(arg1);
11284 resultobj = SWIG_Py_Void();
11285 return resultobj;
11286fail:
11287 return NULL;
11288}
11289
11290
11291SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11292 PyObject *resultobj = 0;
11293 PLFLT arg1 ;
11294 PLFLT arg2 ;
11295 double val1 ;
11296 int ecode1 = 0 ;
11297 double val2 ;
11298 int ecode2 = 0 ;
11299 PyObject *swig_obj[2] ;
11300
11301 (void)self;
11302 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11303 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11304 if (!SWIG_IsOK(ecode1)) {
11305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11306 }
11307 arg1 = (PLFLT)(val1);
11308 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11309 if (!SWIG_IsOK(ecode2)) {
11310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11311 }
11312 arg2 = (PLFLT)(val2);
11313 plscmap1_range(arg1,arg2);
11314 resultobj = SWIG_Py_Void();
11315 return resultobj;
11316fail:
11317 return NULL;
11318}
11319
11320
11321SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11322 PyObject *resultobj = 0;
11323 PLFLT *arg1 = (PLFLT *) 0 ;
11324 PLFLT *arg2 = (PLFLT *) 0 ;
11325 PLFLT temp1 ;
11326 int res1 = SWIG_TMPOBJ ;
11327 PLFLT temp2 ;
11328 int res2 = SWIG_TMPOBJ ;
11329
11330 arg1 = &temp1;
11331 arg2 = &temp2;
11332 (void)self;
11333 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11334 plgcmap1_range(arg1,arg2);
11335 resultobj = SWIG_Py_Void();
11336 if (SWIG_IsTmpObj(res1)) {
11337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
11338 } else {
11339 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
11341 }
11342 if (SWIG_IsTmpObj(res2)) {
11343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
11344 } else {
11345 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
11347 }
11348 return resultobj;
11349fail:
11350 return NULL;
11351}
11352
11353
11354SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11355 PyObject *resultobj = 0;
11356 PLINT arg1 ;
11357 PLINT arg2 ;
11358 PLINT arg3 ;
11359 PLINT arg4 ;
11360 int val1 ;
11361 int ecode1 = 0 ;
11362 int val2 ;
11363 int ecode2 = 0 ;
11364 int val3 ;
11365 int ecode3 = 0 ;
11366 int val4 ;
11367 int ecode4 = 0 ;
11368 PyObject *swig_obj[4] ;
11369
11370 (void)self;
11371 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11372 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11373 if (!SWIG_IsOK(ecode1)) {
11374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11375 }
11376 arg1 = (PLINT)(val1);
11377 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11378 if (!SWIG_IsOK(ecode2)) {
11379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11380 }
11381 arg2 = (PLINT)(val2);
11382 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11383 if (!SWIG_IsOK(ecode3)) {
11384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11385 }
11386 arg3 = (PLINT)(val3);
11387 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11388 if (!SWIG_IsOK(ecode4)) {
11389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11390 }
11391 arg4 = (PLINT)(val4);
11392 plscol0(arg1,arg2,arg3,arg4);
11393 resultobj = SWIG_Py_Void();
11394 return resultobj;
11395fail:
11396 return NULL;
11397}
11398
11399
11400SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11401 PyObject *resultobj = 0;
11402 PLINT arg1 ;
11403 PLINT arg2 ;
11404 PLINT arg3 ;
11405 PLINT arg4 ;
11406 PLFLT arg5 ;
11407 int val1 ;
11408 int ecode1 = 0 ;
11409 int val2 ;
11410 int ecode2 = 0 ;
11411 int val3 ;
11412 int ecode3 = 0 ;
11413 int val4 ;
11414 int ecode4 = 0 ;
11415 double val5 ;
11416 int ecode5 = 0 ;
11417 PyObject *swig_obj[5] ;
11418
11419 (void)self;
11420 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11421 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11422 if (!SWIG_IsOK(ecode1)) {
11423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11424 }
11425 arg1 = (PLINT)(val1);
11426 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11427 if (!SWIG_IsOK(ecode2)) {
11428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11429 }
11430 arg2 = (PLINT)(val2);
11431 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11432 if (!SWIG_IsOK(ecode3)) {
11433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11434 }
11435 arg3 = (PLINT)(val3);
11436 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11437 if (!SWIG_IsOK(ecode4)) {
11438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11439 }
11440 arg4 = (PLINT)(val4);
11441 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11442 if (!SWIG_IsOK(ecode5)) {
11443 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11444 }
11445 arg5 = (PLFLT)(val5);
11446 plscol0a(arg1,arg2,arg3,arg4,arg5);
11447 resultobj = SWIG_Py_Void();
11448 return resultobj;
11449fail:
11450 return NULL;
11451}
11452
11453
11454SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11455 PyObject *resultobj = 0;
11456 PLINT arg1 ;
11457 PLINT arg2 ;
11458 PLINT arg3 ;
11459 int val1 ;
11460 int ecode1 = 0 ;
11461 int val2 ;
11462 int ecode2 = 0 ;
11463 int val3 ;
11464 int ecode3 = 0 ;
11465 PyObject *swig_obj[3] ;
11466
11467 (void)self;
11468 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11469 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11470 if (!SWIG_IsOK(ecode1)) {
11471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11472 }
11473 arg1 = (PLINT)(val1);
11474 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11475 if (!SWIG_IsOK(ecode2)) {
11476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11477 }
11478 arg2 = (PLINT)(val2);
11479 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11480 if (!SWIG_IsOK(ecode3)) {
11481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11482 }
11483 arg3 = (PLINT)(val3);
11484 plscolbg(arg1,arg2,arg3);
11485 resultobj = SWIG_Py_Void();
11486 return resultobj;
11487fail:
11488 return NULL;
11489}
11490
11491
11492SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11493 PyObject *resultobj = 0;
11494 PLINT arg1 ;
11495 PLINT arg2 ;
11496 PLINT arg3 ;
11497 PLFLT arg4 ;
11498 int val1 ;
11499 int ecode1 = 0 ;
11500 int val2 ;
11501 int ecode2 = 0 ;
11502 int val3 ;
11503 int ecode3 = 0 ;
11504 double val4 ;
11505 int ecode4 = 0 ;
11506 PyObject *swig_obj[4] ;
11507
11508 (void)self;
11509 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11510 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11511 if (!SWIG_IsOK(ecode1)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11513 }
11514 arg1 = (PLINT)(val1);
11515 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11516 if (!SWIG_IsOK(ecode2)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11518 }
11519 arg2 = (PLINT)(val2);
11520 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11521 if (!SWIG_IsOK(ecode3)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11523 }
11524 arg3 = (PLINT)(val3);
11525 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11526 if (!SWIG_IsOK(ecode4)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11528 }
11529 arg4 = (PLFLT)(val4);
11530 plscolbga(arg1,arg2,arg3,arg4);
11531 resultobj = SWIG_Py_Void();
11532 return resultobj;
11533fail:
11534 return NULL;
11535}
11536
11537
11538SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11539 PyObject *resultobj = 0;
11540 PLINT arg1 ;
11541 int val1 ;
11542 int ecode1 = 0 ;
11543 PyObject *swig_obj[1] ;
11544
11545 (void)self;
11546 if (!args) SWIG_fail;
11547 swig_obj[0] = args;
11548 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11549 if (!SWIG_IsOK(ecode1)) {
11550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11551 }
11552 arg1 = (PLINT)(val1);
11553 plscolor(arg1);
11554 resultobj = SWIG_Py_Void();
11555 return resultobj;
11556fail:
11557 return NULL;
11558}
11559
11560
11561SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11562 PyObject *resultobj = 0;
11563 PLINT arg1 ;
11564 int val1 ;
11565 int ecode1 = 0 ;
11566 PyObject *swig_obj[1] ;
11567
11568 (void)self;
11569 if (!args) SWIG_fail;
11570 swig_obj[0] = args;
11571 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11572 if (!SWIG_IsOK(ecode1)) {
11573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11574 }
11575 arg1 = (PLINT)(val1);
11576 plscompression(arg1);
11577 resultobj = SWIG_Py_Void();
11578 return resultobj;
11579fail:
11580 return NULL;
11581}
11582
11583
11584SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11585 PyObject *resultobj = 0;
11586 char *arg1 = (char *) 0 ;
11587 int res1 ;
11588 char *buf1 = 0 ;
11589 int alloc1 = 0 ;
11590 PyObject *swig_obj[1] ;
11591
11592 (void)self;
11593 if (!args) SWIG_fail;
11594 swig_obj[0] = args;
11595 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11598 }
11599 arg1 = (char *)(buf1);
11600 plsdev((char const *)arg1);
11601 resultobj = SWIG_Py_Void();
11602 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11603 return resultobj;
11604fail:
11605 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11606 return NULL;
11607}
11608
11609
11610SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11611 PyObject *resultobj = 0;
11612 PLFLT arg1 ;
11613 PLFLT arg2 ;
11614 PLFLT arg3 ;
11615 PLFLT arg4 ;
11616 double val1 ;
11617 int ecode1 = 0 ;
11618 double val2 ;
11619 int ecode2 = 0 ;
11620 double val3 ;
11621 int ecode3 = 0 ;
11622 double val4 ;
11623 int ecode4 = 0 ;
11624 PyObject *swig_obj[4] ;
11625
11626 (void)self;
11627 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11628 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11629 if (!SWIG_IsOK(ecode1)) {
11630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11631 }
11632 arg1 = (PLFLT)(val1);
11633 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11634 if (!SWIG_IsOK(ecode2)) {
11635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11636 }
11637 arg2 = (PLFLT)(val2);
11638 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11639 if (!SWIG_IsOK(ecode3)) {
11640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11641 }
11642 arg3 = (PLFLT)(val3);
11643 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11644 if (!SWIG_IsOK(ecode4)) {
11645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11646 }
11647 arg4 = (PLFLT)(val4);
11648 plsdidev(arg1,arg2,arg3,arg4);
11649 resultobj = SWIG_Py_Void();
11650 return resultobj;
11651fail:
11652 return NULL;
11653}
11654
11655
11656SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11657 PyObject *resultobj = 0;
11658 PLINT arg1 ;
11659 PLINT arg2 ;
11660 PLINT arg3 ;
11661 PLINT arg4 ;
11662 PLFLT arg5 ;
11663 PLFLT arg6 ;
11664 int val1 ;
11665 int ecode1 = 0 ;
11666 int val2 ;
11667 int ecode2 = 0 ;
11668 int val3 ;
11669 int ecode3 = 0 ;
11670 int val4 ;
11671 int ecode4 = 0 ;
11672 double val5 ;
11673 int ecode5 = 0 ;
11674 double val6 ;
11675 int ecode6 = 0 ;
11676 PyObject *swig_obj[6] ;
11677
11678 (void)self;
11679 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11680 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11681 if (!SWIG_IsOK(ecode1)) {
11682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11683 }
11684 arg1 = (PLINT)(val1);
11685 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11686 if (!SWIG_IsOK(ecode2)) {
11687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11688 }
11689 arg2 = (PLINT)(val2);
11690 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11691 if (!SWIG_IsOK(ecode3)) {
11692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11693 }
11694 arg3 = (PLINT)(val3);
11695 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11696 if (!SWIG_IsOK(ecode4)) {
11697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11698 }
11699 arg4 = (PLINT)(val4);
11700 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11701 if (!SWIG_IsOK(ecode5)) {
11702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11703 }
11704 arg5 = (PLFLT)(val5);
11705 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11706 if (!SWIG_IsOK(ecode6)) {
11707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11708 }
11709 arg6 = (PLFLT)(val6);
11710 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11711 resultobj = SWIG_Py_Void();
11712 return resultobj;
11713fail:
11714 return NULL;
11715}
11716
11717
11718SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11719 PyObject *resultobj = 0;
11720 PLFLT arg1 ;
11721 double val1 ;
11722 int ecode1 = 0 ;
11723 PyObject *swig_obj[1] ;
11724
11725 (void)self;
11726 if (!args) SWIG_fail;
11727 swig_obj[0] = args;
11728 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11729 if (!SWIG_IsOK(ecode1)) {
11730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11731 }
11732 arg1 = (PLFLT)(val1);
11733 plsdiori(arg1);
11734 resultobj = SWIG_Py_Void();
11735 return resultobj;
11736fail:
11737 return NULL;
11738}
11739
11740
11741SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11742 PyObject *resultobj = 0;
11743 PLFLT arg1 ;
11744 PLFLT arg2 ;
11745 PLFLT arg3 ;
11746 PLFLT arg4 ;
11747 double val1 ;
11748 int ecode1 = 0 ;
11749 double val2 ;
11750 int ecode2 = 0 ;
11751 double val3 ;
11752 int ecode3 = 0 ;
11753 double val4 ;
11754 int ecode4 = 0 ;
11755 PyObject *swig_obj[4] ;
11756
11757 (void)self;
11758 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11759 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11760 if (!SWIG_IsOK(ecode1)) {
11761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11762 }
11763 arg1 = (PLFLT)(val1);
11764 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11765 if (!SWIG_IsOK(ecode2)) {
11766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11767 }
11768 arg2 = (PLFLT)(val2);
11769 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11770 if (!SWIG_IsOK(ecode3)) {
11771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11772 }
11773 arg3 = (PLFLT)(val3);
11774 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11775 if (!SWIG_IsOK(ecode4)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11777 }
11778 arg4 = (PLFLT)(val4);
11779 plsdiplt(arg1,arg2,arg3,arg4);
11780 resultobj = SWIG_Py_Void();
11781 return resultobj;
11782fail:
11783 return NULL;
11784}
11785
11786
11787SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11788 PyObject *resultobj = 0;
11789 PLFLT arg1 ;
11790 PLFLT arg2 ;
11791 PLFLT arg3 ;
11792 PLFLT arg4 ;
11793 double val1 ;
11794 int ecode1 = 0 ;
11795 double val2 ;
11796 int ecode2 = 0 ;
11797 double val3 ;
11798 int ecode3 = 0 ;
11799 double val4 ;
11800 int ecode4 = 0 ;
11801 PyObject *swig_obj[4] ;
11802
11803 (void)self;
11804 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11805 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11806 if (!SWIG_IsOK(ecode1)) {
11807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11808 }
11809 arg1 = (PLFLT)(val1);
11810 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11811 if (!SWIG_IsOK(ecode2)) {
11812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11813 }
11814 arg2 = (PLFLT)(val2);
11815 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11816 if (!SWIG_IsOK(ecode3)) {
11817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11818 }
11819 arg3 = (PLFLT)(val3);
11820 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11821 if (!SWIG_IsOK(ecode4)) {
11822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11823 }
11824 arg4 = (PLFLT)(val4);
11825 plsdiplz(arg1,arg2,arg3,arg4);
11826 resultobj = SWIG_Py_Void();
11827 return resultobj;
11828fail:
11829 return NULL;
11830}
11831
11832
11833SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11834 PyObject *resultobj = 0;
11835 unsigned int arg1 ;
11836 unsigned int val1 ;
11837 int ecode1 = 0 ;
11838 PyObject *swig_obj[1] ;
11839
11840 (void)self;
11841 if (!args) SWIG_fail;
11842 swig_obj[0] = args;
11843 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11844 if (!SWIG_IsOK(ecode1)) {
11845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11846 }
11847 arg1 = (unsigned int)(val1);
11848 plseed(arg1);
11849 resultobj = SWIG_Py_Void();
11850 return resultobj;
11851fail:
11852 return NULL;
11853}
11854
11855
11856SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11857 PyObject *resultobj = 0;
11858 char arg1 ;
11859 char val1 ;
11860 int ecode1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 (void)self;
11864 if (!args) SWIG_fail;
11865 swig_obj[0] = args;
11866 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11867 if (!SWIG_IsOK(ecode1)) {
11868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11869 }
11870 arg1 = (char)(val1);
11871 plsesc(arg1);
11872 resultobj = SWIG_Py_Void();
11873 return resultobj;
11874fail:
11875 return NULL;
11876}
11877
11878
11879SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11880 PyObject *resultobj = 0;
11881 char *arg1 = (char *) 0 ;
11882 char *arg2 = (char *) 0 ;
11883 int res1 ;
11884 char *buf1 = 0 ;
11885 int alloc1 = 0 ;
11886 int res2 ;
11887 char *buf2 = 0 ;
11888 int alloc2 = 0 ;
11889 PyObject *swig_obj[2] ;
11890 PLINT result;
11891
11892 (void)self;
11893 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11894 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11895 if (!SWIG_IsOK(res1)) {
11896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11897 }
11898 arg1 = (char *)(buf1);
11899 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11900 if (!SWIG_IsOK(res2)) {
11901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11902 }
11903 arg2 = (char *)(buf2);
11904 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11905 resultobj = SWIG_From_int((int)(result));
11906 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11907 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11908 return resultobj;
11909fail:
11910 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11911 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11912 return NULL;
11913}
11914
11915
11916SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11917 PyObject *resultobj = 0;
11918 PLINT arg1 ;
11919 PLINT arg2 ;
11920 PLINT arg3 ;
11921 int val1 ;
11922 int ecode1 = 0 ;
11923 int val2 ;
11924 int ecode2 = 0 ;
11925 int val3 ;
11926 int ecode3 = 0 ;
11927 PyObject *swig_obj[3] ;
11928
11929 (void)self;
11930 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11931 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11932 if (!SWIG_IsOK(ecode1)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11934 }
11935 arg1 = (PLINT)(val1);
11936 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11937 if (!SWIG_IsOK(ecode2)) {
11938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11939 }
11940 arg2 = (PLINT)(val2);
11941 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11942 if (!SWIG_IsOK(ecode3)) {
11943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11944 }
11945 arg3 = (PLINT)(val3);
11946 plsfam(arg1,arg2,arg3);
11947 resultobj = SWIG_Py_Void();
11948 return resultobj;
11949fail:
11950 return NULL;
11951}
11952
11953
11954SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11955 PyObject *resultobj = 0;
11956 PLUNICODE arg1 ;
11957 unsigned int val1 ;
11958 int ecode1 = 0 ;
11959 PyObject *swig_obj[1] ;
11960
11961 (void)self;
11962 if (!args) SWIG_fail;
11963 swig_obj[0] = args;
11964 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11965 if (!SWIG_IsOK(ecode1)) {
11966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11967 }
11968 arg1 = (PLUNICODE)(val1);
11969 plsfci(arg1);
11970 resultobj = SWIG_Py_Void();
11971 return resultobj;
11972fail:
11973 return NULL;
11974}
11975
11976
11977SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11978 PyObject *resultobj = 0;
11979 char *arg1 = (char *) 0 ;
11980 int res1 ;
11981 char *buf1 = 0 ;
11982 int alloc1 = 0 ;
11983 PyObject *swig_obj[1] ;
11984
11985 (void)self;
11986 if (!args) SWIG_fail;
11987 swig_obj[0] = args;
11988 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11989 if (!SWIG_IsOK(res1)) {
11990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11991 }
11992 arg1 = (char *)(buf1);
11993 plsfnam((char const *)arg1);
11994 resultobj = SWIG_Py_Void();
11995 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11996 return resultobj;
11997fail:
11998 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11999 return NULL;
12000}
12001
12002
12003SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
12004 PyObject *resultobj = 0;
12005 PLINT arg1 ;
12006 PLINT arg2 ;
12007 PLINT arg3 ;
12008 int val1 ;
12009 int ecode1 = 0 ;
12010 int val2 ;
12011 int ecode2 = 0 ;
12012 int val3 ;
12013 int ecode3 = 0 ;
12014 PyObject *swig_obj[3] ;
12015
12016 (void)self;
12017 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
12018 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12019 if (!SWIG_IsOK(ecode1)) {
12020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
12021 }
12022 arg1 = (PLINT)(val1);
12023 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12024 if (!SWIG_IsOK(ecode2)) {
12025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
12026 }
12027 arg2 = (PLINT)(val2);
12028 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12029 if (!SWIG_IsOK(ecode3)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
12031 }
12032 arg3 = (PLINT)(val3);
12033 plsfont(arg1,arg2,arg3);
12034 resultobj = SWIG_Py_Void();
12035 return resultobj;
12036fail:
12037 return NULL;
12038}
12039
12040
12041SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12042 PyObject *resultobj = 0;
12043 PLFLT **arg1 = (PLFLT **) 0 ;
12044 PLINT arg2 ;
12045 PLINT arg3 ;
12046 defined_func arg4 = (defined_func) 0 ;
12047 PLFLT arg5 ;
12048 PLFLT arg6 ;
12049 PLFLT arg7 ;
12050 PLFLT arg8 ;
12051 PLFLT *arg9 = (PLFLT *) 0 ;
12052 PLINT arg10 ;
12053 PLFLT arg11 ;
12054 PLINT arg12 ;
12055 PLFLT arg13 ;
12056 fill_func arg14 = (fill_func) 0 ;
12057 PLBOOL arg15 ;
12058 pltr_func arg16 = (pltr_func) 0 ;
12059 PLPointer arg17 = (PLPointer) 0 ;
12060 PyArrayObject *tmp1 = NULL ;
12061 double val5 ;
12062 int ecode5 = 0 ;
12063 double val6 ;
12064 int ecode6 = 0 ;
12065 double val7 ;
12066 int ecode7 = 0 ;
12067 double val8 ;
12068 int ecode8 = 0 ;
12069 PyArrayObject *tmp9 = NULL ;
12070 double val11 ;
12071 int ecode11 = 0 ;
12072 int val12 ;
12073 int ecode12 = 0 ;
12074 double val13 ;
12075 int ecode13 = 0 ;
12076 int val15 ;
12077 int ecode15 = 0 ;
12078 PyObject *swig_obj[12] ;
12079
12080 {
12081 python_pltr = 0;
12082 arg16 = NULL;
12083 }
12084 {
12085 arg17 = NULL;
12086 }
12087 {
12088 arg4 = NULL;
12089 }
12090 {
12091 arg14 = plfill;
12092 }
12093 (void)self;
12094 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12095 {
12096 int i, size;
12097 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12098 if ( tmp1 == NULL )
12099 return NULL;
12100 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12101 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12102 size = arg3;
12103 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12104 for ( i = 0; i < arg2; i++ )
12105 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12106 }
12107 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12108 if (!SWIG_IsOK(ecode5)) {
12109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12110 }
12111 arg5 = (PLFLT)(val5);
12112 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12113 if (!SWIG_IsOK(ecode6)) {
12114 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12115 }
12116 arg6 = (PLFLT)(val6);
12117 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12118 if (!SWIG_IsOK(ecode7)) {
12119 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12120 }
12121 arg7 = (PLFLT)(val7);
12122 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12123 if (!SWIG_IsOK(ecode8)) {
12124 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12125 }
12126 arg8 = (PLFLT)(val8);
12127 {
12128 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12129 if ( tmp9 == NULL )
12130 return NULL;
12131 arg10 = PyArray_DIMS( tmp9 )[0];
12132 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12133 }
12134 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12135 if (!SWIG_IsOK(ecode11)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12137 }
12138 arg11 = (PLFLT)(val11);
12139 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12140 if (!SWIG_IsOK(ecode12)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12142 }
12143 arg12 = (PLINT)(val12);
12144 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12145 if (!SWIG_IsOK(ecode13)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12147 }
12148 arg13 = (PLFLT)(val13);
12149 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12150 if (!SWIG_IsOK(ecode15)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12152 }
12153 arg15 = (PLBOOL)(val15);
12154 if (swig_obj[10]) {
12155 {
12156 // it must be a callable or None
12157 if ( swig_obj[10] == Py_None )
12158 {
12159 arg16 = NULL;
12160 }
12161 else
12162 {
12163 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12164 {
12165 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12166 return NULL;
12167 }
12168 arg16 = marshal_pltr( swig_obj[10] );
12169 }
12170 }
12171 }
12172 if (swig_obj[11]) {
12173 {
12174 if ( swig_obj[11] == Py_None )
12175 arg17 = NULL;
12176 else
12177 {
12178 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12179 }
12180 }
12181 }
12182 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12183 resultobj = SWIG_Py_Void();
12184 {
12185 Py_CLEAR( tmp1 );
12186 free( arg1 );
12187 }
12188 {
12189 Py_CLEAR( tmp9 );
12190 }
12191 {
12192 cleanup_pltr();
12193 }
12194 {
12196 }
12197 return resultobj;
12198fail:
12199 {
12200 Py_CLEAR( tmp1 );
12201 free( arg1 );
12202 }
12203 {
12204 Py_CLEAR( tmp9 );
12205 }
12206 {
12207 cleanup_pltr();
12208 }
12209 {
12211 }
12212 return NULL;
12213}
12214
12215
12216SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12217 PyObject *resultobj = 0;
12218 PLFLT **arg1 = (PLFLT **) 0 ;
12219 PLINT arg2 ;
12220 PLINT arg3 ;
12221 defined_func arg4 = (defined_func) 0 ;
12222 PLFLT arg5 ;
12223 PLFLT arg6 ;
12224 PLFLT arg7 ;
12225 PLFLT arg8 ;
12226 PLFLT arg9 ;
12227 PLFLT arg10 ;
12228 PLINT arg11 ;
12229 PLFLT arg12 ;
12230 PLFLT arg13 ;
12231 PLINT arg14 ;
12232 PLFLT arg15 ;
12233 PLINT arg16 ;
12234 PLFLT arg17 ;
12235 fill_func arg18 = (fill_func) 0 ;
12236 PLBOOL arg19 ;
12237 pltr_func arg20 = (pltr_func) 0 ;
12238 PLPointer arg21 = (PLPointer) 0 ;
12239 PyArrayObject *tmp1 = NULL ;
12240 double val5 ;
12241 int ecode5 = 0 ;
12242 double val6 ;
12243 int ecode6 = 0 ;
12244 double val7 ;
12245 int ecode7 = 0 ;
12246 double val8 ;
12247 int ecode8 = 0 ;
12248 double val9 ;
12249 int ecode9 = 0 ;
12250 double val10 ;
12251 int ecode10 = 0 ;
12252 int val11 ;
12253 int ecode11 = 0 ;
12254 double val12 ;
12255 int ecode12 = 0 ;
12256 double val13 ;
12257 int ecode13 = 0 ;
12258 int val14 ;
12259 int ecode14 = 0 ;
12260 double val15 ;
12261 int ecode15 = 0 ;
12262 int val16 ;
12263 int ecode16 = 0 ;
12264 double val17 ;
12265 int ecode17 = 0 ;
12266 int val19 ;
12267 int ecode19 = 0 ;
12268 PyObject *swig_obj[17] ;
12269
12270 {
12271 python_pltr = 0;
12272 arg20 = NULL;
12273 }
12274 {
12275 arg21 = NULL;
12276 }
12277 {
12278 arg4 = NULL;
12279 }
12280 {
12281 arg18 = plfill;
12282 }
12283 (void)self;
12284 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12285 {
12286 int i, size;
12287 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12288 if ( tmp1 == NULL )
12289 return NULL;
12290 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12291 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12292 size = arg3;
12293 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12294 for ( i = 0; i < arg2; i++ )
12295 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12296 }
12297 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12298 if (!SWIG_IsOK(ecode5)) {
12299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12300 }
12301 arg5 = (PLFLT)(val5);
12302 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12303 if (!SWIG_IsOK(ecode6)) {
12304 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12305 }
12306 arg6 = (PLFLT)(val6);
12307 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12308 if (!SWIG_IsOK(ecode7)) {
12309 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12310 }
12311 arg7 = (PLFLT)(val7);
12312 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12313 if (!SWIG_IsOK(ecode8)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12315 }
12316 arg8 = (PLFLT)(val8);
12317 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12318 if (!SWIG_IsOK(ecode9)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12320 }
12321 arg9 = (PLFLT)(val9);
12322 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12323 if (!SWIG_IsOK(ecode10)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12325 }
12326 arg10 = (PLFLT)(val10);
12327 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12328 if (!SWIG_IsOK(ecode11)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12330 }
12331 arg11 = (PLINT)(val11);
12332 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12333 if (!SWIG_IsOK(ecode12)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12335 }
12336 arg12 = (PLFLT)(val12);
12337 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12338 if (!SWIG_IsOK(ecode13)) {
12339 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12340 }
12341 arg13 = (PLFLT)(val13);
12342 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12343 if (!SWIG_IsOK(ecode14)) {
12344 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12345 }
12346 arg14 = (PLINT)(val14);
12347 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12348 if (!SWIG_IsOK(ecode15)) {
12349 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12350 }
12351 arg15 = (PLFLT)(val15);
12352 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12353 if (!SWIG_IsOK(ecode16)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12355 }
12356 arg16 = (PLINT)(val16);
12357 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12358 if (!SWIG_IsOK(ecode17)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12360 }
12361 arg17 = (PLFLT)(val17);
12362 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12363 if (!SWIG_IsOK(ecode19)) {
12364 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12365 }
12366 arg19 = (PLBOOL)(val19);
12367 if (swig_obj[15]) {
12368 {
12369 // it must be a callable or None
12370 if ( swig_obj[15] == Py_None )
12371 {
12372 arg20 = NULL;
12373 }
12374 else
12375 {
12376 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12377 {
12378 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12379 return NULL;
12380 }
12381 arg20 = marshal_pltr( swig_obj[15] );
12382 }
12383 }
12384 }
12385 if (swig_obj[16]) {
12386 {
12387 if ( swig_obj[16] == Py_None )
12388 arg21 = NULL;
12389 else
12390 {
12391 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12392 }
12393 }
12394 }
12395 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12396 resultobj = SWIG_Py_Void();
12397 {
12398 Py_CLEAR( tmp1 );
12399 free( arg1 );
12400 }
12401 {
12402 cleanup_pltr();
12403 }
12404 {
12406 }
12407 return resultobj;
12408fail:
12409 {
12410 Py_CLEAR( tmp1 );
12411 free( arg1 );
12412 }
12413 {
12414 cleanup_pltr();
12415 }
12416 {
12418 }
12419 return NULL;
12420}
12421
12422
12423SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12424 PyObject *resultobj = 0;
12425 label_func arg1 = (label_func) 0 ;
12426 PLPointer arg2 = (PLPointer) 0 ;
12427 int res2 ;
12428 PyObject *swig_obj[2] ;
12429
12430 (void)self;
12431 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12432 {
12433 // Release reference to previous function if applicable
12434 if ( python_label )
12435 {
12436 Py_CLEAR( python_label );
12437 python_label = 0;
12438 }
12439 // it must be a callable or None
12440 if ( swig_obj[0] == Py_None )
12441 {
12442 arg1 = NULL;
12443 }
12444 else
12445 {
12446 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12447 {
12448 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12449 return NULL;
12450 }
12451 // hold a reference to it
12452 Py_XINCREF( (PyObject *) swig_obj[0] );
12453 python_label = (PyObject *) swig_obj[0];
12454 // this function handles calling the python function
12455 arg1 = do_label_callback;
12456 }
12457 }
12458 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12459 if (!SWIG_IsOK(res2)) {
12460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12461 }
12462 plslabelfunc(arg1,arg2);
12463 resultobj = SWIG_Py_Void();
12464 return resultobj;
12465fail:
12466 return NULL;
12467}
12468
12469
12470SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12471 PyObject *resultobj = 0;
12472 PLFLT arg1 ;
12473 PLFLT arg2 ;
12474 double val1 ;
12475 int ecode1 = 0 ;
12476 double val2 ;
12477 int ecode2 = 0 ;
12478 PyObject *swig_obj[2] ;
12479
12480 (void)self;
12481 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12482 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12483 if (!SWIG_IsOK(ecode1)) {
12484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12485 }
12486 arg1 = (PLFLT)(val1);
12487 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12488 if (!SWIG_IsOK(ecode2)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12490 }
12491 arg2 = (PLFLT)(val2);
12492 plsmaj(arg1,arg2);
12493 resultobj = SWIG_Py_Void();
12494 return resultobj;
12495fail:
12496 return NULL;
12497}
12498
12499
12500SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12501 PyObject *resultobj = 0;
12502 PLINT arg1 ;
12503 PLINT arg2 ;
12504 void *arg3 = (void *) 0 ;
12505 int val1 ;
12506 int ecode1 = 0 ;
12507 int val2 ;
12508 int ecode2 = 0 ;
12509 PyObject *swig_obj[3] ;
12510
12511 (void)self;
12512 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12513 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12514 if (!SWIG_IsOK(ecode1)) {
12515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12516 }
12517 arg1 = (PLINT)(val1);
12518 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12519 if (!SWIG_IsOK(ecode2)) {
12520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12521 }
12522 arg2 = (PLINT)(val2);
12523 {
12524 int res; void *buf = 0;
12525#ifndef Py_LIMITED_API
12526 Py_buffer view;
12527 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12528#else
12529#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12530#pragma GCC diagnostic push
12531#pragma GCC diagnostic ignored "-Wdeprecated"
12532#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12533#elif defined(_MSC_VER)
12534#pragma warning(push)
12535#pragma warning(disable: 4996)
12536#endif
12537 Py_ssize_t size;
12538 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12539#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12540#pragma GCC diagnostic pop
12541#elif defined(_MSC_VER)
12542#pragma warning(pop)
12543#endif
12544#endif
12545 if (res < 0) {
12546 PyErr_Clear();
12547 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12548 }
12549#ifndef Py_LIMITED_API
12550 buf = view.buf;
12551 PyBuffer_Release(&view);
12552#endif
12553 arg3 = (void *) buf;
12554 }
12555 plsmem(arg1,arg2,arg3);
12556 resultobj = SWIG_Py_Void();
12557 return resultobj;
12558fail:
12559 return NULL;
12560}
12561
12562
12563SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12564 PyObject *resultobj = 0;
12565 PLINT arg1 ;
12566 PLINT arg2 ;
12567 void *arg3 = (void *) 0 ;
12568 int val1 ;
12569 int ecode1 = 0 ;
12570 int val2 ;
12571 int ecode2 = 0 ;
12572 PyObject *swig_obj[3] ;
12573
12574 (void)self;
12575 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12576 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12577 if (!SWIG_IsOK(ecode1)) {
12578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12579 }
12580 arg1 = (PLINT)(val1);
12581 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12582 if (!SWIG_IsOK(ecode2)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12584 }
12585 arg2 = (PLINT)(val2);
12586 {
12587 int res; void *buf = 0;
12588#ifndef Py_LIMITED_API
12589 Py_buffer view;
12590 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12591#else
12592#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12593#pragma GCC diagnostic push
12594#pragma GCC diagnostic ignored "-Wdeprecated"
12595#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12596#elif defined(_MSC_VER)
12597#pragma warning(push)
12598#pragma warning(disable: 4996)
12599#endif
12600 Py_ssize_t size;
12601 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12602#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12603#pragma GCC diagnostic pop
12604#elif defined(_MSC_VER)
12605#pragma warning(pop)
12606#endif
12607#endif
12608 if (res < 0) {
12609 PyErr_Clear();
12610 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12611 }
12612#ifndef Py_LIMITED_API
12613 buf = view.buf;
12614 PyBuffer_Release(&view);
12615#endif
12616 arg3 = (void *) buf;
12617 }
12618 plsmema(arg1,arg2,arg3);
12619 resultobj = SWIG_Py_Void();
12620 return resultobj;
12621fail:
12622 return NULL;
12623}
12624
12625
12626SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12627 PyObject *resultobj = 0;
12628 PLFLT arg1 ;
12629 PLFLT arg2 ;
12630 double val1 ;
12631 int ecode1 = 0 ;
12632 double val2 ;
12633 int ecode2 = 0 ;
12634 PyObject *swig_obj[2] ;
12635
12636 (void)self;
12637 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12638 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12639 if (!SWIG_IsOK(ecode1)) {
12640 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12641 }
12642 arg1 = (PLFLT)(val1);
12643 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12644 if (!SWIG_IsOK(ecode2)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12646 }
12647 arg2 = (PLFLT)(val2);
12648 plsmin(arg1,arg2);
12649 resultobj = SWIG_Py_Void();
12650 return resultobj;
12651fail:
12652 return NULL;
12653}
12654
12655
12656SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12657 PyObject *resultobj = 0;
12658 PLINT arg1 ;
12659 int val1 ;
12660 int ecode1 = 0 ;
12661 PyObject *swig_obj[1] ;
12662
12663 (void)self;
12664 if (!args) SWIG_fail;
12665 swig_obj[0] = args;
12666 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12667 if (!SWIG_IsOK(ecode1)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12669 }
12670 arg1 = (PLINT)(val1);
12671 plsori(arg1);
12672 resultobj = SWIG_Py_Void();
12673 return resultobj;
12674fail:
12675 return NULL;
12676}
12677
12678
12679SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12680 PyObject *resultobj = 0;
12681 PLFLT arg1 ;
12682 PLFLT arg2 ;
12683 PLINT arg3 ;
12684 PLINT arg4 ;
12685 PLINT arg5 ;
12686 PLINT arg6 ;
12687 double val1 ;
12688 int ecode1 = 0 ;
12689 double val2 ;
12690 int ecode2 = 0 ;
12691 int val3 ;
12692 int ecode3 = 0 ;
12693 int val4 ;
12694 int ecode4 = 0 ;
12695 int val5 ;
12696 int ecode5 = 0 ;
12697 int val6 ;
12698 int ecode6 = 0 ;
12699 PyObject *swig_obj[6] ;
12700
12701 (void)self;
12702 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12703 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12704 if (!SWIG_IsOK(ecode1)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12706 }
12707 arg1 = (PLFLT)(val1);
12708 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12709 if (!SWIG_IsOK(ecode2)) {
12710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12711 }
12712 arg2 = (PLFLT)(val2);
12713 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12714 if (!SWIG_IsOK(ecode3)) {
12715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12716 }
12717 arg3 = (PLINT)(val3);
12718 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12719 if (!SWIG_IsOK(ecode4)) {
12720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12721 }
12722 arg4 = (PLINT)(val4);
12723 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12724 if (!SWIG_IsOK(ecode5)) {
12725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12726 }
12727 arg5 = (PLINT)(val5);
12728 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12729 if (!SWIG_IsOK(ecode6)) {
12730 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12731 }
12732 arg6 = (PLINT)(val6);
12733 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12734 resultobj = SWIG_Py_Void();
12735 return resultobj;
12736fail:
12737 return NULL;
12738}
12739
12740
12741SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12742 PyObject *resultobj = 0;
12743 char *arg1 = (char *) 0 ;
12744 int res1 ;
12745 char *buf1 = 0 ;
12746 int alloc1 = 0 ;
12747 PyObject *swig_obj[1] ;
12748
12749 (void)self;
12750 if (!args) SWIG_fail;
12751 swig_obj[0] = args;
12752 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12755 }
12756 arg1 = (char *)(buf1);
12757 plspal0((char const *)arg1);
12758 resultobj = SWIG_Py_Void();
12759 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12760 return resultobj;
12761fail:
12762 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12763 return NULL;
12764}
12765
12766
12767SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12768 PyObject *resultobj = 0;
12769 char *arg1 = (char *) 0 ;
12770 PLBOOL arg2 ;
12771 int res1 ;
12772 char *buf1 = 0 ;
12773 int alloc1 = 0 ;
12774 int val2 ;
12775 int ecode2 = 0 ;
12776 PyObject *swig_obj[2] ;
12777
12778 (void)self;
12779 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12780 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12781 if (!SWIG_IsOK(res1)) {
12782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12783 }
12784 arg1 = (char *)(buf1);
12785 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12786 if (!SWIG_IsOK(ecode2)) {
12787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12788 }
12789 arg2 = (PLBOOL)(val2);
12790 plspal1((char const *)arg1,arg2);
12791 resultobj = SWIG_Py_Void();
12792 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12793 return resultobj;
12794fail:
12795 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12796 return NULL;
12797}
12798
12799
12800SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12801 PyObject *resultobj = 0;
12802 PLBOOL arg1 ;
12803 int val1 ;
12804 int ecode1 = 0 ;
12805 PyObject *swig_obj[1] ;
12806
12807 (void)self;
12808 if (!args) SWIG_fail;
12809 swig_obj[0] = args;
12810 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12811 if (!SWIG_IsOK(ecode1)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12813 }
12814 arg1 = (PLBOOL)(val1);
12815 plspause(arg1);
12816 resultobj = SWIG_Py_Void();
12817 return resultobj;
12818fail:
12819 return NULL;
12820}
12821
12822
12823SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12824 PyObject *resultobj = 0;
12825 PLINT arg1 ;
12826 int val1 ;
12827 int ecode1 = 0 ;
12828 PyObject *swig_obj[1] ;
12829
12830 (void)self;
12831 if (!args) SWIG_fail;
12832 swig_obj[0] = args;
12833 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12834 if (!SWIG_IsOK(ecode1)) {
12835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12836 }
12837 arg1 = (PLINT)(val1);
12838 plsstrm(arg1);
12839 resultobj = SWIG_Py_Void();
12840 return resultobj;
12841fail:
12842 return NULL;
12843}
12844
12845
12846SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12847 PyObject *resultobj = 0;
12848 PLINT arg1 ;
12849 PLINT arg2 ;
12850 int val1 ;
12851 int ecode1 = 0 ;
12852 int val2 ;
12853 int ecode2 = 0 ;
12854 PyObject *swig_obj[2] ;
12855
12856 (void)self;
12857 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12858 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12859 if (!SWIG_IsOK(ecode1)) {
12860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12861 }
12862 arg1 = (PLINT)(val1);
12863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12864 if (!SWIG_IsOK(ecode2)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12866 }
12867 arg2 = (PLINT)(val2);
12868 plssub(arg1,arg2);
12869 resultobj = SWIG_Py_Void();
12870 return resultobj;
12871fail:
12872 return NULL;
12873}
12874
12875
12876SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12877 PyObject *resultobj = 0;
12878 PLFLT arg1 ;
12879 PLFLT arg2 ;
12880 double val1 ;
12881 int ecode1 = 0 ;
12882 double val2 ;
12883 int ecode2 = 0 ;
12884 PyObject *swig_obj[2] ;
12885
12886 (void)self;
12887 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12888 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12889 if (!SWIG_IsOK(ecode1)) {
12890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12891 }
12892 arg1 = (PLFLT)(val1);
12893 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12894 if (!SWIG_IsOK(ecode2)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12896 }
12897 arg2 = (PLFLT)(val2);
12898 plssym(arg1,arg2);
12899 resultobj = SWIG_Py_Void();
12900 return resultobj;
12901fail:
12902 return NULL;
12903}
12904
12905
12906SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12907 PyObject *resultobj = 0;
12908 PLINT arg1 ;
12909 PLINT arg2 ;
12910 int val1 ;
12911 int ecode1 = 0 ;
12912 int val2 ;
12913 int ecode2 = 0 ;
12914 PyObject *swig_obj[2] ;
12915
12916 (void)self;
12917 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12918 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12919 if (!SWIG_IsOK(ecode1)) {
12920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12921 }
12922 arg1 = (PLINT)(val1);
12923 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12924 if (!SWIG_IsOK(ecode2)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12926 }
12927 arg2 = (PLINT)(val2);
12928 plstar(arg1,arg2);
12929 resultobj = SWIG_Py_Void();
12930 return resultobj;
12931fail:
12932 return NULL;
12933}
12934
12935
12936SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12937 PyObject *resultobj = 0;
12938 char *arg1 = (char *) 0 ;
12939 PLINT arg2 ;
12940 PLINT arg3 ;
12941 int res1 ;
12942 char *buf1 = 0 ;
12943 int alloc1 = 0 ;
12944 int val2 ;
12945 int ecode2 = 0 ;
12946 int val3 ;
12947 int ecode3 = 0 ;
12948 PyObject *swig_obj[3] ;
12949
12950 (void)self;
12951 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12952 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12955 }
12956 arg1 = (char *)(buf1);
12957 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12958 if (!SWIG_IsOK(ecode2)) {
12959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12960 }
12961 arg2 = (PLINT)(val2);
12962 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12963 if (!SWIG_IsOK(ecode3)) {
12964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12965 }
12966 arg3 = (PLINT)(val3);
12967 plstart((char const *)arg1,arg2,arg3);
12968 resultobj = SWIG_Py_Void();
12969 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12970 return resultobj;
12971fail:
12972 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12973 return NULL;
12974}
12975
12976
12977SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12978 PyObject *resultobj = 0;
12979 ct_func arg1 = (ct_func) 0 ;
12980 PLPointer arg2 = (PLPointer) 0 ;
12981 int res2 ;
12982 PyObject *swig_obj[2] ;
12983
12984 {
12985 python_ct = 0;
12986 arg1 = NULL;
12987 }
12988 (void)self;
12989 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12990 if (swig_obj[0]) {
12991 {
12992 if ( python_ct )
12993 cleanup_ct();
12994 // it must be a callable or none
12995 if ( swig_obj[0] == Py_None )
12996 {
12997 arg1 = NULL;
12998 }
12999 else
13000 {
13001 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13002 {
13003 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
13004 return NULL;
13005 }
13006 arg1 = marshal_ct( swig_obj[0] );
13007 }
13008 }
13009 }
13010 if (swig_obj[1]) {
13011 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
13012 if (!SWIG_IsOK(res2)) {
13013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
13014 }
13015 }
13016 plstransform(arg1,arg2);
13017 resultobj = SWIG_Py_Void();
13018 return resultobj;
13019fail:
13020 return NULL;
13021}
13022
13023
13024SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
13025 PyObject *resultobj = 0;
13026 PLINT arg1 ;
13027 PLFLT *arg2 = (PLFLT *) 0 ;
13028 PLFLT *arg3 = (PLFLT *) 0 ;
13029 char *arg4 = (char *) 0 ;
13030 PyArrayObject *tmp1 = NULL ;
13031 PyArrayObject *tmp3 = NULL ;
13032 int res4 ;
13033 char *buf4 = 0 ;
13034 int alloc4 = 0 ;
13035 PyObject *swig_obj[3] ;
13036
13037 (void)self;
13038 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13039 {
13040 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13041 if ( tmp1 == NULL )
13042 return NULL;
13043 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13044 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13045 }
13046 {
13047 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13048 if ( tmp3 == NULL )
13049 return NULL;
13050 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13051 {
13052 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13053 return NULL;
13054 }
13055 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13056 }
13057 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13058 if (!SWIG_IsOK(res4)) {
13059 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13060 }
13061 arg4 = (char *)(buf4);
13062 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13063 resultobj = SWIG_Py_Void();
13064 {
13065 Py_CLEAR( tmp1 );
13066 }
13067 {
13068 Py_CLEAR( tmp3 );
13069 }
13070 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13071 return resultobj;
13072fail:
13073 {
13074 Py_CLEAR( tmp1 );
13075 }
13076 {
13077 Py_CLEAR( tmp3 );
13078 }
13079 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13080 return NULL;
13081}
13082
13083
13084SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13085 PyObject *resultobj = 0;
13086 PLINT arg1 ;
13087 PLFLT *arg2 = (PLFLT *) 0 ;
13088 PLFLT *arg3 = (PLFLT *) 0 ;
13089 PLFLT *arg4 = (PLFLT *) 0 ;
13090 char *arg5 = (char *) 0 ;
13091 PyArrayObject *tmp1 = NULL ;
13092 PyArrayObject *tmp3 = NULL ;
13093 PyArrayObject *tmp4 = NULL ;
13094 int res5 ;
13095 char *buf5 = 0 ;
13096 int alloc5 = 0 ;
13097 PyObject *swig_obj[4] ;
13098
13099 (void)self;
13100 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13101 {
13102 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13103 if ( tmp1 == NULL )
13104 return NULL;
13105 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13106 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13107 }
13108 {
13109 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13110 if ( tmp3 == NULL )
13111 return NULL;
13112 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13113 {
13114 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13115 return NULL;
13116 }
13117 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13118 }
13119 {
13120 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13121 if ( tmp4 == NULL )
13122 return NULL;
13123 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13124 {
13125 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13126 return NULL;
13127 }
13128 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13129 }
13130 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13131 if (!SWIG_IsOK(res5)) {
13132 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13133 }
13134 arg5 = (char *)(buf5);
13135 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13136 resultobj = SWIG_Py_Void();
13137 {
13138 Py_CLEAR( tmp1 );
13139 }
13140 {
13141 Py_CLEAR( tmp3 );
13142 }
13143 {
13144 Py_CLEAR( tmp4 );
13145 }
13146 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13147 return resultobj;
13148fail:
13149 {
13150 Py_CLEAR( tmp1 );
13151 }
13152 {
13153 Py_CLEAR( tmp3 );
13154 }
13155 {
13156 Py_CLEAR( tmp4 );
13157 }
13158 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13159 return NULL;
13160}
13161
13162
13163SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13164 PyObject *resultobj = 0;
13165 PLINT arg1 ;
13166 PLINT arg2 ;
13167 PLFLT arg3 ;
13168 PLFLT arg4 ;
13169 int val1 ;
13170 int ecode1 = 0 ;
13171 int val2 ;
13172 int ecode2 = 0 ;
13173 double val3 ;
13174 int ecode3 = 0 ;
13175 double val4 ;
13176 int ecode4 = 0 ;
13177 PyObject *swig_obj[4] ;
13178
13179 (void)self;
13180 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13181 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13182 if (!SWIG_IsOK(ecode1)) {
13183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13184 }
13185 arg1 = (PLINT)(val1);
13186 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13187 if (!SWIG_IsOK(ecode2)) {
13188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13189 }
13190 arg2 = (PLINT)(val2);
13191 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13192 if (!SWIG_IsOK(ecode3)) {
13193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13194 }
13195 arg3 = (PLFLT)(val3);
13196 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13197 if (!SWIG_IsOK(ecode4)) {
13198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13199 }
13200 arg4 = (PLFLT)(val4);
13201 plstripa(arg1,arg2,arg3,arg4);
13202 resultobj = SWIG_Py_Void();
13203 return resultobj;
13204fail:
13205 return NULL;
13206}
13207
13208
13209SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13210 PyObject *resultobj = 0;
13211 PLINT *arg1 = (PLINT *) 0 ;
13212 char *arg2 = (char *) 0 ;
13213 char *arg3 = (char *) 0 ;
13214 PLFLT arg4 ;
13215 PLFLT arg5 ;
13216 PLFLT arg6 ;
13217 PLFLT arg7 ;
13218 PLFLT arg8 ;
13219 PLFLT arg9 ;
13220 PLFLT arg10 ;
13221 PLBOOL arg11 ;
13222 PLBOOL arg12 ;
13223 PLINT arg13 ;
13224 PLINT arg14 ;
13225 PLINT *arg15 = (PLINT *) 0 ;
13226 PLINT *arg16 = (PLINT *) 0 ;
13227 char **arg17 = (char **) (char **)0 ;
13228 char *arg18 = (char *) 0 ;
13229 char *arg19 = (char *) 0 ;
13230 char *arg20 = (char *) 0 ;
13231 PLINT temp1 ;
13232 int res1 = SWIG_TMPOBJ ;
13233 int res2 ;
13234 char *buf2 = 0 ;
13235 int alloc2 = 0 ;
13236 int res3 ;
13237 char *buf3 = 0 ;
13238 int alloc3 = 0 ;
13239 double val4 ;
13240 int ecode4 = 0 ;
13241 double val5 ;
13242 int ecode5 = 0 ;
13243 double val6 ;
13244 int ecode6 = 0 ;
13245 double val7 ;
13246 int ecode7 = 0 ;
13247 double val8 ;
13248 int ecode8 = 0 ;
13249 double val9 ;
13250 int ecode9 = 0 ;
13251 double val10 ;
13252 int ecode10 = 0 ;
13253 int val11 ;
13254 int ecode11 = 0 ;
13255 int val12 ;
13256 int ecode12 = 0 ;
13257 int val13 ;
13258 int ecode13 = 0 ;
13259 int val14 ;
13260 int ecode14 = 0 ;
13261 PyArrayObject *tmp15 = NULL ;
13262 PyArrayObject *tmp16 = NULL ;
13263 char **tmp17 = NULL ;
13264 int res18 ;
13265 char *buf18 = 0 ;
13266 int alloc18 = 0 ;
13267 int res19 ;
13268 char *buf19 = 0 ;
13269 int alloc19 = 0 ;
13270 int res20 ;
13271 char *buf20 = 0 ;
13272 int alloc20 = 0 ;
13273 PyObject *swig_obj[19] ;
13274
13275 arg1 = &temp1;
13276 (void)self;
13277 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13278 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13279 if (!SWIG_IsOK(res2)) {
13280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13281 }
13282 arg2 = (char *)(buf2);
13283 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13284 if (!SWIG_IsOK(res3)) {
13285 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13286 }
13287 arg3 = (char *)(buf3);
13288 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13289 if (!SWIG_IsOK(ecode4)) {
13290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13291 }
13292 arg4 = (PLFLT)(val4);
13293 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13294 if (!SWIG_IsOK(ecode5)) {
13295 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13296 }
13297 arg5 = (PLFLT)(val5);
13298 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13299 if (!SWIG_IsOK(ecode6)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13301 }
13302 arg6 = (PLFLT)(val6);
13303 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13304 if (!SWIG_IsOK(ecode7)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13306 }
13307 arg7 = (PLFLT)(val7);
13308 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13309 if (!SWIG_IsOK(ecode8)) {
13310 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13311 }
13312 arg8 = (PLFLT)(val8);
13313 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13314 if (!SWIG_IsOK(ecode9)) {
13315 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13316 }
13317 arg9 = (PLFLT)(val9);
13318 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13319 if (!SWIG_IsOK(ecode10)) {
13320 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13321 }
13322 arg10 = (PLFLT)(val10);
13323 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13324 if (!SWIG_IsOK(ecode11)) {
13325 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13326 }
13327 arg11 = (PLBOOL)(val11);
13328 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13329 if (!SWIG_IsOK(ecode12)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13331 }
13332 arg12 = (PLBOOL)(val12);
13333 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13334 if (!SWIG_IsOK(ecode13)) {
13335 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13336 }
13337 arg13 = (PLINT)(val13);
13338 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13339 if (!SWIG_IsOK(ecode14)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13341 }
13342 arg14 = (PLINT)(val14);
13343 {
13344 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13345 if ( tmp15 == NULL )
13346 return NULL;
13347 Alen = PyArray_DIMS( tmp15 )[0];
13348 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13349 }
13350 {
13351 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13352 if ( tmp16 == NULL )
13353 return NULL;
13354 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13355 {
13356 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13357 return NULL;
13358 }
13359 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13360 }
13361 {
13362 int i;
13363 PyObject *elt, *unicode_string;
13364
13365 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13366 {
13367 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13368 return NULL;
13369 }
13370 if ( Alen != 4 )
13371 {
13372 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13373 return NULL;
13374 }
13375 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13376 if ( tmp17 == NULL )
13377 return NULL;
13378 arg17 = tmp17;
13379 for ( i = 0; i < 4; i++ )
13380 {
13381 arg17[i] = NULL;
13382 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13383 if ( PyString_Check( elt ) )
13384 {
13385 arg17[i] = PyString_AsString( elt );
13386 }
13387 else if ( PyUnicode_Check( elt ) )
13388 {
13389 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13390 arg17[i] = PyBytes_AS_STRING( unicode_string );
13391 }
13392 if ( arg17[i] == NULL )
13393 {
13394 free( tmp17 );
13395 return NULL;
13396 }
13397 }
13398 }
13399 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13400 if (!SWIG_IsOK(res18)) {
13401 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13402 }
13403 arg18 = (char *)(buf18);
13404 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13405 if (!SWIG_IsOK(res19)) {
13406 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13407 }
13408 arg19 = (char *)(buf19);
13409 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13410 if (!SWIG_IsOK(res20)) {
13411 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13412 }
13413 arg20 = (char *)(buf20);
13414 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);
13415 resultobj = SWIG_Py_Void();
13416 if (SWIG_IsTmpObj(res1)) {
13417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
13418 } else {
13419 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
13421 }
13422 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13423 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13424 {
13425 Py_CLEAR( tmp15 );
13426 }
13427 {
13428 Py_CLEAR( tmp16 );
13429 }
13430 {
13431 free( tmp17 );
13432 }
13433 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13434 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13435 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13436 return resultobj;
13437fail:
13438 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13439 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13440 {
13441 Py_CLEAR( tmp15 );
13442 }
13443 {
13444 Py_CLEAR( tmp16 );
13445 }
13446 {
13447 free( tmp17 );
13448 }
13449 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13450 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13451 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13452 return NULL;
13453}
13454
13455
13456SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13457 PyObject *resultobj = 0;
13458 PLINT arg1 ;
13459 int val1 ;
13460 int ecode1 = 0 ;
13461 PyObject *swig_obj[1] ;
13462
13463 (void)self;
13464 if (!args) SWIG_fail;
13465 swig_obj[0] = args;
13466 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13467 if (!SWIG_IsOK(ecode1)) {
13468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13469 }
13470 arg1 = (PLINT)(val1);
13471 plstripd(arg1);
13472 resultobj = SWIG_Py_Void();
13473 return resultobj;
13474fail:
13475 return NULL;
13476}
13477
13478
13479SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13480 PyObject *resultobj = 0;
13481 PLINT arg1 ;
13482 PLINT *arg2 = (PLINT *) 0 ;
13483 PLINT *arg3 = (PLINT *) 0 ;
13484 PyArrayObject *tmp1 = NULL ;
13485 PyArrayObject *tmp3 = NULL ;
13486 PyObject *swig_obj[2] ;
13487
13488 (void)self;
13489 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13490 {
13491 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13492 if ( tmp1 == NULL )
13493 return NULL;
13494 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13495 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13496 }
13497 {
13498 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13499 if ( tmp3 == NULL )
13500 return NULL;
13501 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13502 {
13503 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13504 return NULL;
13505 }
13506 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13507 }
13508 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13509 resultobj = SWIG_Py_Void();
13510 {
13511 Py_CLEAR( tmp1 );
13512 }
13513 {
13514 Py_CLEAR( tmp3 );
13515 }
13516 return resultobj;
13517fail:
13518 {
13519 Py_CLEAR( tmp1 );
13520 }
13521 {
13522 Py_CLEAR( tmp3 );
13523 }
13524 return NULL;
13525}
13526
13527
13528SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13529 PyObject *resultobj = 0;
13530 PLFLT *arg1 = (PLFLT *) 0 ;
13531 PLFLT *arg2 = (PLFLT *) 0 ;
13532 PLINT arg3 ;
13533 PLBOOL arg4 ;
13534 PyArrayObject *tmp1 = NULL ;
13535 PyArrayObject *tmp2 = NULL ;
13536 int val4 ;
13537 int ecode4 = 0 ;
13538 PyObject *swig_obj[3] ;
13539
13540 (void)self;
13541 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13542 {
13543 if ( swig_obj[0] != Py_None )
13544 {
13545 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13546 if ( tmp1 == NULL )
13547 return NULL;
13548 Alen = PyArray_DIMS( tmp1 )[0];
13549 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13550 }
13551 else
13552 {
13553 arg1 = NULL;
13554 Alen = 0;
13555 }
13556 }
13557 {
13558 if ( swig_obj[1] != Py_None )
13559 {
13560 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13561 if ( tmp2 == NULL )
13562 return NULL;
13563 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13564 {
13565 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13566 return NULL;
13567 }
13568 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13569 arg3 = PyArray_DIMS( tmp2 )[0];
13570 }
13571 else
13572 {
13573 arg2 = NULL;
13574 arg3 = 0;
13575 }
13576 }
13577 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13578 if (!SWIG_IsOK(ecode4)) {
13579 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13580 }
13581 arg4 = (PLBOOL)(val4);
13582 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13583 resultobj = SWIG_Py_Void();
13584 {
13585 Py_CLEAR( tmp1 );
13586 }
13587 {
13588 Py_CLEAR( tmp2 );
13589 }
13590 return resultobj;
13591fail:
13592 {
13593 Py_CLEAR( tmp1 );
13594 }
13595 {
13596 Py_CLEAR( tmp2 );
13597 }
13598 return NULL;
13599}
13600
13601
13602SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13603 PyObject *resultobj = 0;
13604 PLFLT arg1 ;
13605 PLFLT arg2 ;
13606 PLFLT arg3 ;
13607 PLFLT arg4 ;
13608 double val1 ;
13609 int ecode1 = 0 ;
13610 double val2 ;
13611 int ecode2 = 0 ;
13612 double val3 ;
13613 int ecode3 = 0 ;
13614 double val4 ;
13615 int ecode4 = 0 ;
13616 PyObject *swig_obj[4] ;
13617
13618 (void)self;
13619 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13620 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13621 if (!SWIG_IsOK(ecode1)) {
13622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13623 }
13624 arg1 = (PLFLT)(val1);
13625 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13626 if (!SWIG_IsOK(ecode2)) {
13627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13628 }
13629 arg2 = (PLFLT)(val2);
13630 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13631 if (!SWIG_IsOK(ecode3)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13633 }
13634 arg3 = (PLFLT)(val3);
13635 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13636 if (!SWIG_IsOK(ecode4)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13638 }
13639 arg4 = (PLFLT)(val4);
13640 plsvpa(arg1,arg2,arg3,arg4);
13641 resultobj = SWIG_Py_Void();
13642 return resultobj;
13643fail:
13644 return NULL;
13645}
13646
13647
13648SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13649 PyObject *resultobj = 0;
13650 PLINT arg1 ;
13651 PLINT arg2 ;
13652 int val1 ;
13653 int ecode1 = 0 ;
13654 int val2 ;
13655 int ecode2 = 0 ;
13656 PyObject *swig_obj[2] ;
13657
13658 (void)self;
13659 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13660 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13661 if (!SWIG_IsOK(ecode1)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13663 }
13664 arg1 = (PLINT)(val1);
13665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13666 if (!SWIG_IsOK(ecode2)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13668 }
13669 arg2 = (PLINT)(val2);
13670 plsxax(arg1,arg2);
13671 resultobj = SWIG_Py_Void();
13672 return resultobj;
13673fail:
13674 return NULL;
13675}
13676
13677
13678SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13679 PyObject *resultobj = 0;
13680 PLINT arg1 ;
13681 PLINT arg2 ;
13682 int val1 ;
13683 int ecode1 = 0 ;
13684 int val2 ;
13685 int ecode2 = 0 ;
13686 PyObject *swig_obj[2] ;
13687
13688 (void)self;
13689 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13690 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13691 if (!SWIG_IsOK(ecode1)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13693 }
13694 arg1 = (PLINT)(val1);
13695 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13696 if (!SWIG_IsOK(ecode2)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13698 }
13699 arg2 = (PLINT)(val2);
13700 plsyax(arg1,arg2);
13701 resultobj = SWIG_Py_Void();
13702 return resultobj;
13703fail:
13704 return NULL;
13705}
13706
13707
13708SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13709 PyObject *resultobj = 0;
13710 PLINT arg1 ;
13711 PLFLT *arg2 = (PLFLT *) 0 ;
13712 PLFLT *arg3 = (PLFLT *) 0 ;
13713 PLINT arg4 ;
13714 PyArrayObject *tmp1 = NULL ;
13715 PyArrayObject *tmp3 = NULL ;
13716 int val4 ;
13717 int ecode4 = 0 ;
13718 PyObject *swig_obj[3] ;
13719
13720 (void)self;
13721 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13722 {
13723 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13724 if ( tmp1 == NULL )
13725 return NULL;
13726 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13727 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13728 }
13729 {
13730 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13731 if ( tmp3 == NULL )
13732 return NULL;
13733 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13734 {
13735 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13736 return NULL;
13737 }
13738 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13739 }
13740 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13741 if (!SWIG_IsOK(ecode4)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13743 }
13744 arg4 = (PLINT)(val4);
13745 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13746 resultobj = SWIG_Py_Void();
13747 {
13748 Py_CLEAR( tmp1 );
13749 }
13750 {
13751 Py_CLEAR( tmp3 );
13752 }
13753 return resultobj;
13754fail:
13755 {
13756 Py_CLEAR( tmp1 );
13757 }
13758 {
13759 Py_CLEAR( tmp3 );
13760 }
13761 return NULL;
13762}
13763
13764
13765SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13766 PyObject *resultobj = 0;
13767 PLINT arg1 ;
13768 PLINT arg2 ;
13769 int val1 ;
13770 int ecode1 = 0 ;
13771 int val2 ;
13772 int ecode2 = 0 ;
13773 PyObject *swig_obj[2] ;
13774
13775 (void)self;
13776 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13777 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13778 if (!SWIG_IsOK(ecode1)) {
13779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13780 }
13781 arg1 = (PLINT)(val1);
13782 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13783 if (!SWIG_IsOK(ecode2)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13785 }
13786 arg2 = (PLINT)(val2);
13787 plszax(arg1,arg2);
13788 resultobj = SWIG_Py_Void();
13789 return resultobj;
13790fail:
13791 return NULL;
13792}
13793
13794
13795SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13796 PyObject *resultobj = 0;
13797
13798 (void)self;
13799 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13800 pltext();
13801 resultobj = SWIG_Py_Void();
13802 return resultobj;
13803fail:
13804 return NULL;
13805}
13806
13807
13808SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13809 PyObject *resultobj = 0;
13810 char *arg1 = (char *) 0 ;
13811 int res1 ;
13812 char *buf1 = 0 ;
13813 int alloc1 = 0 ;
13814 PyObject *swig_obj[1] ;
13815
13816 (void)self;
13817 if (!args) SWIG_fail;
13818 swig_obj[0] = args;
13819 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13820 if (!SWIG_IsOK(res1)) {
13821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13822 }
13823 arg1 = (char *)(buf1);
13824 pltimefmt((char const *)arg1);
13825 resultobj = SWIG_Py_Void();
13826 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13827 return resultobj;
13828fail:
13829 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13830 return NULL;
13831}
13832
13833
13834SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13835 PyObject *resultobj = 0;
13836 PLFLT arg1 ;
13837 double val1 ;
13838 int ecode1 = 0 ;
13839 PyObject *swig_obj[1] ;
13840
13841 (void)self;
13842 if (!args) SWIG_fail;
13843 swig_obj[0] = args;
13844 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13845 if (!SWIG_IsOK(ecode1)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13847 }
13848 arg1 = (PLFLT)(val1);
13849 plvasp(arg1);
13850 resultobj = SWIG_Py_Void();
13851 return resultobj;
13852fail:
13853 return NULL;
13854}
13855
13856
13857SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13858 PyObject *resultobj = 0;
13859 PLFLT **arg1 = (PLFLT **) 0 ;
13860 PLFLT **arg2 = (PLFLT **) 0 ;
13861 PLINT arg3 ;
13862 PLINT arg4 ;
13863 PLFLT arg5 ;
13864 pltr_func arg6 = (pltr_func) 0 ;
13865 PLPointer arg7 = (PLPointer) 0 ;
13866 PyArrayObject *tmp1 = NULL ;
13867 PyArrayObject *tmp2 = NULL ;
13868 double val5 ;
13869 int ecode5 = 0 ;
13870 PyObject *swig_obj[5] ;
13871
13872 {
13873 python_pltr = 0;
13874 arg6 = NULL;
13875 }
13876 {
13877 arg7 = NULL;
13878 }
13879 (void)self;
13880 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13881 {
13882 int i, size;
13883 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13884 if ( tmp1 == NULL )
13885 return NULL;
13886 Xlen = PyArray_DIMS( tmp1 )[0];
13887 Ylen = PyArray_DIMS( tmp1 )[1];
13888 size = Ylen;
13889 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13890 for ( i = 0; i < Xlen; i++ )
13891 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13892 }
13893 {
13894 int i, size;
13895 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13896 if ( tmp2 == NULL )
13897 return NULL;
13898 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13899 {
13900 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13901 return NULL;
13902 }
13903 arg3 = PyArray_DIMS( tmp2 )[0];
13904 arg4 = PyArray_DIMS( tmp2 )[1];
13905 size = arg4;
13906 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13907 for ( i = 0; i < arg3; i++ )
13908 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13909 }
13910 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13911 if (!SWIG_IsOK(ecode5)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13913 }
13914 arg5 = (PLFLT)(val5);
13915 if (swig_obj[3]) {
13916 {
13917 // it must be a callable or None
13918 if ( swig_obj[3] == Py_None )
13919 {
13920 arg6 = NULL;
13921 }
13922 else
13923 {
13924 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13925 {
13926 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13927 return NULL;
13928 }
13929 arg6 = marshal_pltr( swig_obj[3] );
13930 }
13931 }
13932 }
13933 if (swig_obj[4]) {
13934 {
13935 if ( swig_obj[4] == Py_None )
13936 arg7 = NULL;
13937 else
13938 {
13939 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13940 }
13941 }
13942 }
13943 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13944 resultobj = SWIG_Py_Void();
13945 {
13946 Py_CLEAR( tmp1 );
13947 free( arg1 );
13948 }
13949 {
13950 Py_CLEAR( tmp2 );
13951 free( arg2 );
13952 }
13953 {
13954 cleanup_pltr();
13955 }
13956 {
13958 }
13959 return resultobj;
13960fail:
13961 {
13962 Py_CLEAR( tmp1 );
13963 free( arg1 );
13964 }
13965 {
13966 Py_CLEAR( tmp2 );
13967 free( arg2 );
13968 }
13969 {
13970 cleanup_pltr();
13971 }
13972 {
13974 }
13975 return NULL;
13976}
13977
13978
13979SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13980 PyObject *resultobj = 0;
13981 PLFLT arg1 ;
13982 PLFLT arg2 ;
13983 PLFLT arg3 ;
13984 PLFLT arg4 ;
13985 PLFLT arg5 ;
13986 double val1 ;
13987 int ecode1 = 0 ;
13988 double val2 ;
13989 int ecode2 = 0 ;
13990 double val3 ;
13991 int ecode3 = 0 ;
13992 double val4 ;
13993 int ecode4 = 0 ;
13994 double val5 ;
13995 int ecode5 = 0 ;
13996 PyObject *swig_obj[5] ;
13997
13998 (void)self;
13999 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
14000 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14001 if (!SWIG_IsOK(ecode1)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
14003 }
14004 arg1 = (PLFLT)(val1);
14005 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14006 if (!SWIG_IsOK(ecode2)) {
14007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
14008 }
14009 arg2 = (PLFLT)(val2);
14010 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14011 if (!SWIG_IsOK(ecode3)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
14013 }
14014 arg3 = (PLFLT)(val3);
14015 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14016 if (!SWIG_IsOK(ecode4)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
14018 }
14019 arg4 = (PLFLT)(val4);
14020 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14021 if (!SWIG_IsOK(ecode5)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
14023 }
14024 arg5 = (PLFLT)(val5);
14025 plvpas(arg1,arg2,arg3,arg4,arg5);
14026 resultobj = SWIG_Py_Void();
14027 return resultobj;
14028fail:
14029 return NULL;
14030}
14031
14032
14033SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
14034 PyObject *resultobj = 0;
14035 PLFLT arg1 ;
14036 PLFLT arg2 ;
14037 PLFLT arg3 ;
14038 PLFLT arg4 ;
14039 double val1 ;
14040 int ecode1 = 0 ;
14041 double val2 ;
14042 int ecode2 = 0 ;
14043 double val3 ;
14044 int ecode3 = 0 ;
14045 double val4 ;
14046 int ecode4 = 0 ;
14047 PyObject *swig_obj[4] ;
14048
14049 (void)self;
14050 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14051 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14052 if (!SWIG_IsOK(ecode1)) {
14053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14054 }
14055 arg1 = (PLFLT)(val1);
14056 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14057 if (!SWIG_IsOK(ecode2)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14059 }
14060 arg2 = (PLFLT)(val2);
14061 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14062 if (!SWIG_IsOK(ecode3)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14064 }
14065 arg3 = (PLFLT)(val3);
14066 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14067 if (!SWIG_IsOK(ecode4)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14069 }
14070 arg4 = (PLFLT)(val4);
14071 plvpor(arg1,arg2,arg3,arg4);
14072 resultobj = SWIG_Py_Void();
14073 return resultobj;
14074fail:
14075 return NULL;
14076}
14077
14078
14079SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14080 PyObject *resultobj = 0;
14081
14082 (void)self;
14083 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14084 plvsta();
14085 resultobj = SWIG_Py_Void();
14086 return resultobj;
14087fail:
14088 return NULL;
14089}
14090
14091
14092SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14093 PyObject *resultobj = 0;
14094 PLFLT arg1 ;
14095 PLFLT arg2 ;
14096 PLFLT arg3 ;
14097 PLFLT arg4 ;
14098 PLFLT arg5 ;
14099 PLFLT arg6 ;
14100 PLFLT arg7 ;
14101 PLFLT arg8 ;
14102 PLFLT arg9 ;
14103 PLFLT arg10 ;
14104 PLFLT arg11 ;
14105 double val1 ;
14106 int ecode1 = 0 ;
14107 double val2 ;
14108 int ecode2 = 0 ;
14109 double val3 ;
14110 int ecode3 = 0 ;
14111 double val4 ;
14112 int ecode4 = 0 ;
14113 double val5 ;
14114 int ecode5 = 0 ;
14115 double val6 ;
14116 int ecode6 = 0 ;
14117 double val7 ;
14118 int ecode7 = 0 ;
14119 double val8 ;
14120 int ecode8 = 0 ;
14121 double val9 ;
14122 int ecode9 = 0 ;
14123 double val10 ;
14124 int ecode10 = 0 ;
14125 double val11 ;
14126 int ecode11 = 0 ;
14127 PyObject *swig_obj[11] ;
14128
14129 (void)self;
14130 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14131 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14132 if (!SWIG_IsOK(ecode1)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14134 }
14135 arg1 = (PLFLT)(val1);
14136 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14137 if (!SWIG_IsOK(ecode2)) {
14138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14139 }
14140 arg2 = (PLFLT)(val2);
14141 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14142 if (!SWIG_IsOK(ecode3)) {
14143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14144 }
14145 arg3 = (PLFLT)(val3);
14146 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14147 if (!SWIG_IsOK(ecode4)) {
14148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14149 }
14150 arg4 = (PLFLT)(val4);
14151 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14152 if (!SWIG_IsOK(ecode5)) {
14153 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14154 }
14155 arg5 = (PLFLT)(val5);
14156 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14157 if (!SWIG_IsOK(ecode6)) {
14158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14159 }
14160 arg6 = (PLFLT)(val6);
14161 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14162 if (!SWIG_IsOK(ecode7)) {
14163 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14164 }
14165 arg7 = (PLFLT)(val7);
14166 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14167 if (!SWIG_IsOK(ecode8)) {
14168 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14169 }
14170 arg8 = (PLFLT)(val8);
14171 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14172 if (!SWIG_IsOK(ecode9)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14174 }
14175 arg9 = (PLFLT)(val9);
14176 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14177 if (!SWIG_IsOK(ecode10)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14179 }
14180 arg10 = (PLFLT)(val10);
14181 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14182 if (!SWIG_IsOK(ecode11)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14184 }
14185 arg11 = (PLFLT)(val11);
14186 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14187 resultobj = SWIG_Py_Void();
14188 return resultobj;
14189fail:
14190 return NULL;
14191}
14192
14193
14194SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14195 PyObject *resultobj = 0;
14196 PLFLT arg1 ;
14197 double val1 ;
14198 int ecode1 = 0 ;
14199 PyObject *swig_obj[1] ;
14200
14201 (void)self;
14202 if (!args) SWIG_fail;
14203 swig_obj[0] = args;
14204 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14205 if (!SWIG_IsOK(ecode1)) {
14206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14207 }
14208 arg1 = (PLFLT)(val1);
14209 plwidth(arg1);
14210 resultobj = SWIG_Py_Void();
14211 return resultobj;
14212fail:
14213 return NULL;
14214}
14215
14216
14217SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14218 PyObject *resultobj = 0;
14219 PLFLT arg1 ;
14220 PLFLT arg2 ;
14221 PLFLT arg3 ;
14222 PLFLT arg4 ;
14223 double val1 ;
14224 int ecode1 = 0 ;
14225 double val2 ;
14226 int ecode2 = 0 ;
14227 double val3 ;
14228 int ecode3 = 0 ;
14229 double val4 ;
14230 int ecode4 = 0 ;
14231 PyObject *swig_obj[4] ;
14232
14233 (void)self;
14234 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14235 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14236 if (!SWIG_IsOK(ecode1)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14238 }
14239 arg1 = (PLFLT)(val1);
14240 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14241 if (!SWIG_IsOK(ecode2)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14243 }
14244 arg2 = (PLFLT)(val2);
14245 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14246 if (!SWIG_IsOK(ecode3)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14248 }
14249 arg3 = (PLFLT)(val3);
14250 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14251 if (!SWIG_IsOK(ecode4)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14253 }
14254 arg4 = (PLFLT)(val4);
14255 plwind(arg1,arg2,arg3,arg4);
14256 resultobj = SWIG_Py_Void();
14257 return resultobj;
14258fail:
14259 return NULL;
14260}
14261
14262
14263SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14264 PyObject *resultobj = 0;
14265 PLBOOL arg1 ;
14266 PLBOOL *arg2 = (PLBOOL *) 0 ;
14267 int val1 ;
14268 int ecode1 = 0 ;
14269 PLBOOL temp2 ;
14270 int res2 = SWIG_TMPOBJ ;
14271 PyObject *swig_obj[1] ;
14272
14273 arg2 = &temp2;
14274 (void)self;
14275 if (!args) SWIG_fail;
14276 swig_obj[0] = args;
14277 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14278 if (!SWIG_IsOK(ecode1)) {
14279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14280 }
14281 arg1 = (PLBOOL)(val1);
14282 plxormod(arg1,arg2);
14283 resultobj = SWIG_Py_Void();
14284 if (SWIG_IsTmpObj(res2)) {
14285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
14286 } else {
14287 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
14289 }
14290 return resultobj;
14291fail:
14292 return NULL;
14293}
14294
14295
14296SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14297 PyObject *resultobj = 0;
14298 mapform_func arg1 = (mapform_func) 0 ;
14299 char *arg2 = (char *) 0 ;
14300 PLFLT arg3 ;
14301 PLFLT arg4 ;
14302 PLFLT arg5 ;
14303 PLFLT arg6 ;
14304 int res2 ;
14305 char *buf2 = 0 ;
14306 int alloc2 = 0 ;
14307 double val3 ;
14308 int ecode3 = 0 ;
14309 double val4 ;
14310 int ecode4 = 0 ;
14311 double val5 ;
14312 int ecode5 = 0 ;
14313 double val6 ;
14314 int ecode6 = 0 ;
14315 PyObject *swig_obj[6] ;
14316
14317 (void)self;
14318 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14319 {
14320 // it must be a callable or none
14321 if ( swig_obj[0] == Py_None )
14322 {
14323 arg1 = NULL;
14324 }
14325 else
14326 {
14327 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14328 {
14329 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14330 return NULL;
14331 }
14332 arg1 = marshal_mapform( swig_obj[0] );
14333 }
14334 }
14335 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14336 if (!SWIG_IsOK(res2)) {
14337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14338 }
14339 arg2 = (char *)(buf2);
14340 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14341 if (!SWIG_IsOK(ecode3)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14343 }
14344 arg3 = (PLFLT)(val3);
14345 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14346 if (!SWIG_IsOK(ecode4)) {
14347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14348 }
14349 arg4 = (PLFLT)(val4);
14350 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14351 if (!SWIG_IsOK(ecode5)) {
14352 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14353 }
14354 arg5 = (PLFLT)(val5);
14355 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14356 if (!SWIG_IsOK(ecode6)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14358 }
14359 arg6 = (PLFLT)(val6);
14360 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14361 resultobj = SWIG_Py_Void();
14362 {
14364 }
14365 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14366 return resultobj;
14367fail:
14368 {
14370 }
14371 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14372 return NULL;
14373}
14374
14375
14376SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14377 PyObject *resultobj = 0;
14378 mapform_func arg1 = (mapform_func) 0 ;
14379 char *arg2 = (char *) 0 ;
14380 PLFLT arg3 ;
14381 PLFLT arg4 ;
14382 PLFLT arg5 ;
14383 PLFLT arg6 ;
14384 PLINT *arg7 = (PLINT *) 0 ;
14385 PLINT arg8 ;
14386 int res2 ;
14387 char *buf2 = 0 ;
14388 int alloc2 = 0 ;
14389 double val3 ;
14390 int ecode3 = 0 ;
14391 double val4 ;
14392 int ecode4 = 0 ;
14393 double val5 ;
14394 int ecode5 = 0 ;
14395 double val6 ;
14396 int ecode6 = 0 ;
14397 PyArrayObject *tmp7 = NULL ;
14398 PyObject *swig_obj[7] ;
14399
14400 (void)self;
14401 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14402 {
14403 // it must be a callable or none
14404 if ( swig_obj[0] == Py_None )
14405 {
14406 arg1 = NULL;
14407 }
14408 else
14409 {
14410 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14411 {
14412 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14413 return NULL;
14414 }
14415 arg1 = marshal_mapform( swig_obj[0] );
14416 }
14417 }
14418 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14419 if (!SWIG_IsOK(res2)) {
14420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14421 }
14422 arg2 = (char *)(buf2);
14423 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14424 if (!SWIG_IsOK(ecode3)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14426 }
14427 arg3 = (PLFLT)(val3);
14428 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14429 if (!SWIG_IsOK(ecode4)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14431 }
14432 arg4 = (PLFLT)(val4);
14433 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14434 if (!SWIG_IsOK(ecode5)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14436 }
14437 arg5 = (PLFLT)(val5);
14438 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14439 if (!SWIG_IsOK(ecode6)) {
14440 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14441 }
14442 arg6 = (PLFLT)(val6);
14443 {
14444 if ( swig_obj[6] != Py_None )
14445 {
14446 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14447 if ( tmp7 == NULL )
14448 return NULL;
14449 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14450 arg8 = PyArray_DIMS( tmp7 )[0];
14451 }
14452 else
14453 {
14454 arg7 = NULL;
14455 arg8 = 0;
14456 }
14457 }
14458 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14459 resultobj = SWIG_Py_Void();
14460 {
14462 }
14463 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14464 {
14465 Py_CLEAR( tmp7 );
14466 }
14467 return resultobj;
14468fail:
14469 {
14471 }
14472 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14473 {
14474 Py_CLEAR( tmp7 );
14475 }
14476 return NULL;
14477}
14478
14479
14480SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14481 PyObject *resultobj = 0;
14482 mapform_func arg1 = (mapform_func) 0 ;
14483 char *arg2 = (char *) 0 ;
14484 char *arg3 = (char *) 0 ;
14485 PLFLT arg4 ;
14486 PLFLT arg5 ;
14487 PLFLT arg6 ;
14488 PLFLT arg7 ;
14489 PLINT *arg8 = (PLINT *) 0 ;
14490 PLINT arg9 ;
14491 int res2 ;
14492 char *buf2 = 0 ;
14493 int alloc2 = 0 ;
14494 int res3 ;
14495 char *buf3 = 0 ;
14496 int alloc3 = 0 ;
14497 double val4 ;
14498 int ecode4 = 0 ;
14499 double val5 ;
14500 int ecode5 = 0 ;
14501 double val6 ;
14502 int ecode6 = 0 ;
14503 double val7 ;
14504 int ecode7 = 0 ;
14505 PyArrayObject *tmp8 = NULL ;
14506 PyObject *swig_obj[8] ;
14507
14508 (void)self;
14509 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14510 {
14511 // it must be a callable or none
14512 if ( swig_obj[0] == Py_None )
14513 {
14514 arg1 = NULL;
14515 }
14516 else
14517 {
14518 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14519 {
14520 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14521 return NULL;
14522 }
14523 arg1 = marshal_mapform( swig_obj[0] );
14524 }
14525 }
14526 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14527 if (!SWIG_IsOK(res2)) {
14528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14529 }
14530 arg2 = (char *)(buf2);
14531 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14532 if (!SWIG_IsOK(res3)) {
14533 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14534 }
14535 arg3 = (char *)(buf3);
14536 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14537 if (!SWIG_IsOK(ecode4)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14539 }
14540 arg4 = (PLFLT)(val4);
14541 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14542 if (!SWIG_IsOK(ecode5)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14544 }
14545 arg5 = (PLFLT)(val5);
14546 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14547 if (!SWIG_IsOK(ecode6)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14549 }
14550 arg6 = (PLFLT)(val6);
14551 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14552 if (!SWIG_IsOK(ecode7)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14554 }
14555 arg7 = (PLFLT)(val7);
14556 {
14557 if ( swig_obj[7] != Py_None )
14558 {
14559 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14560 if ( tmp8 == NULL )
14561 return NULL;
14562 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14563 arg9 = PyArray_DIMS( tmp8 )[0];
14564 }
14565 else
14566 {
14567 arg8 = NULL;
14568 arg9 = 0;
14569 }
14570 }
14571 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14572 resultobj = SWIG_Py_Void();
14573 {
14575 }
14576 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14577 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14578 {
14579 Py_CLEAR( tmp8 );
14580 }
14581 return resultobj;
14582fail:
14583 {
14585 }
14586 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14587 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14588 {
14589 Py_CLEAR( tmp8 );
14590 }
14591 return NULL;
14592}
14593
14594
14595SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14596 PyObject *resultobj = 0;
14597 mapform_func arg1 = (mapform_func) 0 ;
14598 char *arg2 = (char *) 0 ;
14599 PLFLT arg3 ;
14600 PLFLT arg4 ;
14601 PLFLT arg5 ;
14602 char *arg6 = (char *) 0 ;
14603 PLFLT arg7 ;
14604 PLFLT arg8 ;
14605 PLFLT arg9 ;
14606 PLFLT arg10 ;
14607 PLINT arg11 ;
14608 int res2 ;
14609 char *buf2 = 0 ;
14610 int alloc2 = 0 ;
14611 double val3 ;
14612 int ecode3 = 0 ;
14613 double val4 ;
14614 int ecode4 = 0 ;
14615 double val5 ;
14616 int ecode5 = 0 ;
14617 int res6 ;
14618 char *buf6 = 0 ;
14619 int alloc6 = 0 ;
14620 double val7 ;
14621 int ecode7 = 0 ;
14622 double val8 ;
14623 int ecode8 = 0 ;
14624 double val9 ;
14625 int ecode9 = 0 ;
14626 double val10 ;
14627 int ecode10 = 0 ;
14628 int val11 ;
14629 int ecode11 = 0 ;
14630 PyObject *swig_obj[11] ;
14631
14632 (void)self;
14633 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14634 {
14635 // it must be a callable or none
14636 if ( swig_obj[0] == Py_None )
14637 {
14638 arg1 = NULL;
14639 }
14640 else
14641 {
14642 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14643 {
14644 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14645 return NULL;
14646 }
14647 arg1 = marshal_mapform( swig_obj[0] );
14648 }
14649 }
14650 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14651 if (!SWIG_IsOK(res2)) {
14652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14653 }
14654 arg2 = (char *)(buf2);
14655 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14656 if (!SWIG_IsOK(ecode3)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14658 }
14659 arg3 = (PLFLT)(val3);
14660 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14661 if (!SWIG_IsOK(ecode4)) {
14662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14663 }
14664 arg4 = (PLFLT)(val4);
14665 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14666 if (!SWIG_IsOK(ecode5)) {
14667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14668 }
14669 arg5 = (PLFLT)(val5);
14670 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14671 if (!SWIG_IsOK(res6)) {
14672 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14673 }
14674 arg6 = (char *)(buf6);
14675 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14676 if (!SWIG_IsOK(ecode7)) {
14677 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14678 }
14679 arg7 = (PLFLT)(val7);
14680 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14681 if (!SWIG_IsOK(ecode8)) {
14682 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14683 }
14684 arg8 = (PLFLT)(val8);
14685 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14686 if (!SWIG_IsOK(ecode9)) {
14687 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14688 }
14689 arg9 = (PLFLT)(val9);
14690 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14691 if (!SWIG_IsOK(ecode10)) {
14692 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14693 }
14694 arg10 = (PLFLT)(val10);
14695 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14696 if (!SWIG_IsOK(ecode11)) {
14697 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14698 }
14699 arg11 = (PLINT)(val11);
14700 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14701 resultobj = SWIG_Py_Void();
14702 {
14704 }
14705 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14706 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14707 return resultobj;
14708fail:
14709 {
14711 }
14712 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14713 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14714 return NULL;
14715}
14716
14717
14718SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14719 PyObject *resultobj = 0;
14720 mapform_func arg1 = (mapform_func) 0 ;
14721 char *arg2 = (char *) 0 ;
14722 PLFLT arg3 ;
14723 PLFLT arg4 ;
14724 PLFLT arg5 ;
14725 PLFLT arg6 ;
14726 PLINT *arg7 = (PLINT *) 0 ;
14727 PLINT arg8 ;
14728 int res2 ;
14729 char *buf2 = 0 ;
14730 int alloc2 = 0 ;
14731 double val3 ;
14732 int ecode3 = 0 ;
14733 double val4 ;
14734 int ecode4 = 0 ;
14735 double val5 ;
14736 int ecode5 = 0 ;
14737 double val6 ;
14738 int ecode6 = 0 ;
14739 PyArrayObject *tmp7 = NULL ;
14740 PyObject *swig_obj[7] ;
14741
14742 (void)self;
14743 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14744 {
14745 // it must be a callable or none
14746 if ( swig_obj[0] == Py_None )
14747 {
14748 arg1 = NULL;
14749 }
14750 else
14751 {
14752 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14753 {
14754 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14755 return NULL;
14756 }
14757 arg1 = marshal_mapform( swig_obj[0] );
14758 }
14759 }
14760 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14761 if (!SWIG_IsOK(res2)) {
14762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14763 }
14764 arg2 = (char *)(buf2);
14765 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14766 if (!SWIG_IsOK(ecode3)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14768 }
14769 arg3 = (PLFLT)(val3);
14770 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14771 if (!SWIG_IsOK(ecode4)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14773 }
14774 arg4 = (PLFLT)(val4);
14775 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14776 if (!SWIG_IsOK(ecode5)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14778 }
14779 arg5 = (PLFLT)(val5);
14780 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14781 if (!SWIG_IsOK(ecode6)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14783 }
14784 arg6 = (PLFLT)(val6);
14785 {
14786 if ( swig_obj[6] != Py_None )
14787 {
14788 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14789 if ( tmp7 == NULL )
14790 return NULL;
14791 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14792 arg8 = PyArray_DIMS( tmp7 )[0];
14793 }
14794 else
14795 {
14796 arg7 = NULL;
14797 arg8 = 0;
14798 }
14799 }
14800 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14801 resultobj = SWIG_Py_Void();
14802 {
14804 }
14805 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14806 {
14807 Py_CLEAR( tmp7 );
14808 }
14809 return resultobj;
14810fail:
14811 {
14813 }
14814 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14815 {
14816 Py_CLEAR( tmp7 );
14817 }
14818 return NULL;
14819}
14820
14821
14822SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14823 PyObject *resultobj = 0;
14824 mapform_func arg1 = (mapform_func) 0 ;
14825 PLFLT arg2 ;
14826 PLFLT arg3 ;
14827 PLFLT arg4 ;
14828 PLFLT arg5 ;
14829 PLFLT arg6 ;
14830 PLFLT arg7 ;
14831 double val2 ;
14832 int ecode2 = 0 ;
14833 double val3 ;
14834 int ecode3 = 0 ;
14835 double val4 ;
14836 int ecode4 = 0 ;
14837 double val5 ;
14838 int ecode5 = 0 ;
14839 double val6 ;
14840 int ecode6 = 0 ;
14841 double val7 ;
14842 int ecode7 = 0 ;
14843 PyObject *swig_obj[7] ;
14844
14845 (void)self;
14846 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14847 {
14848 // it must be a callable or none
14849 if ( swig_obj[0] == Py_None )
14850 {
14851 arg1 = NULL;
14852 }
14853 else
14854 {
14855 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14856 {
14857 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14858 return NULL;
14859 }
14860 arg1 = marshal_mapform( swig_obj[0] );
14861 }
14862 }
14863 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14864 if (!SWIG_IsOK(ecode2)) {
14865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14866 }
14867 arg2 = (PLFLT)(val2);
14868 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14869 if (!SWIG_IsOK(ecode3)) {
14870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14871 }
14872 arg3 = (PLFLT)(val3);
14873 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14874 if (!SWIG_IsOK(ecode4)) {
14875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14876 }
14877 arg4 = (PLFLT)(val4);
14878 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14879 if (!SWIG_IsOK(ecode5)) {
14880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14881 }
14882 arg5 = (PLFLT)(val5);
14883 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14884 if (!SWIG_IsOK(ecode6)) {
14885 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14886 }
14887 arg6 = (PLFLT)(val6);
14888 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14889 if (!SWIG_IsOK(ecode7)) {
14890 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14891 }
14892 arg7 = (PLFLT)(val7);
14893 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14894 resultobj = SWIG_Py_Void();
14895 {
14897 }
14898 return resultobj;
14899fail:
14900 {
14902 }
14903 return NULL;
14904}
14905
14906
14907SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14908 PyObject *resultobj = 0;
14909 PLFLT **arg1 = (PLFLT **) 0 ;
14910 PLINT arg2 ;
14911 PLINT arg3 ;
14912 PLFLT arg4 ;
14913 PLFLT arg5 ;
14914 PLFLT arg6 ;
14915 PLFLT arg7 ;
14916 PLFLT arg8 ;
14917 PLFLT arg9 ;
14918 PLFLT arg10 ;
14919 PLFLT arg11 ;
14920 PLFLT arg12 ;
14921 PLFLT arg13 ;
14922 PyArrayObject *tmp1 = NULL ;
14923 double val4 ;
14924 int ecode4 = 0 ;
14925 double val5 ;
14926 int ecode5 = 0 ;
14927 double val6 ;
14928 int ecode6 = 0 ;
14929 double val7 ;
14930 int ecode7 = 0 ;
14931 double val8 ;
14932 int ecode8 = 0 ;
14933 double val9 ;
14934 int ecode9 = 0 ;
14935 double val10 ;
14936 int ecode10 = 0 ;
14937 double val11 ;
14938 int ecode11 = 0 ;
14939 double val12 ;
14940 int ecode12 = 0 ;
14941 double val13 ;
14942 int ecode13 = 0 ;
14943 PyObject *swig_obj[11] ;
14944
14945 (void)self;
14946 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14947 {
14948 int i, size;
14949 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14950 if ( tmp1 == NULL )
14951 return NULL;
14952 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14953 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14954 size = arg3;
14955 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14956 for ( i = 0; i < arg2; i++ )
14957 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14958 }
14959 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14960 if (!SWIG_IsOK(ecode4)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14962 }
14963 arg4 = (PLFLT)(val4);
14964 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14965 if (!SWIG_IsOK(ecode5)) {
14966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14967 }
14968 arg5 = (PLFLT)(val5);
14969 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14970 if (!SWIG_IsOK(ecode6)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14972 }
14973 arg6 = (PLFLT)(val6);
14974 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14975 if (!SWIG_IsOK(ecode7)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14977 }
14978 arg7 = (PLFLT)(val7);
14979 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14980 if (!SWIG_IsOK(ecode8)) {
14981 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14982 }
14983 arg8 = (PLFLT)(val8);
14984 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14985 if (!SWIG_IsOK(ecode9)) {
14986 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14987 }
14988 arg9 = (PLFLT)(val9);
14989 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14990 if (!SWIG_IsOK(ecode10)) {
14991 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14992 }
14993 arg10 = (PLFLT)(val10);
14994 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14995 if (!SWIG_IsOK(ecode11)) {
14996 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14997 }
14998 arg11 = (PLFLT)(val11);
14999 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
15000 if (!SWIG_IsOK(ecode12)) {
15001 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
15002 }
15003 arg12 = (PLFLT)(val12);
15004 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
15005 if (!SWIG_IsOK(ecode13)) {
15006 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
15007 }
15008 arg13 = (PLFLT)(val13);
15009 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15010 resultobj = SWIG_Py_Void();
15011 {
15012 Py_CLEAR( tmp1 );
15013 free( arg1 );
15014 }
15015 return resultobj;
15016fail:
15017 {
15018 Py_CLEAR( tmp1 );
15019 free( arg1 );
15020 }
15021 return NULL;
15022}
15023
15024
15025SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
15026 PyObject *resultobj = 0;
15027 PLFLT **arg1 = (PLFLT **) 0 ;
15028 PLINT arg2 ;
15029 PLINT arg3 ;
15030 PLFLT arg4 ;
15031 PLFLT arg5 ;
15032 PLFLT arg6 ;
15033 PLFLT arg7 ;
15034 PLFLT arg8 ;
15035 PLFLT arg9 ;
15036 PLFLT arg10 ;
15037 PLFLT arg11 ;
15038 pltr_func arg12 = (pltr_func) 0 ;
15039 PLPointer arg13 = (PLPointer) 0 ;
15040 PyArrayObject *tmp1 = NULL ;
15041 double val4 ;
15042 int ecode4 = 0 ;
15043 double val5 ;
15044 int ecode5 = 0 ;
15045 double val6 ;
15046 int ecode6 = 0 ;
15047 double val7 ;
15048 int ecode7 = 0 ;
15049 double val8 ;
15050 int ecode8 = 0 ;
15051 double val9 ;
15052 int ecode9 = 0 ;
15053 double val10 ;
15054 int ecode10 = 0 ;
15055 double val11 ;
15056 int ecode11 = 0 ;
15057 PyObject *swig_obj[11] ;
15058
15059 {
15060 python_pltr = 0;
15061 arg12 = NULL;
15062 }
15063 {
15064 arg13 = NULL;
15065 }
15066 (void)self;
15067 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15068 {
15069 int i, size;
15070 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15071 if ( tmp1 == NULL )
15072 return NULL;
15073 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15074 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15075 size = arg3;
15076 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15077 for ( i = 0; i < arg2; i++ )
15078 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15079 }
15080 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15081 if (!SWIG_IsOK(ecode4)) {
15082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15083 }
15084 arg4 = (PLFLT)(val4);
15085 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15086 if (!SWIG_IsOK(ecode5)) {
15087 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15088 }
15089 arg5 = (PLFLT)(val5);
15090 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15091 if (!SWIG_IsOK(ecode6)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15093 }
15094 arg6 = (PLFLT)(val6);
15095 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15096 if (!SWIG_IsOK(ecode7)) {
15097 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15098 }
15099 arg7 = (PLFLT)(val7);
15100 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15101 if (!SWIG_IsOK(ecode8)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15103 }
15104 arg8 = (PLFLT)(val8);
15105 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15106 if (!SWIG_IsOK(ecode9)) {
15107 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15108 }
15109 arg9 = (PLFLT)(val9);
15110 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15111 if (!SWIG_IsOK(ecode10)) {
15112 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15113 }
15114 arg10 = (PLFLT)(val10);
15115 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15116 if (!SWIG_IsOK(ecode11)) {
15117 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15118 }
15119 arg11 = (PLFLT)(val11);
15120 if (swig_obj[9]) {
15121 {
15122 // it must be a callable or None
15123 if ( swig_obj[9] == Py_None )
15124 {
15125 arg12 = NULL;
15126 }
15127 else
15128 {
15129 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15130 {
15131 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15132 return NULL;
15133 }
15134 arg12 = marshal_pltr( swig_obj[9] );
15135 }
15136 }
15137 }
15138 if (swig_obj[10]) {
15139 {
15140 if ( swig_obj[10] == Py_None )
15141 arg13 = NULL;
15142 else
15143 {
15144 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15145 }
15146 }
15147 }
15148 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15149 resultobj = SWIG_Py_Void();
15150 {
15151 Py_CLEAR( tmp1 );
15152 free( arg1 );
15153 }
15154 {
15155 cleanup_pltr();
15156 }
15157 {
15159 }
15160 return resultobj;
15161fail:
15162 {
15163 Py_CLEAR( tmp1 );
15164 free( arg1 );
15165 }
15166 {
15167 cleanup_pltr();
15168 }
15169 {
15171 }
15172 return NULL;
15173}
15174
15175
15176SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15177 PyObject *resultobj = 0;
15178
15179 (void)self;
15180 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15181 plClearOpts();
15182 resultobj = SWIG_Py_Void();
15183 return resultobj;
15184fail:
15185 return NULL;
15186}
15187
15188
15189SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15190 PyObject *resultobj = 0;
15191
15192 (void)self;
15193 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15194 plResetOpts();
15195 resultobj = SWIG_Py_Void();
15196 return resultobj;
15197fail:
15198 return NULL;
15199}
15200
15201
15202SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15203 PyObject *resultobj = 0;
15204 char *arg1 = (char *) 0 ;
15205 char *arg2 = (char *) 0 ;
15206 int res1 ;
15207 char *buf1 = 0 ;
15208 int alloc1 = 0 ;
15209 int res2 ;
15210 char *buf2 = 0 ;
15211 int alloc2 = 0 ;
15212 PyObject *swig_obj[2] ;
15213
15214 (void)self;
15215 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15216 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15217 if (!SWIG_IsOK(res1)) {
15218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15219 }
15220 arg1 = (char *)(buf1);
15221 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15222 if (!SWIG_IsOK(res2)) {
15223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15224 }
15225 arg2 = (char *)(buf2);
15226 plSetUsage((char const *)arg1,(char const *)arg2);
15227 resultobj = SWIG_Py_Void();
15228 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15229 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15230 return resultobj;
15231fail:
15232 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15233 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15234 return NULL;
15235}
15236
15237
15238SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15239 PyObject *resultobj = 0;
15240
15241 (void)self;
15242 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15243 plOptUsage();
15244 resultobj = SWIG_Py_Void();
15245 return resultobj;
15246fail:
15247 return NULL;
15248}
15249
15250
15251SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15252 PyObject *resultobj = 0;
15253 PLFLT **arg1 = (PLFLT **) 0 ;
15254 PLINT arg2 ;
15255 PLINT arg3 ;
15256 PLFLT *arg4 = (PLFLT *) 0 ;
15257 PLFLT *arg5 = (PLFLT *) 0 ;
15258 PyArrayObject *tmp1 = NULL ;
15259 PLFLT temp4 ;
15260 int res4 = SWIG_TMPOBJ ;
15261 PLFLT temp5 ;
15262 int res5 = SWIG_TMPOBJ ;
15263 PyObject *swig_obj[1] ;
15264
15265 arg4 = &temp4;
15266 arg5 = &temp5;
15267 (void)self;
15268 if (!args) SWIG_fail;
15269 swig_obj[0] = args;
15270 {
15271 int i, size;
15272 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15273 if ( tmp1 == NULL )
15274 return NULL;
15275 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15276 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15277 size = arg3;
15278 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15279 for ( i = 0; i < arg2; i++ )
15280 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15281 }
15282 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15283 resultobj = SWIG_Py_Void();
15284 if (SWIG_IsTmpObj(res4)) {
15285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
15286 } else {
15287 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
15289 }
15290 if (SWIG_IsTmpObj(res5)) {
15291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
15292 } else {
15293 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
15295 }
15296 {
15297 Py_CLEAR( tmp1 );
15298 free( arg1 );
15299 }
15300 return resultobj;
15301fail:
15302 {
15303 Py_CLEAR( tmp1 );
15304 free( arg1 );
15305 }
15306 return NULL;
15307}
15308
15309
15310SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15311 PyObject *resultobj = 0;
15312 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15313 void *argp1 = 0 ;
15314 int res1 = 0 ;
15315 PyObject *swig_obj[1] ;
15316 PLINT result;
15317
15318 (void)self;
15319 if (!args) SWIG_fail;
15320 swig_obj[0] = args;
15321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15322 if (!SWIG_IsOK(res1)) {
15323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15324 }
15325 arg1 = (PLGraphicsIn *)(argp1);
15326 result = (PLINT)plGetCursor(arg1);
15327 resultobj = SWIG_From_int((int)(result));
15328 return resultobj;
15329fail:
15330 return NULL;
15331}
15332
15333
15334static PyMethodDef SwigMethods[] = {
15335 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15336 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15337 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15338 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15339 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15340 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15341 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15342 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15343 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15344 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15345 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15346 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15347 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15348 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15349 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15350 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15351 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15352 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15353 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15354 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15355 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15356 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15357 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15358 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15359 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15360 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15361 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15362 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15363 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15364 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15365 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15366 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15367 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15368 "Set format of numerical label for contours\n"
15369 "\n"
15370 "DESCRIPTION:\n"
15371 "\n"
15372 " Set format of numerical label for contours.\n"
15373 "\n"
15374 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15375 "\n"
15376 " This function is used example 9.\n"
15377 "\n"
15378 "\n"
15379 "\n"
15380 "SYNOPSIS:\n"
15381 "\n"
15382 "pl_setcontlabelformat(lexp, sigdig)\n"
15383 "\n"
15384 "ARGUMENTS:\n"
15385 "\n"
15386 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15387 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15388 " format is used. Default value of lexp is 4.\n"
15389 "\n"
15390 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15391 " value is 2.\n"
15392 "\n"
15393 ""},
15394 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15395 "Set parameters of contour labelling other than format of numerical label\n"
15396 "\n"
15397 "DESCRIPTION:\n"
15398 "\n"
15399 " Set parameters of contour labelling other than those handled by\n"
15400 " pl_setcontlabelformat.\n"
15401 "\n"
15402 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15403 "\n"
15404 " This function is used in example 9.\n"
15405 "\n"
15406 "\n"
15407 "\n"
15408 "SYNOPSIS:\n"
15409 "\n"
15410 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15411 "\n"
15412 "ARGUMENTS:\n"
15413 "\n"
15414 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15415 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15416 "\n"
15417 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15418 " Default value is 0.3.\n"
15419 "\n"
15420 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15421 " Default value is 0.1.\n"
15422 "\n"
15423 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15424 " contour labels on. Default is off (0).\n"
15425 "\n"
15426 ""},
15427 { "pladv", _wrap_pladv, METH_O, "\n"
15428 "Advance the (sub-)page\n"
15429 "\n"
15430 "DESCRIPTION:\n"
15431 "\n"
15432 " Advances to the next subpage if sub=0, performing a page advance if\n"
15433 " there are no remaining subpages on the current page. If subpages\n"
15434 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15435 " PLplot switches to the specified subpage. Note that this allows you\n"
15436 " to overwrite a plot on the specified subpage; if this is not what you\n"
15437 " intended, use pleop followed by plbop to first advance the page. This\n"
15438 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15439 " is not used, pladv must be called after initializing PLplot but before\n"
15440 " defining the viewport.\n"
15441 "\n"
15442 " Redacted form: pladv(page)\n"
15443 "\n"
15444 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15445 " 29, and 31.\n"
15446 "\n"
15447 "\n"
15448 "\n"
15449 "SYNOPSIS:\n"
15450 "\n"
15451 "pladv(page)\n"
15452 "\n"
15453 "ARGUMENTS:\n"
15454 "\n"
15455 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15456 " in the top left corner and increasing along the rows) to which to\n"
15457 " advance. Set to zero to advance to the next subpage (or to the\n"
15458 " next page if subpages are not being used).\n"
15459 "\n"
15460 ""},
15461 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15462 "Draw a circular or elliptical arc\n"
15463 "\n"
15464 "DESCRIPTION:\n"
15465 "\n"
15466 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15467 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15468 "\n"
15469 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15470 " fill)\n"
15471 "\n"
15472 "\n"
15473 " This function is used in examples 3 and 27.\n"
15474 "\n"
15475 "\n"
15476 "\n"
15477 "SYNOPSIS:\n"
15478 "\n"
15479 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15480 "\n"
15481 "ARGUMENTS:\n"
15482 "\n"
15483 " x (PLFLT, input) : X coordinate of arc center.\n"
15484 "\n"
15485 " y (PLFLT, input) : Y coordinate of arc center.\n"
15486 "\n"
15487 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15488 "\n"
15489 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15490 "\n"
15491 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15492 " semimajor axis.\n"
15493 "\n"
15494 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15495 " semimajor axis.\n"
15496 "\n"
15497 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15498 " X-axis.\n"
15499 "\n"
15500 " fill (PLBOOL, input) : Draw a filled arc.\n"
15501 "\n"
15502 ""},
15503 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15504 "Draw a box with axes, etc. with arbitrary origin\n"
15505 "\n"
15506 "DESCRIPTION:\n"
15507 "\n"
15508 " Draws a box around the currently defined viewport with arbitrary\n"
15509 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15510 " world coordinate values appropriate to the window. Thus plaxes should\n"
15511 " only be called after defining both viewport and window. The ascii\n"
15512 " character strings xopt and yopt specify how the box should be drawn as\n"
15513 " described below. If ticks and/or subticks are to be drawn for a\n"
15514 " particular axis, the tick intervals and number of subintervals may be\n"
15515 " specified explicitly, or they may be defaulted by setting the\n"
15516 " appropriate arguments to zero.\n"
15517 "\n"
15518 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15519 " ytick, nysub)\n"
15520 "\n"
15521 "\n"
15522 " This function is not used in any examples.\n"
15523 "\n"
15524 "\n"
15525 "\n"
15526 "SYNOPSIS:\n"
15527 "\n"
15528 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15529 "\n"
15530 "ARGUMENTS:\n"
15531 "\n"
15532 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15533 "\n"
15534 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15535 "\n"
15536 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15537 " options for the x axis. The string can include any combination of\n"
15538 " the following letters (upper or lower case) in any order: a: Draws\n"
15539 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15540 " (x=0).\n"
15541 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15542 " c: Draws top (X) or right (Y) edge of frame.\n"
15543 " d: Plot labels as date / time. Values are assumed to be\n"
15544 " seconds since the epoch (as used by gmtime).\n"
15545 " f: Always use fixed point numeric labels.\n"
15546 " g: Draws a grid at the major tick interval.\n"
15547 " h: Draws a grid at the minor tick interval.\n"
15548 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15549 " inwards.\n"
15550 " l: Labels axis logarithmically. This only affects the labels,\n"
15551 " not the data, and so it is necessary to compute the logarithms\n"
15552 " of data points before passing them to any of the drawing\n"
15553 " routines.\n"
15554 " m: Writes numeric labels at major tick intervals in the\n"
15555 " unconventional location (above box for X, right of box for Y).\n"
15556 " n: Writes numeric labels at major tick intervals in the\n"
15557 " conventional location (below box for X, left of box for Y).\n"
15558 " o: Use custom labelling function to generate axis label text.\n"
15559 " The custom labelling function can be defined with the\n"
15560 " plslabelfunc command.\n"
15561 " s: Enables subticks between major ticks, only valid if t is\n"
15562 " also specified.\n"
15563 " t: Draws major ticks.\n"
15564 " u: Exactly like \"b\" except don't draw edge line.\n"
15565 " w: Exactly like \"c\" except don't draw edge line.\n"
15566 " x: Exactly like \"t\" (including the side effect of the\n"
15567 " numerical labels for the major ticks) except exclude drawing\n"
15568 " the major and minor tick marks.\n"
15569 "\n"
15570 "\n"
15571 " xtick (PLFLT, input) : World coordinate interval between major\n"
15572 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15573 " generates a suitable tick interval.\n"
15574 "\n"
15575 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15576 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15577 " generates a suitable minor tick interval.\n"
15578 "\n"
15579 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15580 " options for the y axis. The string can include any combination of\n"
15581 " the letters defined above for xopt, and in addition may contain:\n"
15582 " v: Write numeric labels for the y axis parallel to the base of the\n"
15583 " graph, rather than parallel to the axis.\n"
15584 "\n"
15585 "\n"
15586 " ytick (PLFLT, input) : World coordinate interval between major\n"
15587 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15588 " generates a suitable tick interval.\n"
15589 "\n"
15590 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15591 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15592 " generates a suitable minor tick interval.\n"
15593 "\n"
15594 ""},
15595 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15596 "Plot a histogram from binned data\n"
15597 "\n"
15598 "DESCRIPTION:\n"
15599 "\n"
15600 " Plots a histogram consisting of nbin bins. The value associated with\n"
15601 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15602 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15603 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15604 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15605 " placed midway between the values in the x vector. Also see plhist for\n"
15606 " drawing histograms from unbinned data.\n"
15607 "\n"
15608 " Redacted form: General: plbin(x, y, opt)\n"
15609 " Python: plbin(nbin, x, y, opt)\n"
15610 "\n"
15611 "\n"
15612 " This function is not used in any examples.\n"
15613 "\n"
15614 "\n"
15615 "\n"
15616 "SYNOPSIS:\n"
15617 "\n"
15618 "plbin(nbin, x, y, opt)\n"
15619 "\n"
15620 "ARGUMENTS:\n"
15621 "\n"
15622 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15623 " and y vectors.)\n"
15624 "\n"
15625 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15626 " with bins. These must form a strictly increasing sequence.\n"
15627 "\n"
15628 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15629 " proportional to the number of points in each bin. This is a PLFLT\n"
15630 " (instead of PLINT) vector so as to allow histograms of\n"
15631 " probabilities, etc.\n"
15632 "\n"
15633 " opt (PLINT, input) : Is a combination of several flags:\n"
15634 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15635 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15636 " zero height are simply drawn.\n"
15637 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15638 " between the x values. If the values in x are equally spaced,\n"
15639 " the values are the center values of the bins.\n"
15640 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15641 " size as the ones inside.\n"
15642 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15643 " (there is a gap for such bins).\n"
15644 "\n"
15645 ""},
15646 { "plbtime", _wrap_plbtime, METH_O, "\n"
15647 "Calculate broken-down time from continuous time for the current stream\n"
15648 "\n"
15649 "DESCRIPTION:\n"
15650 "\n"
15651 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15652 " continuous time, ctime for the current stream. This function is the\n"
15653 " inverse of plctime.\n"
15654 "\n"
15655 " The PLplot definition of broken-down time is a calendar time that\n"
15656 " completely ignores all time zone offsets, i.e., it is the user's\n"
15657 " responsibility to apply those offsets (if so desired) before using the\n"
15658 " PLplot time API. By default broken-down time is defined using the\n"
15659 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15660 " continuous time is defined as the number of seconds since the Unix\n"
15661 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15662 " broken-down and continuous time are possible, see plconfigtime.\n"
15663 "\n"
15664 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15665 " ctime)\n"
15666 "\n"
15667 "\n"
15668 " This function is used in example 29.\n"
15669 "\n"
15670 "\n"
15671 "\n"
15672 "SYNOPSIS:\n"
15673 "\n"
15674 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15675 "\n"
15676 "ARGUMENTS:\n"
15677 "\n"
15678 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15679 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15680 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15681 " BCE, etc.)\n"
15682 "\n"
15683 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15684 " the year in the range from 0 (January) to 11 (December).\n"
15685 "\n"
15686 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15687 " month in the range from 1 to 31.\n"
15688 "\n"
15689 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15690 " day in the range from 0 to 23.\n"
15691 "\n"
15692 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15693 " hour in the range from 0 to 59\n"
15694 "\n"
15695 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15696 " minute in range from 0. to 60.\n"
15697 "\n"
15698 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15699 " time is calculated.\n"
15700 "\n"
15701 ""},
15702 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15703 "Begin a new page\n"
15704 "\n"
15705 "DESCRIPTION:\n"
15706 "\n"
15707 " Begins a new page. For a file driver, the output file is opened if\n"
15708 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15709 " page break is desired at a particular point when plotting to subpages.\n"
15710 " Another use for pleop and plbop is when plotting pages to different\n"
15711 " files, since you can manually set the file name by calling plsfnam\n"
15712 " after the call to pleop. (In fact some drivers may only support a\n"
15713 " single page per file, making this a necessity.) One way to handle\n"
15714 " this case automatically is to page advance via pladv, but enable\n"
15715 " familying (see plsfam) with a small limit on the file size so that a\n"
15716 " new family member file will be created on each page break.\n"
15717 "\n"
15718 " Redacted form: plbop()\n"
15719 "\n"
15720 " This function is used in examples 2 and 20.\n"
15721 "\n"
15722 "\n"
15723 "\n"
15724 "SYNOPSIS:\n"
15725 "\n"
15726 "plbop()\n"
15727 "\n"
15728 ""},
15729 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15730 "Draw a box with axes, etc\n"
15731 "\n"
15732 "DESCRIPTION:\n"
15733 "\n"
15734 " Draws a box around the currently defined viewport, and labels it with\n"
15735 " world coordinate values appropriate to the window. Thus plbox should\n"
15736 " only be called after defining both viewport and window. The ascii\n"
15737 " character strings xopt and yopt specify how the box should be drawn as\n"
15738 " described below. If ticks and/or subticks are to be drawn for a\n"
15739 " particular axis, the tick intervals and number of subintervals may be\n"
15740 " specified explicitly, or they may be defaulted by setting the\n"
15741 " appropriate arguments to zero.\n"
15742 "\n"
15743 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15744 "\n"
15745 "\n"
15746 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15747 " and 29.\n"
15748 "\n"
15749 "\n"
15750 "\n"
15751 "SYNOPSIS:\n"
15752 "\n"
15753 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15754 "\n"
15755 "ARGUMENTS:\n"
15756 "\n"
15757 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15758 " options for the x axis. The string can include any combination of\n"
15759 " the following letters (upper or lower case) in any order: a: Draws\n"
15760 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15761 " (x=0).\n"
15762 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15763 " c: Draws top (X) or right (Y) edge of frame.\n"
15764 " d: Plot labels as date / time. Values are assumed to be\n"
15765 " seconds since the epoch (as used by gmtime).\n"
15766 " f: Always use fixed point numeric labels.\n"
15767 " g: Draws a grid at the major tick interval.\n"
15768 " h: Draws a grid at the minor tick interval.\n"
15769 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15770 " inwards.\n"
15771 " l: Labels axis logarithmically. This only affects the labels,\n"
15772 " not the data, and so it is necessary to compute the logarithms\n"
15773 " of data points before passing them to any of the drawing\n"
15774 " routines.\n"
15775 " m: Writes numeric labels at major tick intervals in the\n"
15776 " unconventional location (above box for X, right of box for Y).\n"
15777 " n: Writes numeric labels at major tick intervals in the\n"
15778 " conventional location (below box for X, left of box for Y).\n"
15779 " o: Use custom labelling function to generate axis label text.\n"
15780 " The custom labelling function can be defined with the\n"
15781 " plslabelfunc command.\n"
15782 " s: Enables subticks between major ticks, only valid if t is\n"
15783 " also specified.\n"
15784 " t: Draws major ticks.\n"
15785 " u: Exactly like \"b\" except don't draw edge line.\n"
15786 " w: Exactly like \"c\" except don't draw edge line.\n"
15787 " x: Exactly like \"t\" (including the side effect of the\n"
15788 " numerical labels for the major ticks) except exclude drawing\n"
15789 " the major and minor tick marks.\n"
15790 "\n"
15791 "\n"
15792 " xtick (PLFLT, input) : World coordinate interval between major\n"
15793 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15794 " generates a suitable tick interval.\n"
15795 "\n"
15796 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15797 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15798 " generates a suitable minor tick interval.\n"
15799 "\n"
15800 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15801 " options for the y axis. The string can include any combination of\n"
15802 " the letters defined above for xopt, and in addition may contain:\n"
15803 " v: Write numeric labels for the y axis parallel to the base of the\n"
15804 " graph, rather than parallel to the axis.\n"
15805 "\n"
15806 "\n"
15807 " ytick (PLFLT, input) : World coordinate interval between major\n"
15808 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15809 " generates a suitable tick interval.\n"
15810 "\n"
15811 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15812 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15813 " generates a suitable minor tick interval.\n"
15814 "\n"
15815 ""},
15816 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15817 "Draw a box with axes, etc, in 3-d\n"
15818 "\n"
15819 "DESCRIPTION:\n"
15820 "\n"
15821 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15822 " plot. For a more complete description of three-dimensional plotting\n"
15823 " see the PLplot documentation.\n"
15824 "\n"
15825 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15826 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15827 "\n"
15828 "\n"
15829 " This function is used in examples 8, 11, 18, and 21.\n"
15830 "\n"
15831 "\n"
15832 "\n"
15833 "SYNOPSIS:\n"
15834 "\n"
15835 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15836 "\n"
15837 "ARGUMENTS:\n"
15838 "\n"
15839 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15840 " options for the x axis. The string can include any combination of\n"
15841 " the following letters (upper or lower case) in any order: b: Draws\n"
15842 " axis at base, at height z=\n"
15843 " zmin where zmin is defined by call to plw3d. This character must be\n"
15844 " specified in order to use any of the other options.\n"
15845 " d: Plot labels as date / time. Values are assumed to be\n"
15846 " seconds since the epoch (as used by gmtime).\n"
15847 " f: Always use fixed point numeric labels.\n"
15848 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15849 " than upwards.\n"
15850 " l: Labels axis logarithmically. This only affects the labels,\n"
15851 " not the data, and so it is necessary to compute the logarithms\n"
15852 " of data points before passing them to any of the drawing\n"
15853 " routines.\n"
15854 " n: Writes numeric labels at major tick intervals.\n"
15855 " o: Use custom labelling function to generate axis label text.\n"
15856 " The custom labelling function can be defined with the\n"
15857 " plslabelfunc command.\n"
15858 " s: Enables subticks between major ticks, only valid if t is\n"
15859 " also specified.\n"
15860 " t: Draws major ticks.\n"
15861 " u: If this is specified, the text label for the axis is\n"
15862 " written under the axis.\n"
15863 "\n"
15864 "\n"
15865 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15866 " the text label for the x axis. It is only drawn if u is in the\n"
15867 " xopt string.\n"
15868 "\n"
15869 " xtick (PLFLT, input) : World coordinate interval between major\n"
15870 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15871 " generates a suitable tick interval.\n"
15872 "\n"
15873 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15874 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15875 " generates a suitable minor tick interval.\n"
15876 "\n"
15877 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15878 " options for the y axis. The string is interpreted in the same way\n"
15879 " as xopt.\n"
15880 "\n"
15881 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15882 " the text label for the y axis. It is only drawn if u is in the\n"
15883 " yopt string.\n"
15884 "\n"
15885 " ytick (PLFLT, input) : World coordinate interval between major\n"
15886 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15887 " generates a suitable tick interval.\n"
15888 "\n"
15889 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15890 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15891 " generates a suitable minor tick interval.\n"
15892 "\n"
15893 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15894 " options for the z axis. The string can include any combination of\n"
15895 " the following letters (upper or lower case) in any order: b: Draws\n"
15896 " z axis to the left of the surface plot.\n"
15897 " c: Draws z axis to the right of the surface plot.\n"
15898 " d: Draws grid lines parallel to the x-y plane behind the\n"
15899 " figure. These lines are not drawn until after plot3d or\n"
15900 " plmesh are called because of the need for hidden line removal.\n"
15901 " e: Plot labels as date / time. Values are assumed to be\n"
15902 " seconds since the epoch (as used by gmtime). Note this\n"
15903 " suboption is interpreted the same as the d suboption for xopt\n"
15904 " and yopt, but it has to be identified as e for zopt since d\n"
15905 " has already been used for the different purpose above.\n"
15906 " f: Always use fixed point numeric labels.\n"
15907 " i: Inverts tick marks, so they are drawn away from the center.\n"
15908 " l: Labels axis logarithmically. This only affects the labels,\n"
15909 " not the data, and so it is necessary to compute the logarithms\n"
15910 " of data points before passing them to any of the drawing\n"
15911 " routines.\n"
15912 " m: Writes numeric labels at major tick intervals on the\n"
15913 " right-hand z axis.\n"
15914 " n: Writes numeric labels at major tick intervals on the\n"
15915 " left-hand z axis.\n"
15916 " o: Use custom labelling function to generate axis label text.\n"
15917 " The custom labelling function can be defined with the\n"
15918 " plslabelfunc command.\n"
15919 " s: Enables subticks between major ticks, only valid if t is\n"
15920 " also specified.\n"
15921 " t: Draws major ticks.\n"
15922 " u: If this is specified, the text label is written beside the\n"
15923 " left-hand axis.\n"
15924 " v: If this is specified, the text label is written beside the\n"
15925 " right-hand axis.\n"
15926 "\n"
15927 "\n"
15928 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15929 " the text label for the z axis. It is only drawn if u or v are in\n"
15930 " the zopt string.\n"
15931 "\n"
15932 " ztick (PLFLT, input) : World coordinate interval between major\n"
15933 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15934 " generates a suitable tick interval.\n"
15935 "\n"
15936 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15937 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15938 " generates a suitable minor tick interval.\n"
15939 "\n"
15940 ""},
15941 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15942 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15943 "\n"
15944 "DESCRIPTION:\n"
15945 "\n"
15946 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15947 " from relative device coordinates, rx and ry.\n"
15948 "\n"
15949 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15950 "\n"
15951 "\n"
15952 " This function is used in example 31.\n"
15953 "\n"
15954 "\n"
15955 "\n"
15956 "SYNOPSIS:\n"
15957 "\n"
15958 "plcalc_world(rx, ry, wx, wy, window)\n"
15959 "\n"
15960 "ARGUMENTS:\n"
15961 "\n"
15962 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15963 " the x coordinate.\n"
15964 "\n"
15965 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15966 " the y coordinate.\n"
15967 "\n"
15968 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15969 " coordinate corresponding to the relative device coordinates rx and\n"
15970 " ry.\n"
15971 "\n"
15972 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15973 " coordinate corresponding to the relative device coordinates rx and\n"
15974 " ry.\n"
15975 "\n"
15976 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15977 " defined window index that corresponds to the input relative device\n"
15978 " coordinates (and the returned world coordinates). To give some\n"
15979 " background on the window index, for each page the initial window\n"
15980 " index is set to zero, and each time plwind is called within the\n"
15981 " page, world and device coordinates are stored for the window and\n"
15982 " the window index is incremented. Thus, for a simple page layout\n"
15983 " with non-overlapping viewports and one window per viewport, window\n"
15984 " corresponds to the viewport index (in the order which the\n"
15985 " viewport/windows were created) of the only viewport/window\n"
15986 " corresponding to rx and ry. However, for more complicated layouts\n"
15987 " with potentially overlapping viewports and possibly more than one\n"
15988 " window (set of world coordinates) per viewport, window and the\n"
15989 " corresponding output world coordinates corresponds to the last\n"
15990 " window created that fulfills the criterion that the relative\n"
15991 " device coordinates are inside it. Finally, in all cases where the\n"
15992 " input relative device coordinates are not inside any\n"
15993 " viewport/window, then the returned value of the last defined\n"
15994 " window index is set to -1.\n"
15995 "\n"
15996 ""},
15997 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15998 "Clear current (sub)page\n"
15999 "\n"
16000 "DESCRIPTION:\n"
16001 "\n"
16002 " Clears the current page, effectively erasing everything that have been\n"
16003 " drawn. This command only works with interactive drivers; if the\n"
16004 " driver does not support this, the page is filled with the background\n"
16005 " color in use. If the current page is divided into subpages, only the\n"
16006 " current subpage is erased. The nth subpage can be selected with\n"
16007 " pladv(n).\n"
16008 "\n"
16009 " Redacted form: General: plclear()\n"
16010 "\n"
16011 "\n"
16012 " This function is not used in any examples.\n"
16013 "\n"
16014 "\n"
16015 "\n"
16016 "SYNOPSIS:\n"
16017 "\n"
16018 "plclear()\n"
16019 "\n"
16020 ""},
16021 { "plcol0", _wrap_plcol0, METH_O, "\n"
16022 "Set color, cmap0\n"
16023 "\n"
16024 "DESCRIPTION:\n"
16025 "\n"
16026 " Sets the color index for cmap0 (see the PLplot documentation).\n"
16027 "\n"
16028 " Redacted form: plcol0(icol0)\n"
16029 "\n"
16030 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16031 "\n"
16032 "\n"
16033 "\n"
16034 "SYNOPSIS:\n"
16035 "\n"
16036 "plcol0(icol0)\n"
16037 "\n"
16038 "ARGUMENTS:\n"
16039 "\n"
16040 " icol0 (PLINT, input) : Integer representing the color. The\n"
16041 " defaults at present are (these may change):\n"
16042 " 0 black (default background)\n"
16043 " 1 red (default foreground)\n"
16044 " 2 yellow\n"
16045 " 3 green\n"
16046 " 4 aquamarine\n"
16047 " 5 pink\n"
16048 " 6 wheat\n"
16049 " 7 grey\n"
16050 " 8 brown\n"
16051 " 9 blue\n"
16052 " 10 BlueViolet\n"
16053 " 11 cyan\n"
16054 " 12 turquoise\n"
16055 " 13 magenta\n"
16056 " 14 salmon\n"
16057 " 15 white\n"
16058 "\n"
16059 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16060 " change an individual color in the cmap0 color palette.\n"
16061 "\n"
16062 ""},
16063 { "plcol1", _wrap_plcol1, METH_O, "\n"
16064 "Set color, cmap1\n"
16065 "\n"
16066 "DESCRIPTION:\n"
16067 "\n"
16068 " Sets the color for cmap1 (see the PLplot documentation).\n"
16069 "\n"
16070 " Redacted form: plcol1(col1)\n"
16071 "\n"
16072 " This function is used in examples 12 and 21.\n"
16073 "\n"
16074 "\n"
16075 "\n"
16076 "SYNOPSIS:\n"
16077 "\n"
16078 "plcol1(col1)\n"
16079 "\n"
16080 "ARGUMENTS:\n"
16081 "\n"
16082 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16083 " is mapped to color using the continuous cmap1 palette which by\n"
16084 " default ranges from blue to the background color to red. The\n"
16085 " cmap1 palette can also be straightforwardly changed by the user\n"
16086 " with plscmap1 or plscmap1l.\n"
16087 "\n"
16088 ""},
16089 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16090 "Configure the transformation between continuous and broken-down time for the current stream\n"
16091 "\n"
16092 "DESCRIPTION:\n"
16093 "\n"
16094 " Configure the transformation between continuous and broken-down time\n"
16095 " for the current stream. This transformation is used by both plbtime\n"
16096 " and plctime.\n"
16097 "\n"
16098 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16099 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16100 "\n"
16101 "\n"
16102 " This function is used in example 29.\n"
16103 "\n"
16104 "\n"
16105 "\n"
16106 "SYNOPSIS:\n"
16107 "\n"
16108 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16109 "\n"
16110 "ARGUMENTS:\n"
16111 "\n"
16112 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16113 " As a special case, if\n"
16114 " scale is 0., then all other arguments are ignored, and the result (the\n"
16115 " default used by PLplot) is the equivalent of a call to\n"
16116 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16117 " That is, for this special case broken-down time is calculated with\n"
16118 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16119 " and the continuous time is defined as the number of seconds since\n"
16120 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16121 "\n"
16122 " offset1 (PLFLT, input) : If\n"
16123 " ifbtime_offset is true, the parameters\n"
16124 " offset1 and\n"
16125 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16126 " (with units in days) specify the epoch of the continuous time\n"
16127 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16128 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16129 " are used to specify the origin to allow users (by specifying\n"
16130 " offset1 as an integer that can be exactly represented by a\n"
16131 " floating-point variable and specifying\n"
16132 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16133 " the numerical errors of the continuous time representation.\n"
16134 "\n"
16135 " offset2 (PLFLT, input) : See documentation of\n"
16136 " offset1.\n"
16137 "\n"
16138 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16139 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16140 " calendar is used for broken-down time rather than the proleptic\n"
16141 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16142 " have been historically used to define UTC are inserted into the\n"
16143 " broken-down time. Other possibilities for additional control bits\n"
16144 " for ccontrol exist such as making the historical time corrections\n"
16145 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16146 " making the (slightly non-constant) corrections from international\n"
16147 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16148 " (TT). But those additional possibilities have not been\n"
16149 " implemented yet in the qsastime library (one of the PLplot utility\n"
16150 " libraries).\n"
16151 "\n"
16152 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16153 " epoch of the continuous time scale is specified by the user. If\n"
16154 " ifbtime_offset is false, then\n"
16155 " offset1 and\n"
16156 " offset2 are used to specify the epoch, and the following broken-down\n"
16157 " time parameters are completely ignored. If\n"
16158 " ifbtime_offset is true, then\n"
16159 " offset1 and\n"
16160 " offset2 are completely ignored, and the following broken-down time\n"
16161 " parameters are used to specify the epoch.\n"
16162 "\n"
16163 " year (PLINT, input) : Year of epoch.\n"
16164 "\n"
16165 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16166 " 11 (December).\n"
16167 "\n"
16168 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16169 "\n"
16170 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16171 "\n"
16172 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16173 "\n"
16174 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16175 "\n"
16176 ""},
16177 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16178 "Contour plot\n"
16179 "\n"
16180 "DESCRIPTION:\n"
16181 "\n"
16182 " Draws a contour plot of the data in f[\n"
16183 " nx][\n"
16184 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16185 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16186 " where all these index ranges are interpreted as one-based for\n"
16187 " historical reasons. A transformation routine pointed to by pltr with\n"
16188 " a generic pointer pltr_data for additional data required by the\n"
16189 " transformation routine is used to map indices within the matrix to the\n"
16190 " world coordinates.\n"
16191 "\n"
16192 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16193 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16194 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16195 " vectors; or xg and yg matrices.\n"
16196 "\n"
16197 " This function is used in examples 9, 14, 16, and 22.\n"
16198 "\n"
16199 "\n"
16200 "\n"
16201 "SYNOPSIS:\n"
16202 "\n"
16203 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16204 "\n"
16205 "ARGUMENTS:\n"
16206 "\n"
16207 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16208 "\n"
16209 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16210 "\n"
16211 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16212 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16213 " zero-based for historical backwards-compatibility reasons.\n"
16214 "\n"
16215 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16216 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16217 " zero-based for historical backwards-compatibility reasons.\n"
16218 "\n"
16219 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16220 " which to draw contours.\n"
16221 "\n"
16222 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16223 "\n"
16224 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16225 " defines the transformation between the zero-based indices of the\n"
16226 " matrix f and the world coordinates.For the C case, transformation\n"
16227 " functions are provided in the PLplot library: pltr0 for the\n"
16228 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16229 " respectively defined by vectors and matrices. In addition, C\n"
16230 " callback routines for the transformation can be supplied by the\n"
16231 " user such as the mypltr function in examples/c/x09c.c which\n"
16232 " provides a general linear transformation between index coordinates\n"
16233 " and world coordinates.For languages other than C you should\n"
16234 " consult the PLplot documentation for the details concerning how\n"
16235 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16236 " general, a particular pattern of callback-associated arguments\n"
16237 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16238 " yg matrices are respectively interfaced to a linear-transformation\n"
16239 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16240 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16241 " the PLplot documentation) support native language callbacks for\n"
16242 " handling index to world-coordinate transformations. Examples of\n"
16243 " these various approaches are given in examples/<language>x09*,\n"
16244 " examples/<language>x16*, examples/<language>x20*,\n"
16245 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16246 " supported languages.\n"
16247 "\n"
16248 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16249 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16250 " that is externally supplied.\n"
16251 "\n"
16252 ""},
16253 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16254 "Calculate continuous time from broken-down time for the current stream\n"
16255 "\n"
16256 "DESCRIPTION:\n"
16257 "\n"
16258 " Calculate continuous time, ctime, from broken-down time for the\n"
16259 " current stream. The broken-down\n"
16260 " time is specified by the following parameters: year, month, day, hour,\n"
16261 " min, and sec. This function is the inverse of plbtime.\n"
16262 "\n"
16263 " The PLplot definition of broken-down time is a calendar time that\n"
16264 " completely ignores all time zone offsets, i.e., it is the user's\n"
16265 " responsibility to apply those offsets (if so desired) before using the\n"
16266 " PLplot time API. By default broken-down time is defined using the\n"
16267 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16268 " continuous time is defined as the number of seconds since the Unix\n"
16269 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16270 " broken-down and continuous time are possible, see plconfigtime which\n"
16271 " specifies that transformation for the current stream.\n"
16272 "\n"
16273 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16274 " ctime)\n"
16275 "\n"
16276 "\n"
16277 " This function is used in example 29.\n"
16278 "\n"
16279 "\n"
16280 "\n"
16281 "SYNOPSIS:\n"
16282 "\n"
16283 "plctime(year, month, day, hour, min, sec, ctime)\n"
16284 "\n"
16285 "ARGUMENTS:\n"
16286 "\n"
16287 " year (PLINT, input) : Input year.\n"
16288 "\n"
16289 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16290 " (December).\n"
16291 "\n"
16292 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16293 "\n"
16294 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16295 "\n"
16296 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16297 "\n"
16298 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16299 "\n"
16300 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16301 " time calculated from the broken-down time specified by the\n"
16302 " previous parameters.\n"
16303 "\n"
16304 ""},
16305 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16306 "Copy state parameters from the reference stream to the current stream\n"
16307 "\n"
16308 "DESCRIPTION:\n"
16309 "\n"
16310 " Copies state parameters from the reference stream to the current\n"
16311 " stream. Tell driver interface to map device coordinates unless flags\n"
16312 " == 1.\n"
16313 "\n"
16314 " This function is used for making save files of selected plots (e.g.\n"
16315 " from the TK driver). After initializing, you can get a copy of the\n"
16316 " current plot to the specified device by switching to this stream and\n"
16317 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16318 " appropriate. The plot buffer must have previously been enabled (done\n"
16319 " automatically by some display drivers, such as X).\n"
16320 "\n"
16321 " Redacted form: plcpstrm(iplsr, flags)\n"
16322 "\n"
16323 " This function is used in example 1,20.\n"
16324 "\n"
16325 "\n"
16326 "\n"
16327 "SYNOPSIS:\n"
16328 "\n"
16329 "plcpstrm(iplsr, flags)\n"
16330 "\n"
16331 "ARGUMENTS:\n"
16332 "\n"
16333 " iplsr (PLINT, input) : Number of reference stream.\n"
16334 "\n"
16335 " flags (PLBOOL, input) : If flags is set to true the device\n"
16336 " coordinates are not copied from the reference to current stream.\n"
16337 "\n"
16338 ""},
16339 { "plend", _wrap_plend, METH_NOARGS, "\n"
16340 "End plotting session\n"
16341 "\n"
16342 "DESCRIPTION:\n"
16343 "\n"
16344 " Ends a plotting session, tidies up all the output files, switches\n"
16345 " interactive devices back into text mode and frees up any memory that\n"
16346 " was allocated. Must be called before end of program.\n"
16347 "\n"
16348 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16349 " wait state after a call to plend or other functions which trigger the\n"
16350 " end of a plot page. To avoid this, use the plspause function.\n"
16351 "\n"
16352 " Redacted form: plend()\n"
16353 "\n"
16354 " This function is used in all of the examples.\n"
16355 "\n"
16356 "\n"
16357 "\n"
16358 "SYNOPSIS:\n"
16359 "\n"
16360 "plend()\n"
16361 "\n"
16362 ""},
16363 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16364 "End plotting session for current stream\n"
16365 "\n"
16366 "DESCRIPTION:\n"
16367 "\n"
16368 " Ends a plotting session for the current output stream only. See\n"
16369 " plsstrm for more info.\n"
16370 "\n"
16371 " Redacted form: plend1()\n"
16372 "\n"
16373 " This function is used in examples 1 and 20.\n"
16374 "\n"
16375 "\n"
16376 "\n"
16377 "SYNOPSIS:\n"
16378 "\n"
16379 "plend1()\n"
16380 "\n"
16381 ""},
16382 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16383 "Set up standard window and draw box\n"
16384 "\n"
16385 "DESCRIPTION:\n"
16386 "\n"
16387 " Sets up plotter environment for simple graphs by calling pladv and\n"
16388 " setting up viewport and window to sensible default values. plenv\n"
16389 " leaves a standard margin (left-hand margin of eight character heights,\n"
16390 " and a margin around the other three sides of five character heights)\n"
16391 " around most graphs for axis labels and a title. When these defaults\n"
16392 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16393 " plvasp for setting up the viewport, plwind for defining the window,\n"
16394 " and plbox for drawing the box.\n"
16395 "\n"
16396 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16397 "\n"
16398 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16399 "\n"
16400 "\n"
16401 "\n"
16402 "SYNOPSIS:\n"
16403 "\n"
16404 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16405 "\n"
16406 "ARGUMENTS:\n"
16407 "\n"
16408 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16409 " world coordinates).\n"
16410 "\n"
16411 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16412 " world coordinates).\n"
16413 "\n"
16414 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16415 " coordinates).\n"
16416 "\n"
16417 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16418 " coordinates).\n"
16419 "\n"
16420 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16421 " scales will not be set, the user must set up the scale before\n"
16422 " calling plenv using plsvpa, plvasp or other.\n"
16423 " 0: the x and y axes are scaled independently to use as much of\n"
16424 " the screen as possible.\n"
16425 " 1: the scales of the x and y axes are made equal.\n"
16426 " 2: the axis of the x and y axes are made equal, and the plot\n"
16427 " box will be square.\n"
16428 "\n"
16429 "\n"
16430 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16431 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16432 " -1: draw box only.\n"
16433 " 0: draw box, ticks, and numeric tick labels.\n"
16434 " 1: also draw coordinate axes at x=0 and y=0.\n"
16435 " 2: also draw a grid at major tick positions in both\n"
16436 " coordinates.\n"
16437 " 3: also draw a grid at minor tick positions in both\n"
16438 " coordinates.\n"
16439 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16440 " have to be converted to logarithms separately.)\n"
16441 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16442 " have to be converted to logarithms separately.)\n"
16443 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16444 " have to be converted to logarithms separately.)\n"
16445 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16446 " have to be converted to logarithms separately.)\n"
16447 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16448 " have to be converted to logarithms separately.)\n"
16449 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16450 " have to be converted to logarithms separately.)\n"
16451 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16452 " have to be converted to logarithms separately.)\n"
16453 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16454 " have to be converted to logarithms separately.)\n"
16455 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16456 " and y data have to be converted to logarithms separately.)\n"
16457 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16458 " and y data have to be converted to logarithms separately.)\n"
16459 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16460 " and y data have to be converted to logarithms separately.)\n"
16461 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16462 " and y data have to be converted to logarithms separately.)\n"
16463 " 40: same as 0 except date / time x labels.\n"
16464 " 41: same as 1 except date / time x labels.\n"
16465 " 42: same as 2 except date / time x labels.\n"
16466 " 43: same as 3 except date / time x labels.\n"
16467 " 50: same as 0 except date / time y labels.\n"
16468 " 51: same as 1 except date / time y labels.\n"
16469 " 52: same as 2 except date / time y labels.\n"
16470 " 53: same as 3 except date / time y labels.\n"
16471 " 60: same as 0 except date / time x and y labels.\n"
16472 " 61: same as 1 except date / time x and y labels.\n"
16473 " 62: same as 2 except date / time x and y labels.\n"
16474 " 63: same as 3 except date / time x and y labels.\n"
16475 " 70: same as 0 except custom x and y labels.\n"
16476 " 71: same as 1 except custom x and y labels.\n"
16477 " 72: same as 2 except custom x and y labels.\n"
16478 " 73: same as 3 except custom x and y labels.\n"
16479 "\n"
16480 ""},
16481 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16482 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16483 "\n"
16484 "DESCRIPTION:\n"
16485 "\n"
16486 " Sets up plotter environment for simple graphs by calling pladv and\n"
16487 " setting up viewport and window to sensible default values. plenv0\n"
16488 " leaves a standard margin (left-hand margin of eight character heights,\n"
16489 " and a margin around the other three sides of five character heights)\n"
16490 " around most graphs for axis labels and a title. When these defaults\n"
16491 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16492 " plvasp for setting up the viewport, plwind for defining the window,\n"
16493 " and plbox for drawing the box.\n"
16494 "\n"
16495 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16496 "\n"
16497 " This function is used in example 21.\n"
16498 "\n"
16499 "\n"
16500 "\n"
16501 "SYNOPSIS:\n"
16502 "\n"
16503 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16504 "\n"
16505 "ARGUMENTS:\n"
16506 "\n"
16507 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16508 " world coordinates).\n"
16509 "\n"
16510 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16511 " world coordinates).\n"
16512 "\n"
16513 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16514 " coordinates).\n"
16515 "\n"
16516 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16517 " coordinates).\n"
16518 "\n"
16519 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16520 " scales will not be set, the user must set up the scale before\n"
16521 " calling plenv0 using plsvpa, plvasp or other.\n"
16522 " 0: the x and y axes are scaled independently to use as much of\n"
16523 " the screen as possible.\n"
16524 " 1: the scales of the x and y axes are made equal.\n"
16525 " 2: the axis of the x and y axes are made equal, and the plot\n"
16526 " box will be square.\n"
16527 "\n"
16528 "\n"
16529 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16530 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16531 " -1: draw box only.\n"
16532 " 0: draw box, ticks, and numeric tick labels.\n"
16533 " 1: also draw coordinate axes at x=0 and y=0.\n"
16534 " 2: also draw a grid at major tick positions in both\n"
16535 " coordinates.\n"
16536 " 3: also draw a grid at minor tick positions in both\n"
16537 " coordinates.\n"
16538 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16539 " have to be converted to logarithms separately.)\n"
16540 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16541 " have to be converted to logarithms separately.)\n"
16542 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16543 " have to be converted to logarithms separately.)\n"
16544 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16545 " have to be converted to logarithms separately.)\n"
16546 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16547 " have to be converted to logarithms separately.)\n"
16548 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16549 " have to be converted to logarithms separately.)\n"
16550 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16551 " have to be converted to logarithms separately.)\n"
16552 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16553 " have to be converted to logarithms separately.)\n"
16554 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16555 " and y data have to be converted to logarithms separately.)\n"
16556 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16557 " and y data have to be converted to logarithms separately.)\n"
16558 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16559 " and y data have to be converted to logarithms separately.)\n"
16560 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16561 " and y data have to be converted to logarithms separately.)\n"
16562 " 40: same as 0 except date / time x labels.\n"
16563 " 41: same as 1 except date / time x labels.\n"
16564 " 42: same as 2 except date / time x labels.\n"
16565 " 43: same as 3 except date / time x labels.\n"
16566 " 50: same as 0 except date / time y labels.\n"
16567 " 51: same as 1 except date / time y labels.\n"
16568 " 52: same as 2 except date / time y labels.\n"
16569 " 53: same as 3 except date / time y labels.\n"
16570 " 60: same as 0 except date / time x and y labels.\n"
16571 " 61: same as 1 except date / time x and y labels.\n"
16572 " 62: same as 2 except date / time x and y labels.\n"
16573 " 63: same as 3 except date / time x and y labels.\n"
16574 " 70: same as 0 except custom x and y labels.\n"
16575 " 71: same as 1 except custom x and y labels.\n"
16576 " 72: same as 2 except custom x and y labels.\n"
16577 " 73: same as 3 except custom x and y labels.\n"
16578 "\n"
16579 ""},
16580 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16581 "Eject current page\n"
16582 "\n"
16583 "DESCRIPTION:\n"
16584 "\n"
16585 " Clears the graphics screen of an interactive device, or ejects a page\n"
16586 " on a plotter. See plbop for more information.\n"
16587 "\n"
16588 " Redacted form: pleop()\n"
16589 "\n"
16590 " This function is used in example 2,14.\n"
16591 "\n"
16592 "\n"
16593 "\n"
16594 "SYNOPSIS:\n"
16595 "\n"
16596 "pleop()\n"
16597 "\n"
16598 ""},
16599 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16600 "Draw error bars in x direction\n"
16601 "\n"
16602 "DESCRIPTION:\n"
16603 "\n"
16604 " Draws a set of n error bars in x direction, the i'th error bar\n"
16605 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16606 " of the error bars are of length equal to the minor tick length\n"
16607 " (settable using plsmin).\n"
16608 "\n"
16609 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16610 "\n"
16611 "\n"
16612 " This function is used in example 29.\n"
16613 "\n"
16614 "\n"
16615 "\n"
16616 "SYNOPSIS:\n"
16617 "\n"
16618 "plerrx(n, xmin, xmax, y)\n"
16619 "\n"
16620 "ARGUMENTS:\n"
16621 "\n"
16622 " n (PLINT, input) : Number of error bars to draw.\n"
16623 "\n"
16624 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16625 " of the left-hand endpoints of the error bars.\n"
16626 "\n"
16627 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16628 " of the right-hand endpoints of the error bars.\n"
16629 "\n"
16630 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16631 " the error bars.\n"
16632 "\n"
16633 ""},
16634 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16635 "Draw error bars in the y direction\n"
16636 "\n"
16637 "DESCRIPTION:\n"
16638 "\n"
16639 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16640 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16641 " of the error bars are of length equal to the minor tick length\n"
16642 " (settable using plsmin).\n"
16643 "\n"
16644 " Redacted form: General: plerry(x, ymin, ymax)\n"
16645 "\n"
16646 "\n"
16647 " This function is used in example 29.\n"
16648 "\n"
16649 "\n"
16650 "\n"
16651 "SYNOPSIS:\n"
16652 "\n"
16653 "plerry(n, x, ymin, ymax)\n"
16654 "\n"
16655 "ARGUMENTS:\n"
16656 "\n"
16657 " n (PLINT, input) : Number of error bars to draw.\n"
16658 "\n"
16659 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16660 " the error bars.\n"
16661 "\n"
16662 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16663 " of the lower endpoints of the error bars.\n"
16664 "\n"
16665 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16666 " of the upper endpoints of the error bars.\n"
16667 "\n"
16668 ""},
16669 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16670 "Advance to the next family file on the next new page\n"
16671 "\n"
16672 "DESCRIPTION:\n"
16673 "\n"
16674 " Advance to the next family file on the next new page.\n"
16675 "\n"
16676 " Redacted form: plfamadv()\n"
16677 "\n"
16678 " This function is not used in any examples.\n"
16679 "\n"
16680 "\n"
16681 "\n"
16682 "SYNOPSIS:\n"
16683 "\n"
16684 "plfamadv()\n"
16685 "\n"
16686 ""},
16687 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16688 "Draw filled polygon\n"
16689 "\n"
16690 "DESCRIPTION:\n"
16691 "\n"
16692 " Fills the polygon defined by the n points (\n"
16693 " x[i],\n"
16694 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16695 " style is a solid fill. The routine will automatically close the\n"
16696 " polygon between the last and first vertices. If multiple closed\n"
16697 " polygons are passed in x and y then plfill will fill in between them.\n"
16698 "\n"
16699 " Redacted form: plfill(x,y)\n"
16700 "\n"
16701 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16702 "\n"
16703 "\n"
16704 "\n"
16705 "SYNOPSIS:\n"
16706 "\n"
16707 "plfill(n, x, y)\n"
16708 "\n"
16709 "ARGUMENTS:\n"
16710 "\n"
16711 " n (PLINT, input) : Number of vertices in polygon.\n"
16712 "\n"
16713 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16714 " vertices.\n"
16715 "\n"
16716 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16717 " vertices.\n"
16718 "\n"
16719 ""},
16720 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16721 "Draw filled polygon in 3D\n"
16722 "\n"
16723 "DESCRIPTION:\n"
16724 "\n"
16725 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16726 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16727 " will automatically close the polygon between the last and first\n"
16728 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16729 " plfill3 will fill in between them.\n"
16730 "\n"
16731 " Redacted form: General: plfill3(x, y, z)\n"
16732 "\n"
16733 "\n"
16734 " This function is used in example 15.\n"
16735 "\n"
16736 "\n"
16737 "\n"
16738 "SYNOPSIS:\n"
16739 "\n"
16740 "plfill3(n, x, y, z)\n"
16741 "\n"
16742 "ARGUMENTS:\n"
16743 "\n"
16744 " n (PLINT, input) : Number of vertices in polygon.\n"
16745 "\n"
16746 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16747 " vertices.\n"
16748 "\n"
16749 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16750 " vertices.\n"
16751 "\n"
16752 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16753 " vertices.\n"
16754 "\n"
16755 ""},
16756 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16757 "Draw linear gradient inside polygon\n"
16758 "\n"
16759 "DESCRIPTION:\n"
16760 "\n"
16761 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16762 " points (\n"
16763 " x[i],\n"
16764 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16765 " polygon coordinates and the gradient angle are all expressed in world\n"
16766 " coordinates. The angle from the x axis for both the rotated\n"
16767 " coordinate system and the gradient vector is specified by angle. The\n"
16768 " magnitude of the gradient vector is the difference between the maximum\n"
16769 " and minimum values of x for the vertices in the rotated coordinate\n"
16770 " system. The origin of the gradient vector can be interpreted as being\n"
16771 " anywhere on the line corresponding to the minimum x value for the\n"
16772 " vertices in the rotated coordinate system. The distance along the\n"
16773 " gradient vector is linearly transformed to the independent variable of\n"
16774 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16775 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16776 " color corresponding to the independent variable of cmap1. For more\n"
16777 " information about cmap1 (see the PLplot documentation).\n"
16778 "\n"
16779 " Redacted form: plgradient(x,y,angle)\n"
16780 "\n"
16781 " This function is used in examples 25 and 30.\n"
16782 "\n"
16783 "\n"
16784 "\n"
16785 "SYNOPSIS:\n"
16786 "\n"
16787 "plgradient(n, x, y, angle)\n"
16788 "\n"
16789 "ARGUMENTS:\n"
16790 "\n"
16791 " n (PLINT, input) : Number of vertices in polygon.\n"
16792 "\n"
16793 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16794 " vertices.\n"
16795 "\n"
16796 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16797 " vertices.\n"
16798 "\n"
16799 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16800 " axis.\n"
16801 "\n"
16802 ""},
16803 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16804 "Flushes the output stream\n"
16805 "\n"
16806 "DESCRIPTION:\n"
16807 "\n"
16808 " Flushes the output stream. Use sparingly, if at all.\n"
16809 "\n"
16810 " Redacted form: plflush()\n"
16811 "\n"
16812 " This function is used in examples 1 and 14.\n"
16813 "\n"
16814 "\n"
16815 "\n"
16816 "SYNOPSIS:\n"
16817 "\n"
16818 "plflush()\n"
16819 "\n"
16820 ""},
16821 { "plfont", _wrap_plfont, METH_O, "\n"
16822 "Set font\n"
16823 "\n"
16824 "DESCRIPTION:\n"
16825 "\n"
16826 " Sets the font used for subsequent text and symbols. For devices that\n"
16827 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16828 " fonts with extended character set are loaded (see plfontld). For\n"
16829 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16830 " this routine calls the plsfci routine with argument set up\n"
16831 " appropriately for the various cases below. However, this method of\n"
16832 " specifying the font for unicode-aware devices is deprecated, and the\n"
16833 " much more flexible method of calling plsfont directly is recommended\n"
16834 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16835 "\n"
16836 " Redacted form: plfont(ifont)\n"
16837 "\n"
16838 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16839 "\n"
16840 "\n"
16841 "\n"
16842 "SYNOPSIS:\n"
16843 "\n"
16844 "plfont(ifont)\n"
16845 "\n"
16846 "ARGUMENTS:\n"
16847 "\n"
16848 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16849 " (simplest and fastest)\n"
16850 " 2: Serif font\n"
16851 " 3: Italic font\n"
16852 " 4: Script font\n"
16853 "\n"
16854 ""},
16855 { "plfontld", _wrap_plfontld, METH_O, "\n"
16856 "Load Hershey fonts\n"
16857 "\n"
16858 "DESCRIPTION:\n"
16859 "\n"
16860 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16861 " be called before or after initializing PLplot. If not explicitly\n"
16862 " called before PLplot initialization, then by default that\n"
16863 " initialization loads Hershey fonts with the extended character set.\n"
16864 " This routine only has a practical effect for devices that still use\n"
16865 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16866 " system fonts instead of Hershey fonts).\n"
16867 "\n"
16868 " Redacted form: plfontld(fnt)\n"
16869 "\n"
16870 " This function is used in examples 1 and 7.\n"
16871 "\n"
16872 "\n"
16873 "\n"
16874 "SYNOPSIS:\n"
16875 "\n"
16876 "plfontld(fnt)\n"
16877 "\n"
16878 "ARGUMENTS:\n"
16879 "\n"
16880 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16881 " A zero value specifies Hershey fonts with the standard character\n"
16882 " set and a non-zero value (the default assumed if plfontld is never\n"
16883 " called) specifies Hershey fonts with the extended character set.\n"
16884 "\n"
16885 ""},
16886 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16887 "Get character default height and current (scaled) height\n"
16888 "\n"
16889 "DESCRIPTION:\n"
16890 "\n"
16891 " Get character default height and current (scaled) height.\n"
16892 "\n"
16893 " Redacted form: plgchr(p_def, p_ht)\n"
16894 "\n"
16895 " This function is used in example 23.\n"
16896 "\n"
16897 "\n"
16898 "\n"
16899 "SYNOPSIS:\n"
16900 "\n"
16901 "plgchr(p_def, p_ht)\n"
16902 "\n"
16903 "ARGUMENTS:\n"
16904 "\n"
16905 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16906 " character height (mm).\n"
16907 "\n"
16908 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16909 " character height (mm).\n"
16910 "\n"
16911 ""},
16912 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16913 "Returns 8-bit RGB values for given color index from cmap0\n"
16914 "\n"
16915 "DESCRIPTION:\n"
16916 "\n"
16917 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16918 " PLplot documentation). Values are negative if an invalid color id is\n"
16919 " given.\n"
16920 "\n"
16921 " Redacted form: plgcol0(icol0, r, g, b)\n"
16922 "\n"
16923 " This function is used in example 2.\n"
16924 "\n"
16925 "\n"
16926 "\n"
16927 "SYNOPSIS:\n"
16928 "\n"
16929 "plgcol0(icol0, r, g, b)\n"
16930 "\n"
16931 "ARGUMENTS:\n"
16932 "\n"
16933 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16934 "\n"
16935 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16936 " value.\n"
16937 "\n"
16938 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16939 " value.\n"
16940 "\n"
16941 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16942 " value.\n"
16943 "\n"
16944 ""},
16945 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16946 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16947 "\n"
16948 "DESCRIPTION:\n"
16949 "\n"
16950 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16951 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16952 " Values are negative if an invalid color id is given.\n"
16953 "\n"
16954 " Redacted form: plgcola(r, g, b)\n"
16955 "\n"
16956 " This function is used in example 30.\n"
16957 "\n"
16958 "\n"
16959 "\n"
16960 "SYNOPSIS:\n"
16961 "\n"
16962 "plgcol0a(icol0, r, g, b, alpha)\n"
16963 "\n"
16964 "ARGUMENTS:\n"
16965 "\n"
16966 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16967 "\n"
16968 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16969 " in the range from 0 to 255.\n"
16970 "\n"
16971 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16972 " in the range from 0 to 255.\n"
16973 "\n"
16974 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16975 " in the range from 0 to 255.\n"
16976 "\n"
16977 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16978 " transparency in the range from (0.0-1.0).\n"
16979 "\n"
16980 ""},
16981 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16982 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16983 "\n"
16984 "DESCRIPTION:\n"
16985 "\n"
16986 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16987 "\n"
16988 " Redacted form: plgcolbg(r, g, b)\n"
16989 "\n"
16990 " This function is used in example 31.\n"
16991 "\n"
16992 "\n"
16993 "\n"
16994 "SYNOPSIS:\n"
16995 "\n"
16996 "plgcolbg(r, g, b)\n"
16997 "\n"
16998 "ARGUMENTS:\n"
16999 "\n"
17000 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17001 " in the range from 0 to 255.\n"
17002 "\n"
17003 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17004 " in the range from 0 to 255.\n"
17005 "\n"
17006 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17007 " in the range from 0 to 255.\n"
17008 "\n"
17009 ""},
17010 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
17011 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
17012 "\n"
17013 "DESCRIPTION:\n"
17014 "\n"
17015 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17016 " alpha transparency value.\n"
17017 "\n"
17018 " This function is used in example 31.\n"
17019 "\n"
17020 "\n"
17021 "\n"
17022 "SYNOPSIS:\n"
17023 "\n"
17024 "plgcolbga(r, g, b, alpha)\n"
17025 "\n"
17026 "ARGUMENTS:\n"
17027 "\n"
17028 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17029 " in the range from 0 to 255.\n"
17030 "\n"
17031 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17032 " in the range from 0 to 255.\n"
17033 "\n"
17034 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17035 " in the range from 0 to 255.\n"
17036 "\n"
17037 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17038 " transparency in the range (0.0-1.0).\n"
17039 "\n"
17040 ""},
17041 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17042 "Get the current device-compression setting\n"
17043 "\n"
17044 "DESCRIPTION:\n"
17045 "\n"
17046 " Get the current device-compression setting. This parameter is only\n"
17047 " used for drivers that provide compression.\n"
17048 "\n"
17049 " Redacted form: plgcompression(compression)\n"
17050 "\n"
17051 " This function is used in example 31.\n"
17052 "\n"
17053 "\n"
17054 "\n"
17055 "SYNOPSIS:\n"
17056 "\n"
17057 "plgcompression(compression)\n"
17058 "\n"
17059 "ARGUMENTS:\n"
17060 "\n"
17061 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17062 " compression setting for the current device.\n"
17063 "\n"
17064 ""},
17065 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17066 "Get the current device (keyword) name\n"
17067 "\n"
17068 "DESCRIPTION:\n"
17069 "\n"
17070 " Get the current device (keyword) name. Note: you must have allocated\n"
17071 " space for this (80 characters is safe).\n"
17072 "\n"
17073 " Redacted form: plgdev(p_dev)\n"
17074 "\n"
17075 " This function is used in example 14.\n"
17076 "\n"
17077 "\n"
17078 "\n"
17079 "SYNOPSIS:\n"
17080 "\n"
17081 "plgdev(p_dev)\n"
17082 "\n"
17083 "ARGUMENTS:\n"
17084 "\n"
17085 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17086 " (with preallocated length of 80 characters or more) containing the\n"
17087 " device (keyword) name.\n"
17088 "\n"
17089 ""},
17090 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17091 "Get parameters that define current device-space window\n"
17092 "\n"
17093 "DESCRIPTION:\n"
17094 "\n"
17095 " Get relative margin width, aspect ratio, and relative justification\n"
17096 " that define current device-space window. If plsdidev has not been\n"
17097 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17098 " p_jy will all be 0.\n"
17099 "\n"
17100 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17101 "\n"
17102 " This function is used in example 31.\n"
17103 "\n"
17104 "\n"
17105 "\n"
17106 "SYNOPSIS:\n"
17107 "\n"
17108 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17109 "\n"
17110 "ARGUMENTS:\n"
17111 "\n"
17112 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17113 " margin width.\n"
17114 "\n"
17115 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17116 " ratio.\n"
17117 "\n"
17118 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17119 " justification in x.\n"
17120 "\n"
17121 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17122 " justification in y.\n"
17123 "\n"
17124 ""},
17125 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17126 "Get plot orientation\n"
17127 "\n"
17128 "DESCRIPTION:\n"
17129 "\n"
17130 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17131 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17132 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17133 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17134 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17135 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17136 " not been called the default value pointed to by p_rot will be 0.\n"
17137 "\n"
17138 " Redacted form: plgdiori(p_rot)\n"
17139 "\n"
17140 " This function is not used in any examples.\n"
17141 "\n"
17142 "\n"
17143 "\n"
17144 "SYNOPSIS:\n"
17145 "\n"
17146 "plgdiori(p_rot)\n"
17147 "\n"
17148 "ARGUMENTS:\n"
17149 "\n"
17150 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17151 " parameter.\n"
17152 "\n"
17153 ""},
17154 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17155 "Get parameters that define current plot-space window\n"
17156 "\n"
17157 "DESCRIPTION:\n"
17158 "\n"
17159 " Get relative minima and maxima that define current plot-space window.\n"
17160 " If plsdiplt has not been called the default values pointed to by\n"
17161 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17162 "\n"
17163 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17164 "\n"
17165 " This function is used in example 31.\n"
17166 "\n"
17167 "\n"
17168 "\n"
17169 "SYNOPSIS:\n"
17170 "\n"
17171 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17172 "\n"
17173 "ARGUMENTS:\n"
17174 "\n"
17175 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17176 " minimum in x.\n"
17177 "\n"
17178 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17179 " minimum in y.\n"
17180 "\n"
17181 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17182 " maximum in x.\n"
17183 "\n"
17184 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17185 " maximum in y.\n"
17186 "\n"
17187 ""},
17188 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17189 "Get family file parameters\n"
17190 "\n"
17191 "DESCRIPTION:\n"
17192 "\n"
17193 " Gets information about current family file, if familying is enabled.\n"
17194 " See the PLplot documentation for more information.\n"
17195 "\n"
17196 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17197 "\n"
17198 " This function is used in examples 14 and 31.\n"
17199 "\n"
17200 "\n"
17201 "\n"
17202 "SYNOPSIS:\n"
17203 "\n"
17204 "plgfam(p_fam, p_num, p_bmax)\n"
17205 "\n"
17206 "ARGUMENTS:\n"
17207 "\n"
17208 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17209 " family flag value. If nonzero, familying is enabled for the\n"
17210 " current device.\n"
17211 "\n"
17212 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17213 " family file number.\n"
17214 "\n"
17215 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17216 " file size (in bytes) for a family file.\n"
17217 "\n"
17218 ""},
17219 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17220 "Get FCI (font characterization integer)\n"
17221 "\n"
17222 "DESCRIPTION:\n"
17223 "\n"
17224 " Gets information about the current font using the FCI approach. See\n"
17225 " the PLplot documentation for more information.\n"
17226 "\n"
17227 " Redacted form: plgfci(p_fci)\n"
17228 "\n"
17229 " This function is used in example 23.\n"
17230 "\n"
17231 "\n"
17232 "\n"
17233 "SYNOPSIS:\n"
17234 "\n"
17235 "plgfci(p_fci)\n"
17236 "\n"
17237 "ARGUMENTS:\n"
17238 "\n"
17239 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17240 " FCI value.\n"
17241 "\n"
17242 ""},
17243 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17244 "Get output file name\n"
17245 "\n"
17246 "DESCRIPTION:\n"
17247 "\n"
17248 " Gets the current output file name, if applicable.\n"
17249 "\n"
17250 " Redacted form: plgfnam(fnam)\n"
17251 "\n"
17252 " This function is used in example 31.\n"
17253 "\n"
17254 "\n"
17255 "\n"
17256 "SYNOPSIS:\n"
17257 "\n"
17258 "plgfnam(fnam)\n"
17259 "\n"
17260 "ARGUMENTS:\n"
17261 "\n"
17262 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17263 " (with preallocated length of 80 characters or more) containing the\n"
17264 " file name.\n"
17265 "\n"
17266 ""},
17267 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17268 "Get family, style and weight of the current font\n"
17269 "\n"
17270 "DESCRIPTION:\n"
17271 "\n"
17272 " Gets information about current font. See the PLplot documentation for\n"
17273 " more information on font selection.\n"
17274 "\n"
17275 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17276 "\n"
17277 " This function is used in example 23.\n"
17278 "\n"
17279 "\n"
17280 "\n"
17281 "SYNOPSIS:\n"
17282 "\n"
17283 "plgfont(p_family, p_style, p_weight)\n"
17284 "\n"
17285 "ARGUMENTS:\n"
17286 "\n"
17287 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17288 " font family. The available values are given by the PL_FCI_*\n"
17289 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17290 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17291 " p_family is NULL then the font family is not returned.\n"
17292 "\n"
17293 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17294 " font style. The available values are given by the PL_FCI_*\n"
17295 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17296 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17297 " style is not returned.\n"
17298 "\n"
17299 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17300 " font weight. The available values are given by the PL_FCI_*\n"
17301 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17302 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17303 " returned.\n"
17304 "\n"
17305 ""},
17306 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17307 "Get the (current) run level\n"
17308 "\n"
17309 "DESCRIPTION:\n"
17310 "\n"
17311 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17312 " 1, initialized\n"
17313 " 2, viewport defined\n"
17314 " 3, world coordinates defined\n"
17315 "\n"
17316 "\n"
17317 " Redacted form: plglevel(p_level)\n"
17318 "\n"
17319 " This function is used in example 31.\n"
17320 "\n"
17321 "\n"
17322 "\n"
17323 "SYNOPSIS:\n"
17324 "\n"
17325 "plglevel(p_level)\n"
17326 "\n"
17327 "ARGUMENTS:\n"
17328 "\n"
17329 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17330 " level.\n"
17331 "\n"
17332 ""},
17333 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17334 "Get page parameters\n"
17335 "\n"
17336 "DESCRIPTION:\n"
17337 "\n"
17338 " Gets the current page configuration. The length and offset values are\n"
17339 " expressed in units that are specific to the current driver. For\n"
17340 " instance: screen drivers will usually interpret them as number of\n"
17341 " pixels, whereas printer drivers will usually use mm.\n"
17342 "\n"
17343 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17344 "\n"
17345 " This function is used in examples 14 and 31.\n"
17346 "\n"
17347 "\n"
17348 "\n"
17349 "SYNOPSIS:\n"
17350 "\n"
17351 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17352 "\n"
17353 "ARGUMENTS:\n"
17354 "\n"
17355 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17356 " pixels/inch (DPI) in x.\n"
17357 "\n"
17358 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17359 " pixels/inch (DPI) in y.\n"
17360 "\n"
17361 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17362 " length.\n"
17363 "\n"
17364 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17365 " length.\n"
17366 "\n"
17367 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17368 " offset.\n"
17369 "\n"
17370 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17371 " offset.\n"
17372 "\n"
17373 ""},
17374 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17375 "Switch to graphics screen\n"
17376 "\n"
17377 "DESCRIPTION:\n"
17378 "\n"
17379 " Sets an interactive device to graphics mode, used in conjunction with\n"
17380 " pltext to allow graphics and text to be interspersed. On a device\n"
17381 " which supports separate text and graphics windows, this command causes\n"
17382 " control to be switched to the graphics window. If already in graphics\n"
17383 " mode, this command is ignored. It is also ignored on devices which\n"
17384 " only support a single window or use a different method for shifting\n"
17385 " focus. See also pltext.\n"
17386 "\n"
17387 " Redacted form: plgra()\n"
17388 "\n"
17389 " This function is used in example 1.\n"
17390 "\n"
17391 "\n"
17392 "\n"
17393 "SYNOPSIS:\n"
17394 "\n"
17395 "plgra()\n"
17396 "\n"
17397 ""},
17398 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17399 "Grid data from irregularly sampled data\n"
17400 "\n"
17401 "DESCRIPTION:\n"
17402 "\n"
17403 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17404 " require data organized as a grid, i.e., with x sample point values\n"
17405 " independent of y coordinate and vice versa. This function takes\n"
17406 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17407 " vectors; reads the desired grid location from the input vectors\n"
17408 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17409 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17410 " interpolate the data to the grid is specified with the argument type\n"
17411 " which can have one parameter specified in argument data.\n"
17412 "\n"
17413 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17414 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17415 "\n"
17416 "\n"
17417 " This function is used in example 21.\n"
17418 "\n"
17419 "\n"
17420 "\n"
17421 "SYNOPSIS:\n"
17422 "\n"
17423 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17424 "\n"
17425 "ARGUMENTS:\n"
17426 "\n"
17427 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17428 "\n"
17429 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17430 "\n"
17431 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17432 " y[i], z[i] represents one data sample coordinate.\n"
17433 "\n"
17434 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17435 " vectors.\n"
17436 "\n"
17437 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17438 " in the x direction. Usually xg has nptsx equally spaced values\n"
17439 " from the minimum to the maximum values of the x input vector.\n"
17440 "\n"
17441 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17442 "\n"
17443 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17444 " in the y direction. Similar to the xg parameter.\n"
17445 "\n"
17446 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17447 "\n"
17448 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17449 " where data lies in the grid specified by xg and yg. Therefore the\n"
17450 " zg matrix must be dimensioned\n"
17451 " nptsx by\n"
17452 " nptsy.\n"
17453 "\n"
17454 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17455 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17456 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17457 " GRID_NNI: Natural Neighbors Interpolation\n"
17458 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17459 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17460 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17461 " Weighted\n"
17462 " For details of the algorithms read the source file plgridd.c.\n"
17463 "\n"
17464 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17465 " which can be specified through this argument. Currently, for\n"
17466 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17467 " use, the lower the value, the noisier (more local) the\n"
17468 " approximation is.\n"
17469 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17470 " range [1. .. 2.]. High values enable the usage of very thin\n"
17471 " triangles for interpolation, possibly resulting in error in\n"
17472 " the approximation.\n"
17473 " GRID_NNI, only weights greater than data will be accepted. If\n"
17474 " 0, all weights will be accepted.\n"
17475 "\n"
17476 ""},
17477 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17478 "Get current subpage parameters\n"
17479 "\n"
17480 "DESCRIPTION:\n"
17481 "\n"
17482 " Gets the size of the current subpage in millimeters measured from the\n"
17483 " bottom left hand corner of the output device page or screen. Can be\n"
17484 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17485 " absolute coordinates (millimeters).\n"
17486 "\n"
17487 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17488 "\n"
17489 " This function is used in example 23.\n"
17490 "\n"
17491 "\n"
17492 "\n"
17493 "SYNOPSIS:\n"
17494 "\n"
17495 "plgspa(xmin, xmax, ymin, ymax)\n"
17496 "\n"
17497 "ARGUMENTS:\n"
17498 "\n"
17499 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17500 " the left hand edge of the subpage in millimeters.\n"
17501 "\n"
17502 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17503 " the right hand edge of the subpage in millimeters.\n"
17504 "\n"
17505 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17506 " the bottom edge of the subpage in millimeters.\n"
17507 "\n"
17508 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17509 " the top edge of the subpage in millimeters.\n"
17510 "\n"
17511 ""},
17512 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17513 "Get current stream number\n"
17514 "\n"
17515 "DESCRIPTION:\n"
17516 "\n"
17517 " Gets the number of the current output stream. See also plsstrm.\n"
17518 "\n"
17519 " Redacted form: plgstrm(p_strm)\n"
17520 "\n"
17521 " This function is used in example 1,20.\n"
17522 "\n"
17523 "\n"
17524 "\n"
17525 "SYNOPSIS:\n"
17526 "\n"
17527 "plgstrm(p_strm)\n"
17528 "\n"
17529 "ARGUMENTS:\n"
17530 "\n"
17531 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17532 " stream value.\n"
17533 "\n"
17534 ""},
17535 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17536 "Get the current library version number\n"
17537 "\n"
17538 "DESCRIPTION:\n"
17539 "\n"
17540 " Get the current library version number. Note: you must have allocated\n"
17541 " space for this (80 characters is safe).\n"
17542 "\n"
17543 " Redacted form: plgver(p_ver)\n"
17544 "\n"
17545 " This function is used in example 1.\n"
17546 "\n"
17547 "\n"
17548 "\n"
17549 "SYNOPSIS:\n"
17550 "\n"
17551 "plgver(p_ver)\n"
17552 "\n"
17553 "ARGUMENTS:\n"
17554 "\n"
17555 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17556 " (with preallocated length of 80 characters or more) containing the\n"
17557 " PLplot version number.\n"
17558 "\n"
17559 ""},
17560 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17561 "Get viewport limits in normalized device coordinates\n"
17562 "\n"
17563 "DESCRIPTION:\n"
17564 "\n"
17565 " Get viewport limits in normalized device coordinates.\n"
17566 "\n"
17567 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17568 "\n"
17569 "\n"
17570 " This function is used in example 31.\n"
17571 "\n"
17572 "\n"
17573 "\n"
17574 "SYNOPSIS:\n"
17575 "\n"
17576 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17577 "\n"
17578 "ARGUMENTS:\n"
17579 "\n"
17580 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17581 " viewport limit of the normalized device coordinate in x.\n"
17582 "\n"
17583 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17584 " viewport limit of the normalized device coordinate in x.\n"
17585 "\n"
17586 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17587 " viewport limit of the normalized device coordinate in y.\n"
17588 "\n"
17589 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17590 " viewport limit of the normalized device coordinate in y.\n"
17591 "\n"
17592 ""},
17593 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17594 "Get viewport limits in world coordinates\n"
17595 "\n"
17596 "DESCRIPTION:\n"
17597 "\n"
17598 " Get viewport limits in world coordinates.\n"
17599 "\n"
17600 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17601 "\n"
17602 "\n"
17603 " This function is used in example 31.\n"
17604 "\n"
17605 "\n"
17606 "\n"
17607 "SYNOPSIS:\n"
17608 "\n"
17609 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17610 "\n"
17611 "ARGUMENTS:\n"
17612 "\n"
17613 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17614 " viewport limit of the world coordinate in x.\n"
17615 "\n"
17616 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17617 " viewport limit of the world coordinate in x.\n"
17618 "\n"
17619 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17620 " viewport limit of the world coordinate in y.\n"
17621 "\n"
17622 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17623 " viewport limit of the world coordinate in y.\n"
17624 "\n"
17625 ""},
17626 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17627 "Get x axis parameters\n"
17628 "\n"
17629 "DESCRIPTION:\n"
17630 "\n"
17631 " Returns current values of the p_digmax and p_digits flags for the x\n"
17632 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17633 " should only be called after the call to plbox (or plbox3) is complete.\n"
17634 " See the PLplot documentation for more information.\n"
17635 "\n"
17636 " Redacted form: plgxax(p_digmax, p_digits)\n"
17637 "\n"
17638 " This function is used in example 31.\n"
17639 "\n"
17640 "\n"
17641 "\n"
17642 "SYNOPSIS:\n"
17643 "\n"
17644 "plgxax(p_digmax, p_digits)\n"
17645 "\n"
17646 "ARGUMENTS:\n"
17647 "\n"
17648 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17649 " number of digits for the x axis. If nonzero, the printed label\n"
17650 " has been switched to a floating-point representation when the\n"
17651 " number of digits exceeds this value.\n"
17652 "\n"
17653 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17654 " number of digits for the numeric labels (x axis) from the last\n"
17655 " plot.\n"
17656 "\n"
17657 ""},
17658 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17659 "Get y axis parameters\n"
17660 "\n"
17661 "DESCRIPTION:\n"
17662 "\n"
17663 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17664 " the description of plgxax for more detail.\n"
17665 "\n"
17666 " Redacted form: plgyax(p_digmax, p_digits)\n"
17667 "\n"
17668 " This function is used in example 31.\n"
17669 "\n"
17670 "\n"
17671 "\n"
17672 "SYNOPSIS:\n"
17673 "\n"
17674 "plgyax(p_digmax, p_digits)\n"
17675 "\n"
17676 "ARGUMENTS:\n"
17677 "\n"
17678 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17679 " number of digits for the y axis. If nonzero, the printed label\n"
17680 " has been switched to a floating-point representation when the\n"
17681 " number of digits exceeds this value.\n"
17682 "\n"
17683 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17684 " number of digits for the numeric labels (y axis) from the last\n"
17685 " plot.\n"
17686 "\n"
17687 ""},
17688 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17689 "Get z axis parameters\n"
17690 "\n"
17691 "DESCRIPTION:\n"
17692 "\n"
17693 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17694 " the description of plgxax for more detail.\n"
17695 "\n"
17696 " Redacted form: plgzax(p_digmax, p_digits)\n"
17697 "\n"
17698 " This function is used in example 31.\n"
17699 "\n"
17700 "\n"
17701 "\n"
17702 "SYNOPSIS:\n"
17703 "\n"
17704 "plgzax(p_digmax, p_digits)\n"
17705 "\n"
17706 "ARGUMENTS:\n"
17707 "\n"
17708 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17709 " number of digits for the z axis. If nonzero, the printed label\n"
17710 " has been switched to a floating-point representation when the\n"
17711 " number of digits exceeds this value.\n"
17712 "\n"
17713 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17714 " number of digits for the numeric labels (z axis) from the last\n"
17715 " plot.\n"
17716 "\n"
17717 ""},
17718 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17719 "Plot a histogram from unbinned data\n"
17720 "\n"
17721 "DESCRIPTION:\n"
17722 "\n"
17723 " Plots a histogram from n data points stored in the data vector. This\n"
17724 " routine bins the data into nbin bins equally spaced between datmin and\n"
17725 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17726 " opt allows, among other things, the histogram either to be plotted in\n"
17727 " an existing window or causes plhist to call plenv with suitable limits\n"
17728 " before plotting the histogram.\n"
17729 "\n"
17730 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17731 "\n"
17732 " This function is used in example 5.\n"
17733 "\n"
17734 "\n"
17735 "\n"
17736 "SYNOPSIS:\n"
17737 "\n"
17738 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17739 "\n"
17740 "ARGUMENTS:\n"
17741 "\n"
17742 " n (PLINT, input) : Number of data points.\n"
17743 "\n"
17744 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17745 " n data points.\n"
17746 "\n"
17747 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17748 "\n"
17749 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17750 "\n"
17751 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17752 " divide the interval xmin to xmax.\n"
17753 "\n"
17754 " opt (PLINT, input) : Is a combination of several flags:\n"
17755 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17756 " the histogram data, the outer bins are expanded to fill up the\n"
17757 " entire x-axis, data outside the given extremes are assigned to the\n"
17758 " outer bins and bins of zero height are simply drawn.\n"
17759 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17760 " to fit the histogram data, without this flag, plenv is called\n"
17761 " to set the world coordinates.\n"
17762 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17763 " extremes are not taken into account. This option should\n"
17764 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17765 " properly present the data.\n"
17766 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17767 " size as the ones inside.\n"
17768 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17769 " (there is a gap for such bins).\n"
17770 "\n"
17771 ""},
17772 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17773 "Convert HLS color to RGB\n"
17774 "\n"
17775 "DESCRIPTION:\n"
17776 "\n"
17777 " Convert HLS color coordinates to RGB.\n"
17778 "\n"
17779 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17780 "\n"
17781 "\n"
17782 " This function is used in example 2.\n"
17783 "\n"
17784 "\n"
17785 "\n"
17786 "SYNOPSIS:\n"
17787 "\n"
17788 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17789 "\n"
17790 "ARGUMENTS:\n"
17791 "\n"
17792 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17793 " cylinder.\n"
17794 "\n"
17795 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17796 " the axis of the color cylinder.\n"
17797 "\n"
17798 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17799 " the radius of the color cylinder.\n"
17800 "\n"
17801 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17802 " (0.0-1.0) of the color.\n"
17803 "\n"
17804 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17805 " intensity (0.0-1.0) of the color.\n"
17806 "\n"
17807 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17808 " intensity (0.0-1.0) of the color.\n"
17809 "\n"
17810 ""},
17811 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17812 "Initialize PLplot\n"
17813 "\n"
17814 "DESCRIPTION:\n"
17815 "\n"
17816 " Initializing the plotting package. The program prompts for the device\n"
17817 " keyword or number of the desired output device. Hitting a RETURN in\n"
17818 " response to the prompt is the same as selecting the first device.\n"
17819 " plinit will issue no prompt if either the device was specified\n"
17820 " previously (via command line flag, the plsetopt function, or the\n"
17821 " plsdev function), or if only one device is enabled when PLplot is\n"
17822 " installed. If subpages have been specified, the output device is\n"
17823 " divided into nx by ny subpages, each of which may be used\n"
17824 " independently. If plinit is called again during a program, the\n"
17825 " previously opened file will be closed. The subroutine pladv is used\n"
17826 " to advance from one subpage to the next.\n"
17827 "\n"
17828 " Redacted form: plinit()\n"
17829 "\n"
17830 " This function is used in all of the examples.\n"
17831 "\n"
17832 "\n"
17833 "\n"
17834 "SYNOPSIS:\n"
17835 "\n"
17836 "plinit()\n"
17837 "\n"
17838 ""},
17839 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17840 "Draw a line between two points\n"
17841 "\n"
17842 "DESCRIPTION:\n"
17843 "\n"
17844 " Joins the point (\n"
17845 " x1,\n"
17846 " y1) to (\n"
17847 " x2,\n"
17848 " y2).\n"
17849 "\n"
17850 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17851 "\n"
17852 " This function is used in examples 3 and 14.\n"
17853 "\n"
17854 "\n"
17855 "\n"
17856 "SYNOPSIS:\n"
17857 "\n"
17858 "pljoin(x1, y1, x2, y2)\n"
17859 "\n"
17860 "ARGUMENTS:\n"
17861 "\n"
17862 " x1 (PLFLT, input) : x coordinate of first point.\n"
17863 "\n"
17864 " y1 (PLFLT, input) : y coordinate of first point.\n"
17865 "\n"
17866 " x2 (PLFLT, input) : x coordinate of second point.\n"
17867 "\n"
17868 " y2 (PLFLT, input) : y coordinate of second point.\n"
17869 "\n"
17870 ""},
17871 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17872 "Simple routine to write labels\n"
17873 "\n"
17874 "DESCRIPTION:\n"
17875 "\n"
17876 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17877 "\n"
17878 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17879 "\n"
17880 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17881 "\n"
17882 "\n"
17883 "\n"
17884 "SYNOPSIS:\n"
17885 "\n"
17886 "pllab(xlabel, ylabel, tlabel)\n"
17887 "\n"
17888 "ARGUMENTS:\n"
17889 "\n"
17890 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17891 " the label for the x axis.\n"
17892 "\n"
17893 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17894 " the label for the y axis.\n"
17895 "\n"
17896 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17897 " the title of the plot.\n"
17898 "\n"
17899 ""},
17900 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17901 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17902 "\n"
17903 "DESCRIPTION:\n"
17904 "\n"
17905 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17906 " line, and/or line of symbols for each annotated legend entry. (See\n"
17907 " plcolorbar for similar functionality for creating continuous color\n"
17908 " bars.) The arguments of pllegend provide control over the location\n"
17909 " and size of the legend as well as the location and characteristics of\n"
17910 " the elements (most of which are optional) within that legend. The\n"
17911 " resulting legend is clipped at the boundaries of the current subpage.\n"
17912 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17913 " defined in the documentation of the position parameter.)\n"
17914 "\n"
17915 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17916 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17917 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17918 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17919 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17920 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17921 "\n"
17922 " This function is used in examples 4, 26, and 33.\n"
17923 "\n"
17924 "\n"
17925 "\n"
17926 "SYNOPSIS:\n"
17927 "\n"
17928 "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"
17929 "\n"
17930 "ARGUMENTS:\n"
17931 "\n"
17932 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17933 " legend width in adopted coordinates. This quantity is calculated\n"
17934 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17935 " the routine depending on nlegend and nrow), and the length\n"
17936 " (calculated internally) of the longest text string.\n"
17937 "\n"
17938 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17939 " legend height in adopted coordinates. This quantity is calculated\n"
17940 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17941 " the routine depending on nlegend and nrow).\n"
17942 "\n"
17943 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17944 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17945 " on the left of the legend and the plotted area on the right.\n"
17946 " Otherwise, put the text area on the right of the legend and the\n"
17947 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17948 " plot a (semitransparent) background for the legend. If the\n"
17949 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17950 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17951 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17952 " plot the resulting array of legend entries in row-major order.\n"
17953 " Otherwise, plot the legend entries in column-major order.\n"
17954 "\n"
17955 " position (PLINT, input) : position contains bits which control the\n"
17956 " overall position of the legend and the definition of the adopted\n"
17957 " coordinates used for positions just like what is done for the\n"
17958 " position argument for plcolorbar. However, note that the defaults\n"
17959 " for the position bits (see below) are different than the\n"
17960 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17961 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17962 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17963 " the 16 possible standard positions (the 4 corners and centers of\n"
17964 " the 4 sides for both the inside and outside cases) of the legend\n"
17965 " relative to the adopted coordinate system. The corner positions\n"
17966 " are specified by the appropriate combination of two of the\n"
17967 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17968 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17969 " value of one of those bits. The adopted coordinates are\n"
17970 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17971 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17972 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17973 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17974 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17975 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17976 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17977 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17978 "\n"
17979 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17980 " coordinates from the specified standard position of the legend.\n"
17981 " For positive x, the direction of motion away from the standard\n"
17982 " position is inward/outward from the standard corner positions or\n"
17983 " standard left or right positions if the\n"
17984 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17985 " For the standard top or bottom positions, the direction of motion\n"
17986 " is toward positive X.\n"
17987 "\n"
17988 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17989 " coordinates from the specified standard position of the legend.\n"
17990 " For positive y, the direction of motion away from the standard\n"
17991 " position is inward/outward from the standard corner positions or\n"
17992 " standard top or bottom positions if the\n"
17993 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17994 " the standard left or right positions, the direction of motion is\n"
17995 " toward positive Y.\n"
17996 "\n"
17997 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17998 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17999 " symbols are drawn) of the legend.\n"
18000 "\n"
18001 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18002 " legend (PL_LEGEND_BACKGROUND).\n"
18003 "\n"
18004 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18005 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
18006 "\n"
18007 " bb_style (PLINT, input) : The pllsty style number for the\n"
18008 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
18009 "\n"
18010 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
18011 " render the\n"
18012 " nlegend legend entries. For internal transformations of\n"
18013 " nrow, see further remarks under\n"
18014 " nlegend.\n"
18015 "\n"
18016 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18017 " to render the\n"
18018 " nlegend legend entries. For internal transformations of\n"
18019 " ncolumn, see further remarks under\n"
18020 " nlegend.\n"
18021 "\n"
18022 " nlegend (PLINT, input) : Number of legend entries. The above\n"
18023 " nrow and\n"
18024 " ncolumn values are transformed internally to be consistent with\n"
18025 " nlegend. If either\n"
18026 " nrow or\n"
18027 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18028 " of\n"
18029 " nrow and\n"
18030 " ncolumn is less than\n"
18031 " nlegend, the smaller of the two (or\n"
18032 " nrow, if\n"
18033 " nrow ==\n"
18034 " ncolumn) is increased so the product is >=\n"
18035 " nlegend. Thus, for example, the common\n"
18036 " nrow = 0,\n"
18037 " ncolumn = 0 case is transformed internally to\n"
18038 " nrow =\n"
18039 " nlegend,\n"
18040 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18041 " column.\n"
18042 "\n"
18043 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18044 " nlegend values of options to control each individual plotted area\n"
18045 " corresponding to a legend entry. If the\n"
18046 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18047 " area. If the\n"
18048 " PL_LEGEND_COLOR_BOX,\n"
18049 " PL_LEGEND_LINE, and/or\n"
18050 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18051 " entry is plotted with a colored box; a line; and/or a line of\n"
18052 " symbols.\n"
18053 "\n"
18054 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18055 " area in units of character width.\n"
18056 "\n"
18057 " text_scale (PLFLT, input) : Character height scale for text\n"
18058 " annotations.\n"
18059 "\n"
18060 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18061 " character height from one legend entry to the next.\n"
18062 "\n"
18063 " text_justification (PLFLT, input) : Justification parameter used\n"
18064 " for text justification. The most common values of\n"
18065 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18066 " is left justified, centred, or right justified within the text\n"
18067 " area, but other values are allowed as well.\n"
18068 "\n"
18069 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18070 " nlegend cmap0 text colors.\n"
18071 "\n"
18072 " text (PLCHAR_MATRIX, input) : A vector of\n"
18073 " nlegend UTF-8 character strings containing the legend annotations.\n"
18074 "\n"
18075 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18076 " nlegend cmap0 colors for the discrete colored boxes (\n"
18077 " PL_LEGEND_COLOR_BOX).\n"
18078 "\n"
18079 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18080 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18081 " PL_LEGEND_COLOR_BOX).\n"
18082 "\n"
18083 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18084 " nlegend scales (units of fraction of character height) for the height\n"
18085 " of the discrete colored boxes (\n"
18086 " PL_LEGEND_COLOR_BOX).\n"
18087 "\n"
18088 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18089 " nlegend line widths for the patterns specified by box_patterns (\n"
18090 " PL_LEGEND_COLOR_BOX).\n"
18091 "\n"
18092 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18093 " nlegend cmap0 line colors (\n"
18094 " PL_LEGEND_LINE).\n"
18095 "\n"
18096 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18097 " nlegend line styles (plsty indices) (\n"
18098 " PL_LEGEND_LINE).\n"
18099 "\n"
18100 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18101 " nlegend line widths (\n"
18102 " PL_LEGEND_LINE).\n"
18103 "\n"
18104 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18105 " nlegend cmap0 symbol colors (\n"
18106 " PL_LEGEND_SYMBOL).\n"
18107 "\n"
18108 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18109 " nlegend scale values for the symbol height (\n"
18110 " PL_LEGEND_SYMBOL).\n"
18111 "\n"
18112 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18113 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18114 " area (\n"
18115 " PL_LEGEND_SYMBOL).\n"
18116 "\n"
18117 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18118 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18119 " PL_LEGEND_SYMBOL).\n"
18120 "\n"
18121 ""},
18122 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18123 "Plot color bar for image, shade or gradient plots\n"
18124 "\n"
18125 "DESCRIPTION:\n"
18126 "\n"
18127 " Routine for creating a continuous color bar for image, shade, or\n"
18128 " gradient plots. (See pllegend for similar functionality for creating\n"
18129 " legends with discrete elements). The arguments of plcolorbar provide\n"
18130 " control over the location and size of the color bar as well as the\n"
18131 " location and characteristics of the elements (most of which are\n"
18132 " optional) within that color bar. The resulting color bar is clipped\n"
18133 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18134 " system used for some of the parameters is defined in the documentation\n"
18135 " of the position parameter.)\n"
18136 "\n"
18137 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18138 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18139 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18140 " labels, axis_opts, ticks, sub_ticks, values)\n"
18141 "\n"
18142 " This function is used in examples 16 and 33.\n"
18143 "\n"
18144 "\n"
18145 "\n"
18146 "SYNOPSIS:\n"
18147 "\n"
18148 "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"
18149 "\n"
18150 "ARGUMENTS:\n"
18151 "\n"
18152 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18153 " labelled and decorated color bar width in adopted coordinates.\n"
18154 "\n"
18155 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18156 " labelled and decorated color bar height in adopted coordinates.\n"
18157 "\n"
18158 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18159 " color bar. The orientation (direction of the maximum value) of\n"
18160 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18161 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18162 " specified, the default orientation is toward the top if the\n"
18163 " colorbar is placed on the left or right of the viewport or toward\n"
18164 " the right if the colorbar is placed on the top or bottom of the\n"
18165 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18166 " (semitransparent) background for the color bar. If the\n"
18167 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18168 " color bar. The type of color bar must be specified with one of\n"
18169 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18170 " more than one of those bits is set only the first one in the above\n"
18171 " list is honored. The position of the (optional) label/title can be\n"
18172 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18173 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18174 " will be drawn. If more than one of this list of bits is specified,\n"
18175 " only the first one on the list is honored. End-caps for the color\n"
18176 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18177 " If a particular color bar cap option is not specified then no cap\n"
18178 " will be drawn for that end. As a special case for\n"
18179 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18180 " specified. If this option is provided then any tick marks and tick\n"
18181 " labels will be placed at the breaks between shaded segments. TODO:\n"
18182 " This should be expanded to support custom placement of tick marks\n"
18183 " and tick labels at custom value locations for any color bar type.\n"
18184 "\n"
18185 " position (PLINT, input) : position contains bits which control the\n"
18186 " overall position of the color bar and the definition of the\n"
18187 " adopted coordinates used for positions just like what is done for\n"
18188 " the position argument for pllegend. However, note that the\n"
18189 " defaults for the position bits (see below) are different than the\n"
18190 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18191 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18192 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18193 " the 16 possible standard positions (the 4 corners and centers of\n"
18194 " the 4 sides for both the inside and outside cases) of the color\n"
18195 " bar relative to the adopted coordinate system. The corner\n"
18196 " positions are specified by the appropriate combination of two of\n"
18197 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18198 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18199 " value of one of those bits. The adopted coordinates are\n"
18200 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18201 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18202 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18203 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18204 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18205 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18206 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18207 " PL_POSITION_VIEWPORT.\n"
18208 "\n"
18209 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18210 " coordinates from the specified standard position of the color bar.\n"
18211 " For positive x, the direction of motion away from the standard\n"
18212 " position is inward/outward from the standard corner positions or\n"
18213 " standard left or right positions if the\n"
18214 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18215 " For the standard top or bottom positions, the direction of motion\n"
18216 " is toward positive X.\n"
18217 "\n"
18218 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18219 " coordinates from the specified standard position of the color bar.\n"
18220 " For positive y, the direction of motion away from the standard\n"
18221 " position is inward/outward from the standard corner positions or\n"
18222 " standard top or bottom positions if the\n"
18223 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18224 " For the standard left or right positions, the direction of motion\n"
18225 " is toward positive Y.\n"
18226 "\n"
18227 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18228 " the X direction in adopted coordinates.\n"
18229 "\n"
18230 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18231 " the Y direction in adopted coordinates.\n"
18232 "\n"
18233 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18234 " color bar (PL_COLORBAR_BACKGROUND).\n"
18235 "\n"
18236 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18237 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18238 "\n"
18239 " bb_style (PLINT, input) : The pllsty style number for the\n"
18240 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18241 "\n"
18242 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18243 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18244 "\n"
18245 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18246 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18247 "\n"
18248 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18249 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18250 " it will be interpreted according to the design of plshades.\n"
18251 "\n"
18252 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18253 " plots. This is passed directly to plshades, so it will be\n"
18254 " interpreted according to the design of plshades.\n"
18255 "\n"
18256 " n_labels (PLINT, input) : Number of labels to place around the\n"
18257 " color bar.\n"
18258 "\n"
18259 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18260 " n_labels labels.\n"
18261 "\n"
18262 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18263 " n_labels UTF-8 character strings containing the labels for the color\n"
18264 " bar. Ignored if no label position is specified with one of the\n"
18265 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18266 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18267 " corresponding label_opts field.\n"
18268 "\n"
18269 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18270 " value must be greater than 0. It is typically 1 (numerical axis\n"
18271 " labels are provided for one of the long edges of the color bar),\n"
18272 " but it can be larger if multiple numerical axis labels for the\n"
18273 " long edges of the color bar are desired.\n"
18274 "\n"
18275 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18276 " n_axes ascii character strings containing options (interpreted as for\n"
18277 " plbox) for the color bar's axis definitions.\n"
18278 "\n"
18279 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18280 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18281 " color bar's axis definitions.\n"
18282 "\n"
18283 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18284 " number of subticks (interpreted as for plbox) for the color bar's\n"
18285 " axis definitions.\n"
18286 "\n"
18287 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18288 " elements in each of the n_axes rows of the values matrix.\n"
18289 "\n"
18290 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18291 " values for the data range represented by the color bar. For a row\n"
18292 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18293 " elements in the row is specified by n_values[i_axis]. For\n"
18294 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18295 " is 2, and the corresponding row elements of the values matrix are\n"
18296 " the minimum and maximum value represented by the colorbar. For\n"
18297 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18298 " of the values matrix is interpreted the same as the nlevel and\n"
18299 " clevel arguments of plshades.\n"
18300 "\n"
18301 ""},
18302 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18303 "Sets the 3D position of the light source\n"
18304 "\n"
18305 "DESCRIPTION:\n"
18306 "\n"
18307 " Sets the 3D position of the light source for use with plsurf3d and\n"
18308 " plsurf3dl\n"
18309 "\n"
18310 " Redacted form: pllightsource(x, y, z)\n"
18311 "\n"
18312 " This function is used in example 8.\n"
18313 "\n"
18314 "\n"
18315 "\n"
18316 "SYNOPSIS:\n"
18317 "\n"
18318 "pllightsource(x, y, z)\n"
18319 "\n"
18320 "ARGUMENTS:\n"
18321 "\n"
18322 " x (PLFLT, input) : X-coordinate of the light source.\n"
18323 "\n"
18324 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18325 "\n"
18326 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18327 "\n"
18328 ""},
18329 { "plline", _wrap_plline, METH_VARARGS, "\n"
18330 "Draw a line\n"
18331 "\n"
18332 "DESCRIPTION:\n"
18333 "\n"
18334 " Draws line defined by n points in x and y.\n"
18335 "\n"
18336 " Redacted form: plline(x, y)\n"
18337 "\n"
18338 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18339 " 25-27, and 29.\n"
18340 "\n"
18341 "\n"
18342 "\n"
18343 "SYNOPSIS:\n"
18344 "\n"
18345 "plline(n, x, y)\n"
18346 "\n"
18347 "ARGUMENTS:\n"
18348 "\n"
18349 " n (PLINT, input) : Number of points defining line.\n"
18350 "\n"
18351 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18352 " points.\n"
18353 "\n"
18354 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18355 " points.\n"
18356 "\n"
18357 ""},
18358 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18359 "Draw a line in 3 space\n"
18360 "\n"
18361 "DESCRIPTION:\n"
18362 "\n"
18363 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18364 " first set up the viewport, the 2d viewing window (in world\n"
18365 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18366 " more info.\n"
18367 "\n"
18368 " Redacted form: plline3(x, y, z)\n"
18369 "\n"
18370 " This function is used in example 18.\n"
18371 "\n"
18372 "\n"
18373 "\n"
18374 "SYNOPSIS:\n"
18375 "\n"
18376 "plline3(n, x, y, z)\n"
18377 "\n"
18378 "ARGUMENTS:\n"
18379 "\n"
18380 " n (PLINT, input) : Number of points defining line.\n"
18381 "\n"
18382 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18383 " points.\n"
18384 "\n"
18385 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18386 " points.\n"
18387 "\n"
18388 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18389 " points.\n"
18390 "\n"
18391 ""},
18392 { "pllsty", _wrap_pllsty, METH_O, "\n"
18393 "Select line style\n"
18394 "\n"
18395 "DESCRIPTION:\n"
18396 "\n"
18397 " This sets the line style according to one of eight predefined patterns\n"
18398 " (also see plstyl).\n"
18399 "\n"
18400 " Redacted form: pllsty(lin)\n"
18401 "\n"
18402 " This function is used in examples 9, 12, 22, and 25.\n"
18403 "\n"
18404 "\n"
18405 "\n"
18406 "SYNOPSIS:\n"
18407 "\n"
18408 "pllsty(lin)\n"
18409 "\n"
18410 "ARGUMENTS:\n"
18411 "\n"
18412 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18413 " a continuous line, line style 2 is a line with short dashes and\n"
18414 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18415 " 4 has long dashes and short gaps and so on.\n"
18416 "\n"
18417 ""},
18418 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18419 "Plot surface mesh\n"
18420 "\n"
18421 "DESCRIPTION:\n"
18422 "\n"
18423 " Plots a surface mesh within the environment set up by plw3d. The\n"
18424 " surface is defined by the matrix z[\n"
18425 " nx][\n"
18426 " ny] , the point z[i][j] being the value of the function at (\n"
18427 " x[i],\n"
18428 " y[j]). Note that the points in vectors x and y do not need to be\n"
18429 " equally spaced, but must be stored in ascending order. The parameter\n"
18430 " opt controls the way in which the surface is displayed. For further\n"
18431 " details see the PLplot documentation.\n"
18432 "\n"
18433 " Redacted form: plmesh(x, y, z, opt)\n"
18434 "\n"
18435 " This function is used in example 11.\n"
18436 "\n"
18437 "\n"
18438 "\n"
18439 "SYNOPSIS:\n"
18440 "\n"
18441 "plmesh(x, y, z, nx, ny, opt)\n"
18442 "\n"
18443 "ARGUMENTS:\n"
18444 "\n"
18445 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18446 " which the function is evaluated.\n"
18447 "\n"
18448 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18449 " which the function is evaluated.\n"
18450 "\n"
18451 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18452 " plot. Should have dimensions of\n"
18453 " nx by\n"
18454 " ny.\n"
18455 "\n"
18456 " nx (PLINT, input) : Number of x values at which function has been\n"
18457 " evaluated.\n"
18458 "\n"
18459 " ny (PLINT, input) : Number of y values at which function has been\n"
18460 " evaluated.\n"
18461 "\n"
18462 " opt (PLINT, input) : Determines the way in which the surface is\n"
18463 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18464 " function of x for each value of y[j] .\n"
18465 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18466 " for each value of x[i] .\n"
18467 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18468 " at which function is defined.\n"
18469 "\n"
18470 ""},
18471 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18472 "Magnitude colored plot surface mesh with contour\n"
18473 "\n"
18474 "DESCRIPTION:\n"
18475 "\n"
18476 " A more powerful form of plmesh: the surface mesh can be colored\n"
18477 " accordingly to the current z value being plotted, a contour plot can\n"
18478 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18479 " plotted function border and the base XY plane.\n"
18480 "\n"
18481 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18482 "\n"
18483 " This function is used in example 11.\n"
18484 "\n"
18485 "\n"
18486 "\n"
18487 "SYNOPSIS:\n"
18488 "\n"
18489 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18490 "\n"
18491 "ARGUMENTS:\n"
18492 "\n"
18493 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18494 " which the function is evaluated.\n"
18495 "\n"
18496 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18497 " which the function is evaluated.\n"
18498 "\n"
18499 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18500 " plot. Should have dimensions of\n"
18501 " nx by\n"
18502 " ny.\n"
18503 "\n"
18504 " nx (PLINT, input) : Number of x values at which function is\n"
18505 " evaluated.\n"
18506 "\n"
18507 " ny (PLINT, input) : Number of y values at which function is\n"
18508 " evaluated.\n"
18509 "\n"
18510 " opt (PLINT, input) : Determines the way in which the surface is\n"
18511 " represented. To specify more than one option just add the options,\n"
18512 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18513 " showing z as a function of x for each value of y[j] .\n"
18514 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18515 " for each value of x[i] .\n"
18516 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18517 " at which function is defined.\n"
18518 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18519 " the z value being plotted. The color is used from the current\n"
18520 " cmap1.\n"
18521 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18522 " using parameters\n"
18523 " nlevel and\n"
18524 " clevel.\n"
18525 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18526 " the borders of the plotted function.\n"
18527 "\n"
18528 "\n"
18529 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18530 " levels.\n"
18531 "\n"
18532 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18533 "\n"
18534 ""},
18535 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18536 "Creates a new stream and makes it the default\n"
18537 "\n"
18538 "DESCRIPTION:\n"
18539 "\n"
18540 " Creates a new stream and makes it the default. Differs from using\n"
18541 " plsstrm, in that a free stream number is found, and returned.\n"
18542 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18543 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18544 " that no initial, library-opening call is required. So stream 0 must\n"
18545 " be preallocated, and there is no simple way of determining whether it\n"
18546 " is already in use or not.\n"
18547 "\n"
18548 " Redacted form: plmkstrm(p_strm)\n"
18549 "\n"
18550 " This function is used in examples 1 and 20.\n"
18551 "\n"
18552 "\n"
18553 "\n"
18554 "SYNOPSIS:\n"
18555 "\n"
18556 "plmkstrm(p_strm)\n"
18557 "\n"
18558 "ARGUMENTS:\n"
18559 "\n"
18560 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18561 " number of the created stream.\n"
18562 "\n"
18563 ""},
18564 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18565 "Write text relative to viewport boundaries\n"
18566 "\n"
18567 "DESCRIPTION:\n"
18568 "\n"
18569 " Writes text at a specified position relative to the viewport\n"
18570 " boundaries. Text may be written inside or outside the viewport, but\n"
18571 " is clipped at the subpage boundaries. The reference point of a string\n"
18572 " lies along a line passing through the string at half the height of a\n"
18573 " capital letter. The position of the reference point along this line\n"
18574 " is determined by just, and the position of the reference point\n"
18575 " relative to the viewport is set by disp and pos.\n"
18576 "\n"
18577 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18578 "\n"
18579 "\n"
18580 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18581 " 26.\n"
18582 "\n"
18583 "\n"
18584 "\n"
18585 "SYNOPSIS:\n"
18586 "\n"
18587 "plmtex(side, disp, pos, just, text)\n"
18588 "\n"
18589 "ARGUMENTS:\n"
18590 "\n"
18591 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18592 " the side of the viewport along which the text is to be written.\n"
18593 " The string must be one of: b: Bottom of viewport, text written\n"
18594 " parallel to edge.\n"
18595 " bv: Bottom of viewport, text written at right angles to edge.\n"
18596 " l: Left of viewport, text written parallel to edge.\n"
18597 " lv: Left of viewport, text written at right angles to edge.\n"
18598 " r: Right of viewport, text written parallel to edge.\n"
18599 " rv: Right of viewport, text written at right angles to edge.\n"
18600 " t: Top of viewport, text written parallel to edge.\n"
18601 " tv: Top of viewport, text written at right angles to edge.\n"
18602 "\n"
18603 "\n"
18604 " disp (PLFLT, input) : Position of the reference point of string,\n"
18605 " measured outwards from the specified viewport edge in units of the\n"
18606 " current character height. Use negative disp to write within the\n"
18607 " viewport.\n"
18608 "\n"
18609 " pos (PLFLT, input) : Position of the reference point of string\n"
18610 " along the specified edge, expressed as a fraction of the length of\n"
18611 " the edge.\n"
18612 "\n"
18613 " just (PLFLT, input) : Specifies the position of the string relative\n"
18614 " to its reference point. If just=0. , the reference point is at\n"
18615 " the left and if just=1. , it is at the right of the string. Other\n"
18616 " values of just give intermediate justifications.\n"
18617 "\n"
18618 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18619 " written out.\n"
18620 "\n"
18621 ""},
18622 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18623 "Write text relative to viewport boundaries in 3D plots\n"
18624 "\n"
18625 "DESCRIPTION:\n"
18626 "\n"
18627 " Writes text at a specified position relative to the viewport\n"
18628 " boundaries. Text may be written inside or outside the viewport, but\n"
18629 " is clipped at the subpage boundaries. The reference point of a string\n"
18630 " lies along a line passing through the string at half the height of a\n"
18631 " capital letter. The position of the reference point along this line\n"
18632 " is determined by just, and the position of the reference point\n"
18633 " relative to the viewport is set by disp and pos.\n"
18634 "\n"
18635 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18636 "\n"
18637 " This function is used in example 28.\n"
18638 "\n"
18639 "\n"
18640 "\n"
18641 "SYNOPSIS:\n"
18642 "\n"
18643 "plmtex3(side, disp, pos, just, text)\n"
18644 "\n"
18645 "ARGUMENTS:\n"
18646 "\n"
18647 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18648 " the side of the viewport along which the text is to be written.\n"
18649 " The string should contain one or more of the following characters:\n"
18650 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18651 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18652 " axis.\n"
18653 " y: Label the Y axis.\n"
18654 " z: Label the Z axis.\n"
18655 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18656 " For X it is the axis that starts at y-min. For Y it is the\n"
18657 " axis that starts at x-min.\n"
18658 " s: Label the secondary axis.\n"
18659 " v: Draw the text perpendicular to the axis.\n"
18660 "\n"
18661 "\n"
18662 " disp (PLFLT, input) : Position of the reference point of string,\n"
18663 " measured outwards from the specified viewport edge in units of the\n"
18664 " current character height. Use negative disp to write within the\n"
18665 " viewport.\n"
18666 "\n"
18667 " pos (PLFLT, input) : Position of the reference point of string\n"
18668 " along the specified edge, expressed as a fraction of the length of\n"
18669 " the edge.\n"
18670 "\n"
18671 " just (PLFLT, input) : Specifies the position of the string relative\n"
18672 " to its reference point. If just=0. , the reference point is at\n"
18673 " the left and if just=1. , it is at the right of the string. Other\n"
18674 " values of just give intermediate justifications.\n"
18675 "\n"
18676 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18677 " written out.\n"
18678 "\n"
18679 ""},
18680 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18681 "Plot 3-d surface plot\n"
18682 "\n"
18683 "DESCRIPTION:\n"
18684 "\n"
18685 " Plots a three-dimensional surface plot within the environment set up\n"
18686 " by plw3d. The surface is defined by the matrix z[\n"
18687 " nx][\n"
18688 " ny] , the point z[i][j] being the value of the function at (\n"
18689 " x[i],\n"
18690 " y[j]). Note that the points in vectors x and y do not need to be\n"
18691 " equally spaced, but must be stored in ascending order. The parameter\n"
18692 " opt controls the way in which the surface is displayed. For further\n"
18693 " details see the PLplot documentation. The only difference between\n"
18694 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18695 " while plot3d only draws the surface as viewed from the top.\n"
18696 "\n"
18697 " Redacted form: plot3d(x, y, z, opt, side)\n"
18698 "\n"
18699 " This function is used in examples 11 and 21.\n"
18700 "\n"
18701 "\n"
18702 "\n"
18703 "SYNOPSIS:\n"
18704 "\n"
18705 "plot3d(x, y, z, nx, ny, opt, side)\n"
18706 "\n"
18707 "ARGUMENTS:\n"
18708 "\n"
18709 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18710 " which the function is evaluated.\n"
18711 "\n"
18712 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18713 " which the function is evaluated.\n"
18714 "\n"
18715 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18716 " plot. Should have dimensions of\n"
18717 " nx by\n"
18718 " ny.\n"
18719 "\n"
18720 " nx (PLINT, input) : Number of x values at which function is\n"
18721 " evaluated.\n"
18722 "\n"
18723 " ny (PLINT, input) : Number of y values at which function is\n"
18724 " evaluated.\n"
18725 "\n"
18726 " opt (PLINT, input) : Determines the way in which the surface is\n"
18727 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18728 " function of x for each value of y[j] .\n"
18729 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18730 " for each value of x[i] .\n"
18731 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18732 " at which function is defined.\n"
18733 "\n"
18734 "\n"
18735 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18736 " should be draw on the figure. If side is true sides are drawn,\n"
18737 " otherwise no sides are drawn.\n"
18738 "\n"
18739 ""},
18740 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18741 "Magnitude colored plot surface with contour\n"
18742 "\n"
18743 "DESCRIPTION:\n"
18744 "\n"
18745 " Aside from dropping the\n"
18746 " side functionality this is a more powerful form of plot3d: the surface\n"
18747 " mesh can be colored accordingly to the current z value being plotted,\n"
18748 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18749 " drawn between the plotted function border and the base XY plane. The\n"
18750 " arguments are identical to those of plmeshc. The only difference\n"
18751 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18752 " the surface, while plot3dc only draws the surface as viewed from the\n"
18753 " top.\n"
18754 "\n"
18755 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18756 "\n"
18757 "\n"
18758 " This function is used in example 21.\n"
18759 "\n"
18760 "\n"
18761 "\n"
18762 "SYNOPSIS:\n"
18763 "\n"
18764 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18765 "\n"
18766 "ARGUMENTS:\n"
18767 "\n"
18768 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18769 " which the function is evaluated.\n"
18770 "\n"
18771 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18772 " which the function is evaluated.\n"
18773 "\n"
18774 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18775 " plot. Should have dimensions of\n"
18776 " nx by\n"
18777 " ny.\n"
18778 "\n"
18779 " nx (PLINT, input) : Number of x values at which function is\n"
18780 " evaluated.\n"
18781 "\n"
18782 " ny (PLINT, input) : Number of y values at which function is\n"
18783 " evaluated.\n"
18784 "\n"
18785 " opt (PLINT, input) : Determines the way in which the surface is\n"
18786 " represented. To specify more than one option just add the options,\n"
18787 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18788 " showing z as a function of x for each value of y[j] .\n"
18789 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18790 " for each value of x[i] .\n"
18791 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18792 " at which function is defined.\n"
18793 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18794 " the z value being plotted. The color is used from the current\n"
18795 " cmap1.\n"
18796 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18797 " using parameters\n"
18798 " nlevel and\n"
18799 " clevel.\n"
18800 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18801 " the borders of the plotted function.\n"
18802 "\n"
18803 "\n"
18804 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18805 " levels.\n"
18806 "\n"
18807 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18808 "\n"
18809 ""},
18810 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18811 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18812 "\n"
18813 "DESCRIPTION:\n"
18814 "\n"
18815 " When the implementation is completed this variant of plot3dc (see that\n"
18816 " function's documentation for more details) should be suitable for the\n"
18817 " case where the area of the x, y coordinate grid where z is defined can\n"
18818 " be non-rectangular. The implementation is incomplete so the last 4\n"
18819 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18820 " indexymax; are currently ignored and the functionality is otherwise\n"
18821 " identical to that of plot3dc.\n"
18822 "\n"
18823 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18824 " indexymin, indexymax)\n"
18825 "\n"
18826 "\n"
18827 " This function is not used in any example.\n"
18828 "\n"
18829 "\n"
18830 "\n"
18831 "SYNOPSIS:\n"
18832 "\n"
18833 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18834 "\n"
18835 "ARGUMENTS:\n"
18836 "\n"
18837 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18838 " which the function is evaluated.\n"
18839 "\n"
18840 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18841 " which the function is evaluated.\n"
18842 "\n"
18843 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18844 " plot. Should have dimensions of\n"
18845 " nx by\n"
18846 " ny.\n"
18847 "\n"
18848 " nx (PLINT, input) : Number of x values at which the function is\n"
18849 " evaluated.\n"
18850 "\n"
18851 " ny (PLINT, input) : Number of y values at which the function is\n"
18852 " evaluated.\n"
18853 "\n"
18854 " opt (PLINT, input) : Determines the way in which the surface is\n"
18855 " represented. To specify more than one option just add the options,\n"
18856 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18857 " showing z as a function of x for each value of y[j] .\n"
18858 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18859 " for each value of x[i] .\n"
18860 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18861 " at which function is defined.\n"
18862 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18863 " the z value being plotted. The color is used from the current\n"
18864 " cmap1.\n"
18865 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18866 " using parameters\n"
18867 " nlevel and\n"
18868 " clevel.\n"
18869 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18870 " the borders of the plotted function.\n"
18871 "\n"
18872 "\n"
18873 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18874 " levels.\n"
18875 "\n"
18876 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18877 "\n"
18878 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18879 " corresponds to the first x index where z is defined.\n"
18880 "\n"
18881 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18882 " which corresponds (by convention) to one more than the last x\n"
18883 " index value where z is defined.\n"
18884 "\n"
18885 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18886 " values which all must be ≥ 0. These values are the first y index\n"
18887 " where z is defined for a particular x index in the range from\n"
18888 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18889 " indexxmax.\n"
18890 "\n"
18891 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18892 " values which all must be ≤ ny. These values correspond (by\n"
18893 " convention) to one more than the last y index where z is defined\n"
18894 " for a particular x index in the range from indexxmin to indexxmax\n"
18895 " - 1. The dimension of indexymax is indexxmax.\n"
18896 "\n"
18897 ""},
18898 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18899 "Plot shaded 3-d surface plot\n"
18900 "\n"
18901 "DESCRIPTION:\n"
18902 "\n"
18903 " Plots a three-dimensional shaded surface plot within the environment\n"
18904 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18905 " z[\n"
18906 " nx][\n"
18907 " ny], the point z[i][j] being the value of the function at (\n"
18908 " x[i],\n"
18909 " y[j]). Note that the points in vectors x and y do not need to be\n"
18910 " equally spaced, but must be stored in ascending order. For further\n"
18911 " details see the PLplot documentation.\n"
18912 "\n"
18913 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18914 "\n"
18915 " This function is not used in any examples.\n"
18916 "\n"
18917 "\n"
18918 "\n"
18919 "SYNOPSIS:\n"
18920 "\n"
18921 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18922 "\n"
18923 "ARGUMENTS:\n"
18924 "\n"
18925 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18926 " which the function is evaluated.\n"
18927 "\n"
18928 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18929 " which the function is evaluated.\n"
18930 "\n"
18931 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18932 " plot. Should have dimensions of\n"
18933 " nx by\n"
18934 " ny.\n"
18935 "\n"
18936 " nx (PLINT, input) : Number of x values at which function is\n"
18937 " evaluated.\n"
18938 "\n"
18939 " ny (PLINT, input) : Number of y values at which function is\n"
18940 " evaluated.\n"
18941 "\n"
18942 " opt (PLINT, input) : Determines the way in which the surface is\n"
18943 " represented. To specify more than one option just add the options,\n"
18944 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18945 " connecting points at which function is defined.\n"
18946 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18947 " using parameters\n"
18948 " nlevel and\n"
18949 " clevel.\n"
18950 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18951 " using parameters\n"
18952 " nlevel and\n"
18953 " clevel.\n"
18954 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18955 " the borders of the plotted function.\n"
18956 " opt=MAG_COLOR : the surface is colored according to the value\n"
18957 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18958 " according to the intensity of the reflected light in the\n"
18959 " surface from a light source whose position is set using\n"
18960 " pllightsource.\n"
18961 "\n"
18962 "\n"
18963 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18964 " levels.\n"
18965 "\n"
18966 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18967 "\n"
18968 ""},
18969 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18970 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18971 "\n"
18972 "DESCRIPTION:\n"
18973 "\n"
18974 " This variant of plsurf3d (see that function's documentation for more\n"
18975 " details) should be suitable for the case where the area of the x, y\n"
18976 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18977 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18978 " indexymin, and indexymax.\n"
18979 "\n"
18980 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18981 " indexymax)\n"
18982 "\n"
18983 " This function is used in example 8.\n"
18984 "\n"
18985 "\n"
18986 "\n"
18987 "SYNOPSIS:\n"
18988 "\n"
18989 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18990 "\n"
18991 "ARGUMENTS:\n"
18992 "\n"
18993 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18994 " which the function is evaluated.\n"
18995 "\n"
18996 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18997 " which the function is evaluated.\n"
18998 "\n"
18999 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19000 " plot. Should have dimensions of\n"
19001 " nx by\n"
19002 " ny.\n"
19003 "\n"
19004 " nx (PLINT, input) : Number of x values at which function is\n"
19005 " evaluated.\n"
19006 "\n"
19007 " ny (PLINT, input) : Number of y values at which function is\n"
19008 " evaluated.\n"
19009 "\n"
19010 " opt (PLINT, input) : Determines the way in which the surface is\n"
19011 " represented. To specify more than one option just add the options,\n"
19012 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19013 " connecting points at which function is defined.\n"
19014 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19015 " using parameters\n"
19016 " nlevel and\n"
19017 " clevel.\n"
19018 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19019 " using parameters\n"
19020 " nlevel and\n"
19021 " clevel.\n"
19022 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19023 " the borders of the plotted function.\n"
19024 " opt=MAG_COLOR : the surface is colored according to the value\n"
19025 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19026 " according to the intensity of the reflected light in the\n"
19027 " surface from a light source whose position is set using\n"
19028 " pllightsource.\n"
19029 "\n"
19030 "\n"
19031 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19032 " levels.\n"
19033 "\n"
19034 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19035 "\n"
19036 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19037 " corresponds to the first x index where z is defined.\n"
19038 "\n"
19039 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19040 " which corresponds (by convention) to one more than the last x\n"
19041 " index value where z is defined.\n"
19042 "\n"
19043 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19044 " values which all must be ≥ 0. These values are the first y index\n"
19045 " where z is defined for a particular x index in the range from\n"
19046 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19047 " indexxmax.\n"
19048 "\n"
19049 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19050 " values which all must be ≤ ny. These values correspond (by\n"
19051 " convention) to one more than the last y index where z is defined\n"
19052 " for a particular x index in the range from indexxmin to indexxmax\n"
19053 " - 1. The dimension of indexymax is indexxmax.\n"
19054 "\n"
19055 ""},
19056 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19057 "Parse command-line arguments\n"
19058 "\n"
19059 "DESCRIPTION:\n"
19060 "\n"
19061 " Parse command-line arguments.\n"
19062 "\n"
19063 " plparseopts removes all recognized flags (decreasing argc\n"
19064 " accordingly), so that invalid input may be readily detected. It can\n"
19065 " also be used to process user command line flags. The user can merge\n"
19066 " an option table of type PLOptionTable into the internal option table\n"
19067 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19068 " the external table(s) be parsed by calling plClearOpts before\n"
19069 " plMergeOpts.\n"
19070 "\n"
19071 " The default action taken by plparseopts is as follows:\n"
19072 " Returns with an error if an unrecognized option or badly formed\n"
19073 " option-value pair are encountered.\n"
19074 " Returns immediately (return code 0) when the first non-option command\n"
19075 " line argument is found.\n"
19076 " Returns with the return code of the option handler, if one was called.\n"
19077 "\n"
19078 " Deletes command line arguments from argv list as they are found, and\n"
19079 " decrements argc accordingly.\n"
19080 " Does not show \"invisible\" options in usage or help messages.\n"
19081 " Assumes the program name is contained in argv[0].\n"
19082 "\n"
19083 " These behaviors may be controlled through the\n"
19084 " mode argument.\n"
19085 "\n"
19086 " Redacted form: General: plparseopts(argv, mode)\n"
19087 "\n"
19088 "\n"
19089 " This function is used in all of the examples.\n"
19090 "\n"
19091 "\n"
19092 "\n"
19093 "SYNOPSIS:\n"
19094 "\n"
19095 "PLINT plparseopts(p_argc, argv, mode)\n"
19096 "\n"
19097 "ARGUMENTS:\n"
19098 "\n"
19099 " p_argc (int *, input/output) : Number of arguments.\n"
19100 "\n"
19101 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19102 " strings containing *p_argc command-line arguments.\n"
19103 "\n"
19104 " mode (PLINT, input) : Parsing mode with the following\n"
19105 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19106 " and all error messages enabled, including program exit when an\n"
19107 " error occurs. Anything on the command line that isn't recognized\n"
19108 " as a valid option or option argument is flagged as an error.\n"
19109 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19110 " of errors.\n"
19111 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19112 " arguments.\n"
19113 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19114 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19115 " pointer to the program name.\n"
19116 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19117 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19118 " unrecognized arguments.\n"
19119 "\n"
19120 ""},
19121 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19122 "Set area line fill pattern\n"
19123 "\n"
19124 "DESCRIPTION:\n"
19125 "\n"
19126 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19127 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19128 " inclinations and spacings. The arguments to this routine are the\n"
19129 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19130 " elements) specifying the inclinations in tenths of a degree and the\n"
19131 " spacing in micrometers. (See also plpsty)\n"
19132 "\n"
19133 " Redacted form: General: plpat(inc, del)\n"
19134 "\n"
19135 "\n"
19136 " This function is used in example 15.\n"
19137 "\n"
19138 "\n"
19139 "\n"
19140 "SYNOPSIS:\n"
19141 "\n"
19142 "plpat(nlin, inc, del)\n"
19143 "\n"
19144 "ARGUMENTS:\n"
19145 "\n"
19146 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19147 " pattern, either 1 or 2.\n"
19148 "\n"
19149 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19150 " inclination in tenths of a degree. (Should be between -900 and\n"
19151 " 900).\n"
19152 "\n"
19153 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19154 " spacing in micrometers between the lines making up the pattern.\n"
19155 "\n"
19156 ""},
19157 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19158 "Draw a line between two points, accounting for coordinate transforms\n"
19159 "\n"
19160 "DESCRIPTION:\n"
19161 "\n"
19162 " Joins the point (\n"
19163 " x1,\n"
19164 " y1) to (\n"
19165 " x2,\n"
19166 " y2) . If a global coordinate transform is defined then the line is\n"
19167 " broken in to n segments to approximate the path. If no transform is\n"
19168 " defined then this simply acts like a call to pljoin.\n"
19169 "\n"
19170 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19171 "\n"
19172 " This function is used in example 22.\n"
19173 "\n"
19174 "\n"
19175 "\n"
19176 "SYNOPSIS:\n"
19177 "\n"
19178 "plpath(n, x1, y1, x2, y2)\n"
19179 "\n"
19180 "ARGUMENTS:\n"
19181 "\n"
19182 " n (PLINT, input) : number of points to use to approximate the path.\n"
19183 "\n"
19184 " x1 (PLFLT, input) : x coordinate of first point.\n"
19185 "\n"
19186 " y1 (PLFLT, input) : y coordinate of first point.\n"
19187 "\n"
19188 " x2 (PLFLT, input) : x coordinate of second point.\n"
19189 "\n"
19190 " y2 (PLFLT, input) : y coordinate of second point.\n"
19191 "\n"
19192 ""},
19193 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19194 "Plot a glyph at the specified points\n"
19195 "\n"
19196 "DESCRIPTION:\n"
19197 "\n"
19198 " Plot a glyph at the specified points. (This function is largely\n"
19199 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19200 " code=-1 means try to just draw a point. Right now it's just a move\n"
19201 " and a draw at the same place. Not ideal, since a sufficiently\n"
19202 " intelligent output device may optimize it away, or there may be faster\n"
19203 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19204 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19205 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19206 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19207 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19208 "\n"
19209 " Redacted form: plpoin(x, y, code)\n"
19210 "\n"
19211 " This function is used in examples 1, 6, 14, and 29.\n"
19212 "\n"
19213 "\n"
19214 "\n"
19215 "SYNOPSIS:\n"
19216 "\n"
19217 "plpoin(n, x, y, code)\n"
19218 "\n"
19219 "ARGUMENTS:\n"
19220 "\n"
19221 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19222 "\n"
19223 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19224 " points.\n"
19225 "\n"
19226 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19227 " points.\n"
19228 "\n"
19229 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19230 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19231 " each of the n points.\n"
19232 "\n"
19233 ""},
19234 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19235 "Plot a glyph at the specified 3D points\n"
19236 "\n"
19237 "DESCRIPTION:\n"
19238 "\n"
19239 " Plot a glyph at the specified 3D points. (This function is largely\n"
19240 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19241 " Set up the call to this function similar to what is done for plline3.\n"
19242 " code=-1 means try to just draw a point. Right now it's just a move\n"
19243 " and a draw at the same place. Not ideal, since a sufficiently\n"
19244 " intelligent output device may optimize it away, or there may be faster\n"
19245 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19246 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19247 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19248 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19249 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19250 "\n"
19251 " Redacted form: plpoin3(x, y, z, code)\n"
19252 "\n"
19253 " This function is not used in any example.\n"
19254 "\n"
19255 "\n"
19256 "\n"
19257 "SYNOPSIS:\n"
19258 "\n"
19259 "plpoin3(n, x, y, z, code)\n"
19260 "\n"
19261 "ARGUMENTS:\n"
19262 "\n"
19263 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19264 "\n"
19265 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19266 " points.\n"
19267 "\n"
19268 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19269 " points.\n"
19270 "\n"
19271 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19272 " points.\n"
19273 "\n"
19274 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19275 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19276 " each of the n points.\n"
19277 "\n"
19278 ""},
19279 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19280 "Draw a polygon in 3 space\n"
19281 "\n"
19282 "DESCRIPTION:\n"
19283 "\n"
19284 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19285 " like plline3, but differs from that function in that plpoly3 attempts\n"
19286 " to determine if the polygon is viewable depending on the order of the\n"
19287 " points within the vector and the value of ifcc. If the back of\n"
19288 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19289 " you want, then use plline3 instead.\n"
19290 "\n"
19291 " The points are assumed to be in a plane, and the directionality of the\n"
19292 " plane is determined from the first three points. Additional points do\n"
19293 " not have to lie on the plane defined by the first three, but if they\n"
19294 " do not, then the determination of visibility obviously can't be 100%\n"
19295 " accurate... So if you're 3 space polygons are too far from planar,\n"
19296 " consider breaking them into smaller polygons. 3 points define a plane\n"
19297 " :-).\n"
19298 "\n"
19299 " Bugs: If one of the first two segments is of zero length, or if they\n"
19300 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19301 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19302 " of this problem. (Search for 20.1).\n"
19303 "\n"
19304 " Redacted form: plpoly3(x, y, z, code)\n"
19305 "\n"
19306 " This function is used in example 18.\n"
19307 "\n"
19308 "\n"
19309 "\n"
19310 "SYNOPSIS:\n"
19311 "\n"
19312 "plpoly3(n, x, y, z, draw, ifcc)\n"
19313 "\n"
19314 "ARGUMENTS:\n"
19315 "\n"
19316 " n (PLINT, input) : Number of points defining line.\n"
19317 "\n"
19318 " x (PLFLT_VECTOR, input) : A vector containing\n"
19319 " n x coordinates of points.\n"
19320 "\n"
19321 " y (PLFLT_VECTOR, input) : A vector containing\n"
19322 " n y coordinates of points.\n"
19323 "\n"
19324 " z (PLFLT_VECTOR, input) : A vector containing\n"
19325 " n z coordinates of points.\n"
19326 "\n"
19327 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19328 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19329 " If draw[i] is true, then the polygon segment from index [i] to\n"
19330 " [i+1] is drawn, otherwise, not.\n"
19331 "\n"
19332 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19333 " polygon is determined by assuming the points are laid out in a\n"
19334 " counter-clockwise order. Otherwise, the directionality of the\n"
19335 " polygon is determined by assuming the points are laid out in a\n"
19336 " clockwise order.\n"
19337 "\n"
19338 ""},
19339 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19340 "Set precision in numeric labels\n"
19341 "\n"
19342 "DESCRIPTION:\n"
19343 "\n"
19344 " Sets the number of places after the decimal point in numeric labels.\n"
19345 "\n"
19346 " Redacted form: plprec(setp, prec)\n"
19347 "\n"
19348 " This function is used in example 29.\n"
19349 "\n"
19350 "\n"
19351 "\n"
19352 "SYNOPSIS:\n"
19353 "\n"
19354 "plprec(setp, prec)\n"
19355 "\n"
19356 "ARGUMENTS:\n"
19357 "\n"
19358 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19359 " automatically determines the number of places to use after the\n"
19360 " decimal point in numeric labels (like those used to label axes).\n"
19361 " If setp is 1 then prec sets the number of places.\n"
19362 "\n"
19363 " prec (PLINT, input) : The number of characters to draw after the\n"
19364 " decimal point in numeric labels.\n"
19365 "\n"
19366 ""},
19367 { "plpsty", _wrap_plpsty, METH_O, "\n"
19368 "Select area fill pattern\n"
19369 "\n"
19370 "DESCRIPTION:\n"
19371 "\n"
19372 " If\n"
19373 " patt is zero or less use either a hardware solid fill if the drivers\n"
19374 " have that capability (virtually all do) or fall back to a software\n"
19375 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19376 " 0 <\n"
19377 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19378 " to use (see plpat if you desire other patterns).\n"
19379 "\n"
19380 " Redacted form: plpsty(patt)\n"
19381 "\n"
19382 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19383 "\n"
19384 "\n"
19385 "\n"
19386 "SYNOPSIS:\n"
19387 "\n"
19388 "plpsty(patt)\n"
19389 "\n"
19390 "ARGUMENTS:\n"
19391 "\n"
19392 " patt (PLINT, input) : The desired pattern index. If\n"
19393 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19394 " above) used. For\n"
19395 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19396 " line fill capability itself (most deliberately do not so that line\n"
19397 " fill patterns look identical for those drivers), the patterns\n"
19398 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19399 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19400 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19401 " (8) lines at both 45 degrees and -45 degrees.\n"
19402 "\n"
19403 ""},
19404 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19405 "Write text inside the viewport\n"
19406 "\n"
19407 "DESCRIPTION:\n"
19408 "\n"
19409 " Writes text at a specified position and inclination within the\n"
19410 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19411 " point of a string lies along a line passing through the string at half\n"
19412 " the height of a capital letter. The position of the reference point\n"
19413 " along this line is determined by just, the reference point is placed\n"
19414 " at world coordinates (\n"
19415 " x,\n"
19416 " y) within the viewport. The inclination of the string is specified\n"
19417 " in terms of differences of world coordinates making it easy to write\n"
19418 " text parallel to a line in a graph.\n"
19419 "\n"
19420 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19421 "\n"
19422 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19423 "\n"
19424 "\n"
19425 "\n"
19426 "SYNOPSIS:\n"
19427 "\n"
19428 "plptex(x, y, dx, dy, just, text)\n"
19429 "\n"
19430 "ARGUMENTS:\n"
19431 "\n"
19432 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19433 "\n"
19434 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19435 "\n"
19436 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19437 " inclination of the string. The baseline of the string is parallel\n"
19438 " to a line joining (\n"
19439 " x,\n"
19440 " y) to (\n"
19441 " x+\n"
19442 " dx,\n"
19443 " y+\n"
19444 " dy) .\n"
19445 "\n"
19446 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19447 " inclination of the string.\n"
19448 "\n"
19449 " just (PLFLT, input) : Specifies the position of the string relative\n"
19450 " to its reference point. If just=0. , the reference point is at\n"
19451 " the left and if just=1. , it is at the right of the string. Other\n"
19452 " values of just give intermediate justifications.\n"
19453 "\n"
19454 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19455 " written out.\n"
19456 "\n"
19457 ""},
19458 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19459 "Write text inside the viewport of a 3D plot\n"
19460 "\n"
19461 "DESCRIPTION:\n"
19462 "\n"
19463 " Writes text at a specified position and inclination and with a\n"
19464 " specified shear within the viewport. Text is clipped at the viewport\n"
19465 " boundaries. The reference point of a string lies along a line passing\n"
19466 " through the string at half the height of a capital letter. The\n"
19467 " position of the reference point along this line is determined by just,\n"
19468 " and the reference point is placed at world coordinates (\n"
19469 " wx,\n"
19470 " wy,\n"
19471 " wz) within the viewport. The inclination and shear of the string is\n"
19472 " specified in terms of differences of world coordinates making it easy\n"
19473 " to write text parallel to a line in a graph.\n"
19474 "\n"
19475 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19476 "\n"
19477 " This function is used in example 28.\n"
19478 "\n"
19479 "\n"
19480 "\n"
19481 "SYNOPSIS:\n"
19482 "\n"
19483 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19484 "\n"
19485 "ARGUMENTS:\n"
19486 "\n"
19487 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19488 " string.\n"
19489 "\n"
19490 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19491 " string.\n"
19492 "\n"
19493 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19494 " string.\n"
19495 "\n"
19496 " dx (PLFLT, input) : Together with dy and\n"
19497 " dz , this specifies the inclination of the string. The baseline of\n"
19498 " the string is parallel to a line joining (\n"
19499 " x,\n"
19500 " y,\n"
19501 " z) to (\n"
19502 " x+\n"
19503 " dx,\n"
19504 " y+\n"
19505 " dy,\n"
19506 " z+\n"
19507 " dz) .\n"
19508 "\n"
19509 " dy (PLFLT, input) : Together with dx and\n"
19510 " dz, this specifies the inclination of the string.\n"
19511 "\n"
19512 " dz (PLFLT, input) : Together with dx and\n"
19513 " dy, this specifies the inclination of the string.\n"
19514 "\n"
19515 " sx (PLFLT, input) : Together with sy and\n"
19516 " sz , this specifies the shear of the string. The string is sheared so\n"
19517 " that the characters are vertically parallel to a line joining (\n"
19518 " x,\n"
19519 " y,\n"
19520 " z) to (\n"
19521 " x+\n"
19522 " sx,\n"
19523 " y+\n"
19524 " sy,\n"
19525 " z+\n"
19526 " sz) . If sx =\n"
19527 " sy =\n"
19528 " sz = 0.) then the text is not sheared.\n"
19529 "\n"
19530 " sy (PLFLT, input) : Together with sx and\n"
19531 " sz, this specifies shear of the string.\n"
19532 "\n"
19533 " sz (PLFLT, input) : Together with sx and\n"
19534 " sy, this specifies shear of the string.\n"
19535 "\n"
19536 " just (PLFLT, input) : Specifies the position of the string relative\n"
19537 " to its reference point. If just=0. , the reference point is at\n"
19538 " the left and if just=1. , it is at the right of the string. Other\n"
19539 " values of just give intermediate justifications.\n"
19540 "\n"
19541 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19542 " written out.\n"
19543 "\n"
19544 ""},
19545 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19546 "Random number generator returning a real random number in the range [0,1]\n"
19547 "\n"
19548 "DESCRIPTION:\n"
19549 "\n"
19550 " Random number generator returning a real random number in the range\n"
19551 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19552 " / compilers provide their own random number generator, and so this is\n"
19553 " provided purely for convenience and to give a consistent random number\n"
19554 " generator across all languages supported by PLplot. This is\n"
19555 " particularly useful for comparing results from the test suite of\n"
19556 " examples.\n"
19557 "\n"
19558 " Redacted form: plrandd()\n"
19559 "\n"
19560 " This function is used in examples 17 and 21.\n"
19561 "\n"
19562 "\n"
19563 "\n"
19564 "SYNOPSIS:\n"
19565 "\n"
19566 "plrandd()\n"
19567 "\n"
19568 ""},
19569 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19570 "Replays contents of plot buffer to current device/file\n"
19571 "\n"
19572 "DESCRIPTION:\n"
19573 "\n"
19574 " Replays contents of plot buffer to current device/file.\n"
19575 "\n"
19576 " Redacted form: plreplot()\n"
19577 "\n"
19578 " This function is used in example 1,20.\n"
19579 "\n"
19580 "\n"
19581 "\n"
19582 "SYNOPSIS:\n"
19583 "\n"
19584 "plreplot()\n"
19585 "\n"
19586 ""},
19587 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19588 "Convert RGB color to HLS\n"
19589 "\n"
19590 "DESCRIPTION:\n"
19591 "\n"
19592 " Convert RGB color coordinates to HLS\n"
19593 "\n"
19594 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19595 "\n"
19596 "\n"
19597 " This function is used in example 2.\n"
19598 "\n"
19599 "\n"
19600 "\n"
19601 "SYNOPSIS:\n"
19602 "\n"
19603 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19604 "\n"
19605 "ARGUMENTS:\n"
19606 "\n"
19607 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19608 "\n"
19609 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19610 "\n"
19611 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19612 "\n"
19613 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19614 " degrees (0.0-360.0) on the color cylinder.\n"
19615 "\n"
19616 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19617 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19618 " cylinder.\n"
19619 "\n"
19620 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19621 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19622 " cylinder.\n"
19623 "\n"
19624 ""},
19625 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19626 "Set character size\n"
19627 "\n"
19628 "DESCRIPTION:\n"
19629 "\n"
19630 " This sets up the size of all subsequent characters drawn. The actual\n"
19631 " height of a character is the product of the default character size and\n"
19632 " a scaling factor.\n"
19633 "\n"
19634 " Redacted form: plschr(def, scale)\n"
19635 "\n"
19636 " This function is used in examples 2, 13, 23, and 24.\n"
19637 "\n"
19638 "\n"
19639 "\n"
19640 "SYNOPSIS:\n"
19641 "\n"
19642 "plschr(def, scale)\n"
19643 "\n"
19644 "ARGUMENTS:\n"
19645 "\n"
19646 " def (PLFLT, input) : The default height of a character in\n"
19647 " millimeters, should be set to zero if the default height is to\n"
19648 " remain unchanged. For rasterized drivers the dx and dy values\n"
19649 " specified in plspage are used to convert from mm to pixels (note\n"
19650 " the different unit systems used). This dpi aware scaling is not\n"
19651 " implemented for all drivers yet.\n"
19652 "\n"
19653 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19654 " actual character height.\n"
19655 "\n"
19656 ""},
19657 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19658 "Set cmap0 colors by 8-bit RGB values\n"
19659 "\n"
19660 "DESCRIPTION:\n"
19661 "\n"
19662 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19663 " documentation). This sets the entire color map -- only as many colors\n"
19664 " as specified will be allocated.\n"
19665 "\n"
19666 " Redacted form: plscmap0(r, g, b)\n"
19667 "\n"
19668 " This function is used in examples 2 and 24.\n"
19669 "\n"
19670 "\n"
19671 "\n"
19672 "SYNOPSIS:\n"
19673 "\n"
19674 "plscmap0(r, g, b, ncol0)\n"
19675 "\n"
19676 "ARGUMENTS:\n"
19677 "\n"
19678 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19679 " integers (0-255) representing the degree of red in the color.\n"
19680 "\n"
19681 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19682 " integers (0-255) representing the degree of green in the color.\n"
19683 "\n"
19684 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19685 " integers (0-255) representing the degree of blue in the color.\n"
19686 "\n"
19687 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19688 "\n"
19689 ""},
19690 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19691 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19692 "\n"
19693 "DESCRIPTION:\n"
19694 "\n"
19695 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19696 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19697 " only as many colors as specified will be allocated.\n"
19698 "\n"
19699 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19700 "\n"
19701 " This function is used in examples 30.\n"
19702 "\n"
19703 "\n"
19704 "\n"
19705 "SYNOPSIS:\n"
19706 "\n"
19707 "plscmap0a(r, g, b, alpha, ncol0)\n"
19708 "\n"
19709 "ARGUMENTS:\n"
19710 "\n"
19711 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19712 " integers (0-255) representing the degree of red in the color.\n"
19713 "\n"
19714 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19715 " integers (0-255) representing the degree of green in the color.\n"
19716 "\n"
19717 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19718 " integers (0-255) representing the degree of blue in the color.\n"
19719 "\n"
19720 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19721 " representing the alpha transparency of the color.\n"
19722 "\n"
19723 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19724 " vectors.\n"
19725 "\n"
19726 ""},
19727 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19728 "Set number of colors in cmap0\n"
19729 "\n"
19730 "DESCRIPTION:\n"
19731 "\n"
19732 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19733 " (or reallocate) cmap0, and fill with default values for those colors\n"
19734 " not previously allocated. The first 16 default colors are given in\n"
19735 " the plcol0 documentation. For larger indices the default color is\n"
19736 " red.\n"
19737 "\n"
19738 " The drivers are not guaranteed to support more than 16 colors.\n"
19739 "\n"
19740 " Redacted form: plscmap0n(ncol0)\n"
19741 "\n"
19742 " This function is used in examples 15, 16, and 24.\n"
19743 "\n"
19744 "\n"
19745 "\n"
19746 "SYNOPSIS:\n"
19747 "\n"
19748 "plscmap0n(ncol0)\n"
19749 "\n"
19750 "ARGUMENTS:\n"
19751 "\n"
19752 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19753 " the cmap0 palette. If this number is zero or less, then the value\n"
19754 " from the previous call to plscmap0n is used and if there is no\n"
19755 " previous call, then a default value is used.\n"
19756 "\n"
19757 ""},
19758 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19759 "Set opaque RGB cmap1 colors values\n"
19760 "\n"
19761 "DESCRIPTION:\n"
19762 "\n"
19763 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19764 " vector values. This function also sets the number of cmap1 colors.\n"
19765 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19766 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19767 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19768 " to\n"
19769 " ncol1-1. So in order for this continuous color model to work\n"
19770 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19771 " that these RGB vectors are continuous functions of their integer\n"
19772 " indices.\n"
19773 "\n"
19774 " Redacted form: plscmap1(r, g, b)\n"
19775 "\n"
19776 " This function is used in example 31.\n"
19777 "\n"
19778 "\n"
19779 "\n"
19780 "SYNOPSIS:\n"
19781 "\n"
19782 "plscmap1(r, g, b, ncol1)\n"
19783 "\n"
19784 "ARGUMENTS:\n"
19785 "\n"
19786 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19787 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19788 " color as a continuous function of the integer index of the vector.\n"
19789 "\n"
19790 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19791 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19792 " color as a continuous function of the integer index of the vector.\n"
19793 "\n"
19794 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19795 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19796 " color as a continuous function of the integer index of the vector.\n"
19797 "\n"
19798 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19799 "\n"
19800 ""},
19801 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19802 "Set semitransparent cmap1 RGBA colors.\n"
19803 "\n"
19804 "DESCRIPTION:\n"
19805 "\n"
19806 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19807 " RGBA vector values. This function also sets the number of cmap1\n"
19808 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19809 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19810 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19811 " vectors in the range from 0 to\n"
19812 " ncol1-1. So in order for this continuous color model to work\n"
19813 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19814 " that these RGBA vectors are continuous functions of their integer\n"
19815 " indices.\n"
19816 "\n"
19817 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19818 "\n"
19819 " This function is used in example 31.\n"
19820 "\n"
19821 "\n"
19822 "\n"
19823 "SYNOPSIS:\n"
19824 "\n"
19825 "plscmap1a(r, g, b, alpha, ncol1)\n"
19826 "\n"
19827 "ARGUMENTS:\n"
19828 "\n"
19829 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19830 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19831 " color as a continuous function of the integer index of the vector.\n"
19832 "\n"
19833 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19834 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19835 " color as a continuous function of the integer index of the vector.\n"
19836 "\n"
19837 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19838 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19839 " color as a continuous function of the integer index of the vector.\n"
19840 "\n"
19841 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19842 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19843 " completely transparent and 1.0 corresponds to completely opaque)\n"
19844 " the alpha transparency of the color as a continuous function of\n"
19845 " the integer index of the vector.\n"
19846 "\n"
19847 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19848 " vectors.\n"
19849 "\n"
19850 ""},
19851 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19852 "Set cmap1 colors using a piece-wise linear relationship\n"
19853 "\n"
19854 "DESCRIPTION:\n"
19855 "\n"
19856 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19857 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19858 " (see the PLplot documentation). May be called at any time.\n"
19859 "\n"
19860 " The idea here is to specify a number of control points that define the\n"
19861 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19862 " these points, linear interpolation is used which gives a smooth\n"
19863 " variation of color with intensity index. Any number of control points\n"
19864 " may be specified, located at arbitrary positions, although typically 2\n"
19865 " - 4 are enough. Another way of stating this is that we are traversing\n"
19866 " a given number of lines through HLS or RGB space as we move through\n"
19867 " cmap1 intensity indices. The control points at the minimum and\n"
19868 " maximum position (0 and 1) must always be specified. By adding more\n"
19869 " control points you can get more variation. One good technique for\n"
19870 " plotting functions that vary about some expected average is to use an\n"
19871 " additional 2 control points in the center (position ~= 0.5) that are\n"
19872 " the same lightness as the background (typically white for paper\n"
19873 " output, black for crt), and same hue as the boundary control points.\n"
19874 " This allows the highs and lows to be very easily distinguished.\n"
19875 "\n"
19876 " Each control point must specify the cmap1 intensity index and the\n"
19877 " associated three coordinates in HLS or RGB space. The first point\n"
19878 " must correspond to position = 0, and the last to position = 1.\n"
19879 "\n"
19880 " If RGB colors are provided then the interpolation takes place in RGB\n"
19881 " space and is trivial. However if HLS colors are provided then, because\n"
19882 " of the circular nature of the color wheel for the hue coordinate, the\n"
19883 " interpolation could be performed in either direction around the color\n"
19884 " wheel. The default behaviour is for the hue to be linearly\n"
19885 " interpolated ignoring this circular property of hue. So for example,\n"
19886 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19887 " green and cyan. If instead you wish to interpolate the other way\n"
19888 " around the color wheel you have two options. You may provide hues\n"
19889 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19890 " for red the interpolation will proceed via magenta. Alternatively you\n"
19891 " can utilise the alt_hue_path variable to reverse the direction of\n"
19892 " interpolation if you need to provide hues within the [0-360) range.\n"
19893 "\n"
19894 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19895 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19896 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19897 " 480]falseblue-magenta-red-yellow-green[120\n"
19898 " 240]truegreen-yellow-red-magenta-blue[240\n"
19899 " 120]trueblue-magenta-red-yellow-green\n"
19900 "\n"
19901 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19902 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19903 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19904 "\n"
19905 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19906 " alt_hue_path)\n"
19907 "\n"
19908 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19909 "\n"
19910 "\n"
19911 "\n"
19912 "SYNOPSIS:\n"
19913 "\n"
19914 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19915 "\n"
19916 "ARGUMENTS:\n"
19917 "\n"
19918 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19919 "\n"
19920 " npts (PLINT, input) : number of control points\n"
19921 "\n"
19922 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19923 " intensity index (0.0-1.0) in ascending order for each control\n"
19924 " point.\n"
19925 "\n"
19926 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19927 " coordinate (H or R) for each control point.\n"
19928 "\n"
19929 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19930 " coordinate (L or G) for each control point.\n"
19931 "\n"
19932 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19933 " coordinate (S or B) for each control point.\n"
19934 "\n"
19935 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19936 " npts - 1 elements), each containing either true to use the reversed\n"
19937 " HLS interpolation or false to use the regular HLS interpolation.\n"
19938 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19939 " i and i + 1 control points). This parameter is not used for RGB\n"
19940 " colors (\n"
19941 " itype = true).\n"
19942 "\n"
19943 ""},
19944 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19945 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19946 "\n"
19947 "DESCRIPTION:\n"
19948 "\n"
19949 " This is a variant of plscmap1l that supports alpha channel\n"
19950 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19951 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19952 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19953 " transparency value (0.0-1.0). It may be called at any time.\n"
19954 "\n"
19955 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19956 " alpha, alt_hue_path)\n"
19957 "\n"
19958 " This function is used in example 30.\n"
19959 "\n"
19960 "\n"
19961 "\n"
19962 "SYNOPSIS:\n"
19963 "\n"
19964 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19965 "\n"
19966 "ARGUMENTS:\n"
19967 "\n"
19968 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19969 "\n"
19970 " npts (PLINT, input) : number of control points.\n"
19971 "\n"
19972 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19973 " intensity index (0.0-1.0) in ascending order for each control\n"
19974 " point.\n"
19975 "\n"
19976 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19977 " coordinate (H or R) for each control point.\n"
19978 "\n"
19979 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19980 " coordinate (L or G) for each control point.\n"
19981 "\n"
19982 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19983 " coordinate (S or B) for each control point.\n"
19984 "\n"
19985 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19986 " transparency value (0.0-1.0) for each control point.\n"
19987 "\n"
19988 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19989 " npts - 1 elements) containing the alternative interpolation method\n"
19990 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19991 " refers to the interpolation interval between the i and i + 1\n"
19992 " control points).\n"
19993 "\n"
19994 ""},
19995 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19996 "Set number of colors in cmap1\n"
19997 "\n"
19998 "DESCRIPTION:\n"
19999 "\n"
20000 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
20001 " values if this is the first allocation (see the PLplot documentation).\n"
20002 "\n"
20003 " Redacted form: plscmap1n(ncol1)\n"
20004 "\n"
20005 " This function is used in examples 8, 11, 20, and 21.\n"
20006 "\n"
20007 "\n"
20008 "\n"
20009 "SYNOPSIS:\n"
20010 "\n"
20011 "plscmap1n(ncol1)\n"
20012 "\n"
20013 "ARGUMENTS:\n"
20014 "\n"
20015 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20016 " the cmap1 palette. If this number is zero or less, then the value\n"
20017 " from the previous call to plscmap1n is used and if there is no\n"
20018 " previous call, then a default value is used.\n"
20019 "\n"
20020 ""},
20021 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
20022 "Set the cmap1 argument range for continuous color plots\n"
20023 "\n"
20024 "DESCRIPTION:\n"
20025 "\n"
20026 " Set the cmap1 argument range for continuous color plots that\n"
20027 " corresponds to the range of data values. The maximum range\n"
20028 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20029 " the cmap1 argument range that is specified with this routine, the\n"
20030 " smaller the subset of the cmap1 color palette that is used to\n"
20031 " represent the continuous data being plotted. If\n"
20032 " min_color is greater than\n"
20033 " max_color or\n"
20034 " max_color is greater than 1.0 or\n"
20035 " min_color is less than 0.0 then no change is made to the cmap1\n"
20036 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20037 "\n"
20038 " Redacted form: plscmap1_range(min_color, max_color)\n"
20039 "\n"
20040 " This function is currently used in example 33.\n"
20041 "\n"
20042 "\n"
20043 "\n"
20044 "SYNOPSIS:\n"
20045 "\n"
20046 "plscmap1_range(min_color, max_color)\n"
20047 "\n"
20048 "ARGUMENTS:\n"
20049 "\n"
20050 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20051 " than 0.0, then 0.0 is used instead.\n"
20052 "\n"
20053 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20054 " than 1.0, then 1.0 is used instead.\n"
20055 "\n"
20056 ""},
20057 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20058 "Get the cmap1 argument range for continuous color plots\n"
20059 "\n"
20060 "DESCRIPTION:\n"
20061 "\n"
20062 " Get the cmap1 argument range for continuous color plots. (Use\n"
20063 " plscmap1_range to set the cmap1 argument range.)\n"
20064 "\n"
20065 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20066 "\n"
20067 " This function is currently not used in any example.\n"
20068 "\n"
20069 "\n"
20070 "\n"
20071 "SYNOPSIS:\n"
20072 "\n"
20073 "plgcmap1_range(min_color, max_color)\n"
20074 "\n"
20075 "ARGUMENTS:\n"
20076 "\n"
20077 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20078 " minimum cmap1 argument.\n"
20079 "\n"
20080 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20081 " maximum cmap1 argument.\n"
20082 "\n"
20083 ""},
20084 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20085 "Set 8-bit RGB values for given cmap0 color index\n"
20086 "\n"
20087 "DESCRIPTION:\n"
20088 "\n"
20089 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20090 " index. Overwrites the previous color value for the given index and,\n"
20091 " thus, does not result in any additional allocation of space for\n"
20092 " colors.\n"
20093 "\n"
20094 " Redacted form: plscol0(icol0, r, g, b)\n"
20095 "\n"
20096 " This function is used in any example 31.\n"
20097 "\n"
20098 "\n"
20099 "\n"
20100 "SYNOPSIS:\n"
20101 "\n"
20102 "plscol0(icol0, r, g, b)\n"
20103 "\n"
20104 "ARGUMENTS:\n"
20105 "\n"
20106 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20107 " number of colors (which is set by default, by plscmap0n, or even\n"
20108 " by plscmap0).\n"
20109 "\n"
20110 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20111 " degree of red in the color.\n"
20112 "\n"
20113 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20114 " degree of green in the color.\n"
20115 "\n"
20116 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20117 " degree of blue in the color.\n"
20118 "\n"
20119 ""},
20120 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20121 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20122 "\n"
20123 "DESCRIPTION:\n"
20124 "\n"
20125 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20126 " (see the PLplot documentation) index. Overwrites the previous color\n"
20127 " value for the given index and, thus, does not result in any additional\n"
20128 " allocation of space for colors.\n"
20129 "\n"
20130 " This function is used in example 30.\n"
20131 "\n"
20132 "\n"
20133 "\n"
20134 "SYNOPSIS:\n"
20135 "\n"
20136 "plscol0a(icol0, r, g, b, alpha)\n"
20137 "\n"
20138 "ARGUMENTS:\n"
20139 "\n"
20140 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20141 " number of colors (which is set by default, by plscmap0n, or even\n"
20142 " by plscmap0).\n"
20143 "\n"
20144 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20145 " degree of red in the color.\n"
20146 "\n"
20147 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20148 " degree of green in the color.\n"
20149 "\n"
20150 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20151 " degree of blue in the color.\n"
20152 "\n"
20153 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20154 " (0.0-1.0).\n"
20155 "\n"
20156 ""},
20157 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20158 "Set the background color by 8-bit RGB value\n"
20159 "\n"
20160 "DESCRIPTION:\n"
20161 "\n"
20162 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20163 " the PLplot documentation).\n"
20164 "\n"
20165 " Redacted form: plscolbg(r, g, b)\n"
20166 "\n"
20167 " This function is used in examples 15 and 31.\n"
20168 "\n"
20169 "\n"
20170 "\n"
20171 "SYNOPSIS:\n"
20172 "\n"
20173 "plscolbg(r, g, b)\n"
20174 "\n"
20175 "ARGUMENTS:\n"
20176 "\n"
20177 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20178 " degree of red in the color.\n"
20179 "\n"
20180 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20181 " degree of green in the color.\n"
20182 "\n"
20183 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20184 " degree of blue in the color.\n"
20185 "\n"
20186 ""},
20187 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20188 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20189 "\n"
20190 "DESCRIPTION:\n"
20191 "\n"
20192 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20193 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20194 "\n"
20195 " This function is used in example 31.\n"
20196 "\n"
20197 "\n"
20198 "\n"
20199 "SYNOPSIS:\n"
20200 "\n"
20201 "plscolbga(r, g, b, alpha)\n"
20202 "\n"
20203 "ARGUMENTS:\n"
20204 "\n"
20205 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20206 " degree of red in the color.\n"
20207 "\n"
20208 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20209 " degree of green in the color.\n"
20210 "\n"
20211 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20212 " degree of blue in the color.\n"
20213 "\n"
20214 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20215 " (0.0-1.0).\n"
20216 "\n"
20217 ""},
20218 { "plscolor", _wrap_plscolor, METH_O, "\n"
20219 "Used to globally turn color output on/off\n"
20220 "\n"
20221 "DESCRIPTION:\n"
20222 "\n"
20223 " Used to globally turn color output on/off for those drivers/devices\n"
20224 " that support it.\n"
20225 "\n"
20226 " Redacted form: plscolor(color)\n"
20227 "\n"
20228 " This function is used in example 31.\n"
20229 "\n"
20230 "\n"
20231 "\n"
20232 "SYNOPSIS:\n"
20233 "\n"
20234 "plscolor(color)\n"
20235 "\n"
20236 "ARGUMENTS:\n"
20237 "\n"
20238 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20239 " turned off. If non-zero, color is turned on.\n"
20240 "\n"
20241 ""},
20242 { "plscompression", _wrap_plscompression, METH_O, "\n"
20243 "Set device-compression level\n"
20244 "\n"
20245 "DESCRIPTION:\n"
20246 "\n"
20247 " Set device-compression level. Only used for drivers that provide\n"
20248 " compression. This function, if used, should be invoked before a call\n"
20249 " to plinit.\n"
20250 "\n"
20251 " Redacted form: plscompression(compression)\n"
20252 "\n"
20253 " This function is used in example 31.\n"
20254 "\n"
20255 "\n"
20256 "\n"
20257 "SYNOPSIS:\n"
20258 "\n"
20259 "plscompression(compression)\n"
20260 "\n"
20261 "ARGUMENTS:\n"
20262 "\n"
20263 " compression (PLINT, input) : The desired compression level. This is\n"
20264 " a device-dependent value. Currently only the jpeg and png devices\n"
20265 " use these values. For jpeg value is the jpeg quality which should\n"
20266 " normally be in the range 0-95. Higher values denote higher quality\n"
20267 " and hence larger image sizes. For png values are in the range -1\n"
20268 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20269 " A value of -1 denotes the default zlib compression level. Values\n"
20270 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20271 " compression level. Higher compression levels correspond to greater\n"
20272 " compression and small file sizes at the expense of more\n"
20273 " computation.\n"
20274 "\n"
20275 ""},
20276 { "plsdev", _wrap_plsdev, METH_O, "\n"
20277 "Set the device (keyword) name\n"
20278 "\n"
20279 "DESCRIPTION:\n"
20280 "\n"
20281 " Set the device (keyword) name.\n"
20282 "\n"
20283 " Redacted form: plsdev(devname)\n"
20284 "\n"
20285 " This function is used in examples 1, 14, and 20.\n"
20286 "\n"
20287 "\n"
20288 "\n"
20289 "SYNOPSIS:\n"
20290 "\n"
20291 "plsdev(devname)\n"
20292 "\n"
20293 "ARGUMENTS:\n"
20294 "\n"
20295 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20296 " containing the device name keyword of the required output device.\n"
20297 " If\n"
20298 " devname is NULL or if the first character of the string is a ``?'',\n"
20299 " the normal (prompted) start up is used.\n"
20300 "\n"
20301 ""},
20302 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20303 "Set parameters that define current device-space window\n"
20304 "\n"
20305 "DESCRIPTION:\n"
20306 "\n"
20307 " Set relative margin width, aspect ratio, and relative justification\n"
20308 " that define current device-space window. If you want to just use the\n"
20309 " previous value for any of these, just pass in the magic value\n"
20310 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20311 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20312 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20313 " to a device-specific value.\n"
20314 "\n"
20315 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20316 "\n"
20317 " This function is used in example 31.\n"
20318 "\n"
20319 "\n"
20320 "\n"
20321 "SYNOPSIS:\n"
20322 "\n"
20323 "plsdidev(mar, aspect, jx, jy)\n"
20324 "\n"
20325 "ARGUMENTS:\n"
20326 "\n"
20327 " mar (PLFLT, input) : Relative margin width.\n"
20328 "\n"
20329 " aspect (PLFLT, input) : Aspect ratio.\n"
20330 "\n"
20331 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20332 " the range -0.5 to 0.5.\n"
20333 "\n"
20334 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20335 " the range -0.5 to 0.5.\n"
20336 "\n"
20337 ""},
20338 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20339 "Set up transformation from metafile coordinates\n"
20340 "\n"
20341 "DESCRIPTION:\n"
20342 "\n"
20343 " Set up transformation from metafile coordinates. The size of the plot\n"
20344 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20345 " general-purpose facility just yet (not sure why the user would need\n"
20346 " it, for one).\n"
20347 "\n"
20348 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20349 " dimypmm)\n"
20350 "\n"
20351 " This function is not used in any examples.\n"
20352 "\n"
20353 "\n"
20354 "\n"
20355 "SYNOPSIS:\n"
20356 "\n"
20357 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20358 "\n"
20359 "ARGUMENTS:\n"
20360 "\n"
20361 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20362 "\n"
20363 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20364 "\n"
20365 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20366 "\n"
20367 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20368 "\n"
20369 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20370 "\n"
20371 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20372 "\n"
20373 ""},
20374 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20375 "Set plot orientation\n"
20376 "\n"
20377 "DESCRIPTION:\n"
20378 "\n"
20379 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20380 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20381 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20382 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20383 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20384 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20385 " not called the default value of rot is 0.\n"
20386 "\n"
20387 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20388 " probably want to change the aspect ratio to a value suitable for the\n"
20389 " plot orientation using a call to plsdidev or the command-line options\n"
20390 " -a or -freeaspect. For more documentation of those options see the\n"
20391 " PLplot documentation. Such command-line options can be set internally\n"
20392 " using plsetopt or set directly using the command line and parsed using\n"
20393 " a call to plparseopts.\n"
20394 "\n"
20395 " Redacted form: plsdiori(rot)\n"
20396 "\n"
20397 " This function is not used in any examples.\n"
20398 "\n"
20399 "\n"
20400 "\n"
20401 "SYNOPSIS:\n"
20402 "\n"
20403 "plsdiori(rot)\n"
20404 "\n"
20405 "ARGUMENTS:\n"
20406 "\n"
20407 " rot (PLFLT, input) : Plot orientation parameter.\n"
20408 "\n"
20409 ""},
20410 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20411 "Set parameters that define current plot-space window\n"
20412 "\n"
20413 "DESCRIPTION:\n"
20414 "\n"
20415 " Set relative minima and maxima that define the current plot-space\n"
20416 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20417 " xmax, and ymax are 0., 0., 1., and 1.\n"
20418 "\n"
20419 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20420 "\n"
20421 " This function is used in example 31.\n"
20422 "\n"
20423 "\n"
20424 "\n"
20425 "SYNOPSIS:\n"
20426 "\n"
20427 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20428 "\n"
20429 "ARGUMENTS:\n"
20430 "\n"
20431 " xmin (PLFLT, input) : Relative minimum in x.\n"
20432 "\n"
20433 " ymin (PLFLT, input) : Relative minimum in y.\n"
20434 "\n"
20435 " xmax (PLFLT, input) : Relative maximum in x.\n"
20436 "\n"
20437 " ymax (PLFLT, input) : Relative maximum in y.\n"
20438 "\n"
20439 ""},
20440 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20441 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20442 "\n"
20443 "DESCRIPTION:\n"
20444 "\n"
20445 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20446 " the current plot-space window. This function has the same effect as\n"
20447 " plsdiplt if that function has not been previously called. Otherwise,\n"
20448 " this function implements zoom mode using the transformation min_used =\n"
20449 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20450 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20451 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20452 "\n"
20453 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20454 "\n"
20455 " This function is used in example 31.\n"
20456 "\n"
20457 "\n"
20458 "\n"
20459 "SYNOPSIS:\n"
20460 "\n"
20461 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20462 "\n"
20463 "ARGUMENTS:\n"
20464 "\n"
20465 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20466 "\n"
20467 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20468 "\n"
20469 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20470 "\n"
20471 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20472 "\n"
20473 ""},
20474 { "plseed", _wrap_plseed, METH_O, "\n"
20475 "Set seed for internal random number generator.\n"
20476 "\n"
20477 "DESCRIPTION:\n"
20478 "\n"
20479 " Set the seed for the internal random number generator. See plrandd for\n"
20480 " further details.\n"
20481 "\n"
20482 " Redacted form: plseed(seed)\n"
20483 "\n"
20484 " This function is used in example 21.\n"
20485 "\n"
20486 "\n"
20487 "\n"
20488 "SYNOPSIS:\n"
20489 "\n"
20490 "plseed(seed)\n"
20491 "\n"
20492 "ARGUMENTS:\n"
20493 "\n"
20494 " seed (unsigned int, input) : Seed for random number generator.\n"
20495 "\n"
20496 ""},
20497 { "plsesc", _wrap_plsesc, METH_O, "\n"
20498 "Set the escape character for text strings\n"
20499 "\n"
20500 "DESCRIPTION:\n"
20501 "\n"
20502 " Set the escape character for text strings. From C (in contrast to\n"
20503 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20504 " characters are allowed to prevent the user from shooting himself in\n"
20505 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20506 " use of backslash as a character escape). Here are the allowed escape\n"
20507 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20508 " #, ASCII 35\n"
20509 " $, ASCII 36\n"
20510 " %, ASCII 37\n"
20511 " &, ASCII 38\n"
20512 " *, ASCII 42\n"
20513 " @, ASCII 64\n"
20514 " ^, ASCII 94\n"
20515 " ~, ASCII 126\n"
20516 "\n"
20517 "\n"
20518 " Redacted form: General: plsesc(esc)\n"
20519 "\n"
20520 "\n"
20521 " This function is used in example 29.\n"
20522 "\n"
20523 "\n"
20524 "\n"
20525 "SYNOPSIS:\n"
20526 "\n"
20527 "plsesc(esc)\n"
20528 "\n"
20529 "ARGUMENTS:\n"
20530 "\n"
20531 " esc (char, input) : Escape character.\n"
20532 "\n"
20533 ""},
20534 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20535 "Set any command-line option\n"
20536 "\n"
20537 "DESCRIPTION:\n"
20538 "\n"
20539 " Set any command-line option internally from a program before it\n"
20540 " invokes plinit. opt is the name of the command-line option and optarg\n"
20541 " is the corresponding command-line option argument.\n"
20542 "\n"
20543 " This function returns 0 on success.\n"
20544 "\n"
20545 " Redacted form: plsetopt(opt, optarg)\n"
20546 "\n"
20547 " This function is used in example 14.\n"
20548 "\n"
20549 "\n"
20550 "\n"
20551 "SYNOPSIS:\n"
20552 "\n"
20553 "PLINT plsetopt(opt, optarg)\n"
20554 "\n"
20555 "ARGUMENTS:\n"
20556 "\n"
20557 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20558 " the command-line option.\n"
20559 "\n"
20560 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20561 " containing the argument of the command-line option.\n"
20562 "\n"
20563 ""},
20564 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20565 "Set family file parameters\n"
20566 "\n"
20567 "DESCRIPTION:\n"
20568 "\n"
20569 " Sets variables dealing with output file familying. Does nothing if\n"
20570 " familying not supported by the driver. This routine, if used, must be\n"
20571 " called before initializing PLplot. See the PLplot documentation for\n"
20572 " more information.\n"
20573 "\n"
20574 " Redacted form: plsfam(fam, num, bmax)\n"
20575 "\n"
20576 " This function is used in examples 14 and 31.\n"
20577 "\n"
20578 "\n"
20579 "\n"
20580 "SYNOPSIS:\n"
20581 "\n"
20582 "plsfam(fam, num, bmax)\n"
20583 "\n"
20584 "ARGUMENTS:\n"
20585 "\n"
20586 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20587 " is enabled.\n"
20588 "\n"
20589 " num (PLINT, input) : Current family file number.\n"
20590 "\n"
20591 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20592 " file.\n"
20593 "\n"
20594 ""},
20595 { "plsfci", _wrap_plsfci, METH_O, "\n"
20596 "Set FCI (font characterization integer)\n"
20597 "\n"
20598 "DESCRIPTION:\n"
20599 "\n"
20600 " Sets font characteristics to be used at the start of the next string\n"
20601 " using the FCI approach. See the PLplot documentation for more\n"
20602 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20603 " more user-friendly API for setting the font characterisitics.\n"
20604 "\n"
20605 " Redacted form: General: plsfci(fci)\n"
20606 "\n"
20607 "\n"
20608 " This function is used in example 23.\n"
20609 "\n"
20610 "\n"
20611 "\n"
20612 "SYNOPSIS:\n"
20613 "\n"
20614 "plsfci(fci)\n"
20615 "\n"
20616 "ARGUMENTS:\n"
20617 "\n"
20618 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20619 " of FCI.\n"
20620 "\n"
20621 ""},
20622 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20623 "Set output file name\n"
20624 "\n"
20625 "DESCRIPTION:\n"
20626 "\n"
20627 " Sets the current output file name, if applicable. If the file name\n"
20628 " has not been specified and is required by the driver, the user will be\n"
20629 " prompted for it. If using the X-windows output driver, this sets the\n"
20630 " display name. This routine, if used, must be called before\n"
20631 " initializing PLplot.\n"
20632 "\n"
20633 " Redacted form: plsfnam(fnam)\n"
20634 "\n"
20635 " This function is used in examples 1 and 20.\n"
20636 "\n"
20637 "\n"
20638 "\n"
20639 "SYNOPSIS:\n"
20640 "\n"
20641 "plsfnam(fnam)\n"
20642 "\n"
20643 "ARGUMENTS:\n"
20644 "\n"
20645 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20646 " the file name.\n"
20647 "\n"
20648 ""},
20649 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20650 "Set family, style and weight of the current font\n"
20651 "\n"
20652 "DESCRIPTION:\n"
20653 "\n"
20654 " Sets the current font. See the PLplot documentation for more\n"
20655 " information on font selection.\n"
20656 "\n"
20657 " Redacted form: plsfont(family, style, weight)\n"
20658 "\n"
20659 " This function is used in example 23.\n"
20660 "\n"
20661 "\n"
20662 "\n"
20663 "SYNOPSIS:\n"
20664 "\n"
20665 "plsfont(family, style, weight)\n"
20666 "\n"
20667 "ARGUMENTS:\n"
20668 "\n"
20669 " family (PLINT, input) : Font family to select for the current font.\n"
20670 " The available values are given by the PL_FCI_* constants in\n"
20671 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20672 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20673 " signifies that the font family should not be altered.\n"
20674 "\n"
20675 " style (PLINT, input) : Font style 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_UPRIGHT, PL_FCI_ITALIC and\n"
20678 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20679 " should not be altered.\n"
20680 "\n"
20681 " weight (PLINT, input) : Font weight 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_MEDIUM and PL_FCI_BOLD. A\n"
20684 " negative value signifies that the font weight should not be\n"
20685 " altered.\n"
20686 "\n"
20687 ""},
20688 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20689 "Shade regions on the basis of value\n"
20690 "\n"
20691 "DESCRIPTION:\n"
20692 "\n"
20693 " Shade regions on the basis of value. This is the high-level routine\n"
20694 " for making continuous color shaded plots with cmap1 while plshade\n"
20695 " should be used to plot individual shaded regions using either cmap0 or\n"
20696 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20697 " our supported languages.\n"
20698 "\n"
20699 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20700 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20701 " pltr_data)\n"
20702 "\n"
20703 "\n"
20704 " This function is used in examples 16, 21, and 22.\n"
20705 "\n"
20706 "\n"
20707 "\n"
20708 "SYNOPSIS:\n"
20709 "\n"
20710 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20711 "\n"
20712 "ARGUMENTS:\n"
20713 "\n"
20714 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20715 " plot. Should have dimensions of\n"
20716 " nx by\n"
20717 " ny.\n"
20718 "\n"
20719 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20720 "\n"
20721 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20722 "\n"
20723 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20724 " the region that should be plotted in the shade plot. This\n"
20725 " function accepts x and y coordinates as input arguments and must\n"
20726 " return 1 if the point is to be included in the shade plot and 0\n"
20727 " otherwise. If you want to plot the entire shade plot (the usual\n"
20728 " case), this argument should be set to NULL.\n"
20729 "\n"
20730 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20731 " pltr below for how these arguments are used (only for the special case\n"
20732 " when the callback function\n"
20733 " pltr is not supplied).\n"
20734 "\n"
20735 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20736 " corresponding to the edges of each shaded region that will be\n"
20737 " plotted by this function. To work properly the levels should be\n"
20738 " monotonic.\n"
20739 "\n"
20740 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20741 " of shade edge values in clevel).\n"
20742 "\n"
20743 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20744 " pattern.\n"
20745 "\n"
20746 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20747 " contours defining edges of shaded regions. The pen color is only\n"
20748 " temporary set for the contour drawing. Set this value to zero or\n"
20749 " less if no shade edge contours are wanted.\n"
20750 "\n"
20751 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20752 " defining edges of shaded regions. This value may not be honored\n"
20753 " by all drivers. The pen width is only temporary set for the\n"
20754 " contour drawing. Set this value to zero or less if no shade edge\n"
20755 " contours are wanted.\n"
20756 "\n"
20757 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20758 " region. Use plfill for this purpose.\n"
20759 "\n"
20760 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20761 " map to rectangles after coordinate transformation with pltrl.\n"
20762 " Otherwise, set rectangular to false. If rectangular is set to\n"
20763 " true, plshade tries to save time by filling large rectangles.\n"
20764 " This optimization fails if the coordinate transformation distorts\n"
20765 " the shape of rectangles. For example a plot in polar coordinates\n"
20766 " has to have rectangular set to false.\n"
20767 "\n"
20768 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20769 " defines the transformation between the zero-based indices of the\n"
20770 " matrix a and world coordinates. If\n"
20771 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20772 " indices of a are mapped to the range\n"
20773 " xmin through\n"
20774 " xmax and the y indices of a are mapped to the range\n"
20775 " ymin through\n"
20776 " ymax.For the C case, transformation functions are provided in the\n"
20777 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20778 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20779 " matrices. In addition, C callback routines for the transformation\n"
20780 " can be supplied by the user such as the mypltr function in\n"
20781 " examples/c/x09c.c which provides a general linear transformation\n"
20782 " between index coordinates and world coordinates.For languages\n"
20783 " other than C you should consult the PLplot documentation for the\n"
20784 " details concerning how PLTRANSFORM_callback arguments are\n"
20785 " interfaced. However, in general, a particular pattern of\n"
20786 " callback-associated arguments such as a tr vector with 6 elements;\n"
20787 " xg and yg vectors; or xg and yg matrices are respectively\n"
20788 " interfaced to a linear-transformation routine similar to the above\n"
20789 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20790 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20791 " support native language callbacks for handling index to\n"
20792 " world-coordinate transformations. Examples of these various\n"
20793 " approaches are given in examples/<language>x09*,\n"
20794 " examples/<language>x16*, examples/<language>x20*,\n"
20795 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20796 " supported languages.\n"
20797 "\n"
20798 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20799 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20800 " externally supplied.\n"
20801 "\n"
20802 ""},
20803 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20804 "Shade individual region on the basis of value\n"
20805 "\n"
20806 "DESCRIPTION:\n"
20807 "\n"
20808 " Shade individual region on the basis of value. Use plshades if you\n"
20809 " want to shade a number of contiguous regions using continuous colors.\n"
20810 " In particular the edge contours are treated properly in plshades. If\n"
20811 " you attempt to do contiguous regions with plshade the contours at the\n"
20812 " edge of the shade are partially obliterated by subsequent plots of\n"
20813 " contiguous shaded regions.\n"
20814 "\n"
20815 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20816 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20817 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20818 "\n"
20819 "\n"
20820 " This function is used in example 15.\n"
20821 "\n"
20822 "\n"
20823 "\n"
20824 "SYNOPSIS:\n"
20825 "\n"
20826 "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"
20827 "\n"
20828 "ARGUMENTS:\n"
20829 "\n"
20830 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20831 " plot. Should have dimensions of\n"
20832 " nx by\n"
20833 " ny.\n"
20834 "\n"
20835 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20836 "\n"
20837 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20838 "\n"
20839 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20840 " the region that should be plotted in the shade plot. This\n"
20841 " function accepts x and y coordinates as input arguments and must\n"
20842 " return 1 if the point is to be included in the shade plot and 0\n"
20843 " otherwise. If you want to plot the entire shade plot (the usual\n"
20844 " case), this argument should be set to NULL.\n"
20845 "\n"
20846 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20847 " pltr below for how these arguments are used (only for the special case\n"
20848 " when the callback function\n"
20849 " pltr is not supplied).\n"
20850 "\n"
20851 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20852 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20853 "\n"
20854 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20855 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20856 "\n"
20857 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20858 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20859 " then sh_color is interpreted as a cmap1 argument in the range\n"
20860 " (0.0-1.0).\n"
20861 "\n"
20862 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20863 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20864 "\n"
20865 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20866 "\n"
20867 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20868 " boundary of shaded region. The min values are used for the\n"
20869 " shade_min boundary, and the max values are used on the shade_max\n"
20870 " boundary. Set color and width to zero for no plotted boundaries.\n"
20871 "\n"
20872 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20873 " boundary of shaded region. The min values are used for the\n"
20874 " shade_min boundary, and the max values are used on the shade_max\n"
20875 " boundary. Set color and width to zero for no plotted boundaries.\n"
20876 "\n"
20877 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20878 " boundary of shaded region. The min values are used for the\n"
20879 " shade_min boundary, and the max values are used on the shade_max\n"
20880 " boundary. Set color and width to zero for no plotted boundaries.\n"
20881 "\n"
20882 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20883 " boundary of shaded region. The min values are used for the\n"
20884 " shade_min boundary, and the max values are used on the shade_max\n"
20885 " boundary. Set color and width to zero for no plotted boundaries.\n"
20886 "\n"
20887 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20888 " Use plfill. Future version of PLplot may have other fill\n"
20889 " routines.\n"
20890 "\n"
20891 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20892 " map to rectangles after coordinate transformation with pltrl.\n"
20893 " Otherwise, set rectangular to false. If rectangular is set to\n"
20894 " true, plshade tries to save time by filling large rectangles.\n"
20895 " This optimization fails if the coordinate transformation distorts\n"
20896 " the shape of rectangles. For example a plot in polar coordinates\n"
20897 " has to have rectangular set to false.\n"
20898 "\n"
20899 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20900 " defines the transformation between the zero-based indices of the\n"
20901 " matrix a and world coordinates. If\n"
20902 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20903 " indices of a are mapped to the range\n"
20904 " xmin through\n"
20905 " xmax and the y indices of a are mapped to the range\n"
20906 " ymin through\n"
20907 " ymax.For the C case, transformation functions are provided in the\n"
20908 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20909 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20910 " matrices. In addition, C callback routines for the transformation\n"
20911 " can be supplied by the user such as the mypltr function in\n"
20912 " examples/c/x09c.c which provides a general linear transformation\n"
20913 " between index coordinates and world coordinates.For languages\n"
20914 " other than C you should consult the PLplot documentation for the\n"
20915 " details concerning how PLTRANSFORM_callback arguments are\n"
20916 " interfaced. However, in general, a particular pattern of\n"
20917 " callback-associated arguments such as a tr vector with 6 elements;\n"
20918 " xg and yg vectors; or xg and yg matrices are respectively\n"
20919 " interfaced to a linear-transformation routine similar to the above\n"
20920 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20921 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20922 " support native language callbacks for handling index to\n"
20923 " world-coordinate transformations. Examples of these various\n"
20924 " approaches are given in examples/<language>x09*,\n"
20925 " examples/<language>x16*, examples/<language>x20*,\n"
20926 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20927 " supported languages.\n"
20928 "\n"
20929 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20930 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20931 " externally supplied.\n"
20932 "\n"
20933 ""},
20934 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20935 "Assign a function to use for generating custom axis labels\n"
20936 "\n"
20937 "DESCRIPTION:\n"
20938 "\n"
20939 " This function allows a user to provide their own function to provide\n"
20940 " axis label text. The user function is given the numeric value for a\n"
20941 " point on an axis and returns a string label to correspond with that\n"
20942 " value. Custom axis labels can be enabled by passing appropriate\n"
20943 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20944 "\n"
20945 " This function is used in example 19.\n"
20946 "\n"
20947 "\n"
20948 "\n"
20949 "SYNOPSIS:\n"
20950 "\n"
20951 "plslabelfunc(label_func, label_data)\n"
20952 "\n"
20953 "ARGUMENTS:\n"
20954 "\n"
20955 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20956 " label function. In order to reset to the default labelling, set\n"
20957 " this to NULL. The labelling function parameters are, in order:\n"
20958 " axis: This indicates which axis a label is being requested for.\n"
20959 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20960 "\n"
20961 " value: This is the value along the axis which is being labelled.\n"
20962 "\n"
20963 " label_text: The string representation of the label value.\n"
20964 "\n"
20965 " length: The maximum length in characters allowed for label_text.\n"
20966 "\n"
20967 "\n"
20968 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20969 " data to the label_func function.\n"
20970 "\n"
20971 ""},
20972 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20973 "Set length of major ticks\n"
20974 "\n"
20975 "DESCRIPTION:\n"
20976 "\n"
20977 " This sets up the length of the major ticks. The actual length is the\n"
20978 " product of the default length and a scaling factor as for character\n"
20979 " height.\n"
20980 "\n"
20981 " Redacted form: plsmaj(def, scale)\n"
20982 "\n"
20983 " This function is used in example 29.\n"
20984 "\n"
20985 "\n"
20986 "\n"
20987 "SYNOPSIS:\n"
20988 "\n"
20989 "plsmaj(def, scale)\n"
20990 "\n"
20991 "ARGUMENTS:\n"
20992 "\n"
20993 " def (PLFLT, input) : The default length of a major tick in\n"
20994 " millimeters, should be set to zero if the default length is to\n"
20995 " remain unchanged.\n"
20996 "\n"
20997 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20998 " actual tick length.\n"
20999 "\n"
21000 ""},
21001 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
21002 "Set the memory area to be plotted (RGB)\n"
21003 "\n"
21004 "DESCRIPTION:\n"
21005 "\n"
21006 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
21007 " the dev member of the stream structure. Also set the number of pixels\n"
21008 " in the memory passed in\n"
21009 " plotmem, which is a block of memory\n"
21010 " maxy by\n"
21011 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
21012 "\n"
21013 " This memory will have to be freed by the user!\n"
21014 "\n"
21015 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21016 "\n"
21017 " This function is not used in any examples.\n"
21018 "\n"
21019 "\n"
21020 "\n"
21021 "SYNOPSIS:\n"
21022 "\n"
21023 "plsmem(maxx, maxy, plotmem)\n"
21024 "\n"
21025 "ARGUMENTS:\n"
21026 "\n"
21027 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21028 "\n"
21029 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21030 "\n"
21031 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21032 " user-supplied writeable memory area.\n"
21033 "\n"
21034 ""},
21035 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21036 "Set the memory area to be plotted (RGBA)\n"
21037 "\n"
21038 "DESCRIPTION:\n"
21039 "\n"
21040 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21041 " dev member of the stream structure. Also set the number of pixels in\n"
21042 " the memory passed in\n"
21043 " plotmem, which is a block of memory\n"
21044 " maxy by\n"
21045 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21046 "\n"
21047 " This memory will have to be freed by the user!\n"
21048 "\n"
21049 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21050 "\n"
21051 " This function is not used in any examples.\n"
21052 "\n"
21053 "\n"
21054 "\n"
21055 "SYNOPSIS:\n"
21056 "\n"
21057 "plsmema(maxx, maxy, plotmem)\n"
21058 "\n"
21059 "ARGUMENTS:\n"
21060 "\n"
21061 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21062 "\n"
21063 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21064 "\n"
21065 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21066 " user-supplied writeable memory area.\n"
21067 "\n"
21068 ""},
21069 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21070 "Set length of minor ticks\n"
21071 "\n"
21072 "DESCRIPTION:\n"
21073 "\n"
21074 " This sets up the length of the minor ticks and the length of the\n"
21075 " terminals on error bars. The actual length is the product of the\n"
21076 " default length and a scaling factor as for character height.\n"
21077 "\n"
21078 " Redacted form: plsmin(def, scale)\n"
21079 "\n"
21080 " This function is used in example 29.\n"
21081 "\n"
21082 "\n"
21083 "\n"
21084 "SYNOPSIS:\n"
21085 "\n"
21086 "plsmin(def, scale)\n"
21087 "\n"
21088 "ARGUMENTS:\n"
21089 "\n"
21090 " def (PLFLT, input) : The default length of a minor tick in\n"
21091 " millimeters, should be set to zero if the default length is to\n"
21092 " remain unchanged.\n"
21093 "\n"
21094 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21095 " actual tick length.\n"
21096 "\n"
21097 ""},
21098 { "plsori", _wrap_plsori, METH_O, "\n"
21099 "Set orientation\n"
21100 "\n"
21101 "DESCRIPTION:\n"
21102 "\n"
21103 " Set integer plot orientation parameter. This function is identical to\n"
21104 " plsdiori except for the type of the argument, and should be used in\n"
21105 " the same way. See the documentation of plsdiori for details.\n"
21106 "\n"
21107 " Redacted form: plsori(ori)\n"
21108 "\n"
21109 " This function is used in example 3.\n"
21110 "\n"
21111 "\n"
21112 "\n"
21113 "SYNOPSIS:\n"
21114 "\n"
21115 "plsori(ori)\n"
21116 "\n"
21117 "ARGUMENTS:\n"
21118 "\n"
21119 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21120 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21121 " angle.\n"
21122 "\n"
21123 ""},
21124 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21125 "Set page parameters\n"
21126 "\n"
21127 "DESCRIPTION:\n"
21128 "\n"
21129 " Sets the page configuration (optional). If an individual parameter is\n"
21130 " zero then that parameter value is not updated. Not all parameters are\n"
21131 " recognized by all drivers and the interpretation is device-dependent.\n"
21132 " The X-window driver uses the length and offset parameters to determine\n"
21133 " the window size and location. The length and offset values are\n"
21134 " expressed in units that are specific to the current driver. For\n"
21135 " instance: screen drivers will usually interpret them as number of\n"
21136 " pixels, whereas printer drivers will usually use mm.\n"
21137 "\n"
21138 " This routine, if used, must be called before initializing PLplot. It\n"
21139 " may be called at later times for interactive drivers to change only\n"
21140 " the dpi for subsequent redraws which you can force via a call to\n"
21141 " plreplot. If this function is not called then the page size defaults\n"
21142 " to landscape A4 for drivers which use real world page sizes and 744\n"
21143 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21144 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21145 "\n"
21146 "\n"
21147 "\n"
21148 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21149 "\n"
21150 " This function is used in examples 14 and 31.\n"
21151 "\n"
21152 "\n"
21153 "\n"
21154 "SYNOPSIS:\n"
21155 "\n"
21156 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21157 "\n"
21158 "ARGUMENTS:\n"
21159 "\n"
21160 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21161 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21162 " (e.g. mm).\n"
21163 "\n"
21164 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21165 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21166 " (e.g. mm).\n"
21167 "\n"
21168 " xleng (PLINT, input) : Page length, x.\n"
21169 "\n"
21170 " yleng (PLINT, input) : Page length, y.\n"
21171 "\n"
21172 " xoff (PLINT, input) : Page offset, x.\n"
21173 "\n"
21174 " yoff (PLINT, input) : Page offset, y.\n"
21175 "\n"
21176 ""},
21177 { "plspal0", _wrap_plspal0, METH_O, "\n"
21178 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21179 "\n"
21180 "DESCRIPTION:\n"
21181 "\n"
21182 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21183 "\n"
21184 " Redacted form: plspal0(filename)\n"
21185 "\n"
21186 " This function is in example 16.\n"
21187 "\n"
21188 "\n"
21189 "\n"
21190 "SYNOPSIS:\n"
21191 "\n"
21192 "plspal0(filename)\n"
21193 "\n"
21194 "ARGUMENTS:\n"
21195 "\n"
21196 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21197 " containing the name of the cmap0*.pal file. If this string is\n"
21198 " empty, use the default cmap0*.pal file.\n"
21199 "\n"
21200 ""},
21201 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21202 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21203 "\n"
21204 "DESCRIPTION:\n"
21205 "\n"
21206 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21207 "\n"
21208 " Redacted form: plspal1(filename, interpolate)\n"
21209 "\n"
21210 " This function is used in example 16.\n"
21211 "\n"
21212 "\n"
21213 "\n"
21214 "SYNOPSIS:\n"
21215 "\n"
21216 "plspal1(filename, interpolate)\n"
21217 "\n"
21218 "ARGUMENTS:\n"
21219 "\n"
21220 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21221 " containing the name of the cmap1*.pal file. If this string is\n"
21222 " empty, use the default cmap1*.pal file.\n"
21223 "\n"
21224 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21225 " columns containing the intensity index, r, g, b, alpha and\n"
21226 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21227 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21228 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21229 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21230 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21231 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21232 " are used instead to set the cmap1 palette directly with a call to\n"
21233 " plscmap1a.\n"
21234 "\n"
21235 ""},
21236 { "plspause", _wrap_plspause, METH_O, "\n"
21237 "Set the pause (on end-of-page) status\n"
21238 "\n"
21239 "DESCRIPTION:\n"
21240 "\n"
21241 " Set the pause (on end-of-page) status.\n"
21242 "\n"
21243 " Redacted form: plspause(pause)\n"
21244 "\n"
21245 " This function is in examples 14,20.\n"
21246 "\n"
21247 "\n"
21248 "\n"
21249 "SYNOPSIS:\n"
21250 "\n"
21251 "plspause(pause)\n"
21252 "\n"
21253 "ARGUMENTS:\n"
21254 "\n"
21255 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21256 " end-of-page for those drivers which support this. Otherwise there\n"
21257 " is no pause.\n"
21258 "\n"
21259 ""},
21260 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21261 "Set current output stream\n"
21262 "\n"
21263 "DESCRIPTION:\n"
21264 "\n"
21265 " Sets the number of the current output stream. The stream number\n"
21266 " defaults to 0 unless changed by this routine. The first use of this\n"
21267 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21268 "\n"
21269 " Redacted form: plsstrm(strm)\n"
21270 "\n"
21271 " This function is examples 1,14,20.\n"
21272 "\n"
21273 "\n"
21274 "\n"
21275 "SYNOPSIS:\n"
21276 "\n"
21277 "plsstrm(strm)\n"
21278 "\n"
21279 "ARGUMENTS:\n"
21280 "\n"
21281 " strm (PLINT, input) : The current stream number.\n"
21282 "\n"
21283 ""},
21284 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21285 "Set the number of subpages in x and y\n"
21286 "\n"
21287 "DESCRIPTION:\n"
21288 "\n"
21289 " Set the number of subpages in x and y.\n"
21290 "\n"
21291 " Redacted form: plssub(nx, ny)\n"
21292 "\n"
21293 " This function is examples 1,2,14,21,25,27.\n"
21294 "\n"
21295 "\n"
21296 "\n"
21297 "SYNOPSIS:\n"
21298 "\n"
21299 "plssub(nx, ny)\n"
21300 "\n"
21301 "ARGUMENTS:\n"
21302 "\n"
21303 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21304 " of window columns).\n"
21305 "\n"
21306 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21307 " of window rows).\n"
21308 "\n"
21309 ""},
21310 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21311 "Set symbol size\n"
21312 "\n"
21313 "DESCRIPTION:\n"
21314 "\n"
21315 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21316 " plsym. The actual height of a symbol is the product of the default\n"
21317 " symbol size and a scaling factor as for the character height.\n"
21318 "\n"
21319 " Redacted form: plssym(def, scale)\n"
21320 "\n"
21321 " This function is used in example 29.\n"
21322 "\n"
21323 "\n"
21324 "\n"
21325 "SYNOPSIS:\n"
21326 "\n"
21327 "plssym(def, scale)\n"
21328 "\n"
21329 "ARGUMENTS:\n"
21330 "\n"
21331 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21332 " should be set to zero if the default height is to remain\n"
21333 " unchanged.\n"
21334 "\n"
21335 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21336 " actual symbol height.\n"
21337 "\n"
21338 ""},
21339 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21340 "Initialization\n"
21341 "\n"
21342 "DESCRIPTION:\n"
21343 "\n"
21344 " Initializing the plotting package. The program prompts for the device\n"
21345 " keyword or number of the desired output device. Hitting a RETURN in\n"
21346 " response to the prompt is the same as selecting the first device. If\n"
21347 " only one device is enabled when PLplot is installed, plstar will issue\n"
21348 " no prompt. The output device is divided into nx by ny subpages, each\n"
21349 " of which may be used independently. The subroutine pladv is used to\n"
21350 " advance from one subpage to the next.\n"
21351 "\n"
21352 " Redacted form: plstar(nx, ny)\n"
21353 "\n"
21354 " This function is used in example 1.\n"
21355 "\n"
21356 "\n"
21357 "\n"
21358 "SYNOPSIS:\n"
21359 "\n"
21360 "plstar(nx, ny)\n"
21361 "\n"
21362 "ARGUMENTS:\n"
21363 "\n"
21364 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21365 " x direction.\n"
21366 "\n"
21367 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21368 " y direction.\n"
21369 "\n"
21370 ""},
21371 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21372 "Initialization\n"
21373 "\n"
21374 "DESCRIPTION:\n"
21375 "\n"
21376 " Alternative to plstar for initializing the plotting package. The\n"
21377 " device name keyword for the desired output device must be supplied as\n"
21378 " an argument. These keywords are the same as those printed out by\n"
21379 " plstar. If the requested device is not available, or if the input\n"
21380 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21381 " is used. This routine also divides the output device page into nx by\n"
21382 " ny subpages, each of which may be used independently. The subroutine\n"
21383 " pladv is used to advance from one subpage to the next.\n"
21384 "\n"
21385 " Redacted form: General: plstart(devname, nx, ny)\n"
21386 "\n"
21387 "\n"
21388 " This function is not used in any examples.\n"
21389 "\n"
21390 "\n"
21391 "\n"
21392 "SYNOPSIS:\n"
21393 "\n"
21394 "plstart(devname, nx, ny)\n"
21395 "\n"
21396 "ARGUMENTS:\n"
21397 "\n"
21398 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21399 " containing the device name keyword of the required output device.\n"
21400 " If\n"
21401 " devname is NULL or if the first character of the string is a ``?'',\n"
21402 " the normal (prompted) start up is used.\n"
21403 "\n"
21404 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21405 " x direction.\n"
21406 "\n"
21407 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21408 " y direction.\n"
21409 "\n"
21410 ""},
21411 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21412 "Set a global coordinate transform function\n"
21413 "\n"
21414 "DESCRIPTION:\n"
21415 "\n"
21416 " This function can be used to define a coordinate transformation which\n"
21417 " affects all elements drawn within the current plot window. The\n"
21418 " coordinate_transform callback function is similar to that provided for\n"
21419 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21420 " parameter may be used to pass extra data to coordinate_transform.\n"
21421 "\n"
21422 " Redacted form: General: plstransform(coordinate_transform,\n"
21423 " coordinate_transform_data)\n"
21424 "\n"
21425 "\n"
21426 " This function is used in examples 19 and 22.\n"
21427 "\n"
21428 "\n"
21429 "\n"
21430 "SYNOPSIS:\n"
21431 "\n"
21432 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21433 "\n"
21434 "ARGUMENTS:\n"
21435 "\n"
21436 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21437 " function that defines the transformation from the input (x, y)\n"
21438 " world coordinates to new PLplot world coordinates. If\n"
21439 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21440 " case), then no transform is applied.\n"
21441 "\n"
21442 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21443 " for\n"
21444 " coordinate_transform.\n"
21445 "\n"
21446 ""},
21447 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21448 "Plot a glyph at the specified points\n"
21449 "\n"
21450 "DESCRIPTION:\n"
21451 "\n"
21452 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21453 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21454 " is specified with a PLplot user string. Note that the user string is\n"
21455 " not actually limited to one glyph so it is possible (but not normally\n"
21456 " useful) to plot more than one glyph at the specified points with this\n"
21457 " function. As with plmtex and plptex, the user string can contain FCI\n"
21458 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21459 " else PLplot escapes for Hershey or unicode text to determine the\n"
21460 " glyph.\n"
21461 "\n"
21462 " Redacted form: plstring(x, y, string)\n"
21463 "\n"
21464 " This function is used in examples 4, 21 and 26.\n"
21465 "\n"
21466 "\n"
21467 "\n"
21468 "SYNOPSIS:\n"
21469 "\n"
21470 "plstring(n, x, y, string)\n"
21471 "\n"
21472 "ARGUMENTS:\n"
21473 "\n"
21474 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21475 "\n"
21476 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21477 " the points.\n"
21478 "\n"
21479 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21480 " the points.\n"
21481 "\n"
21482 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21483 " the glyph(s) to be plotted at each of the n points.\n"
21484 "\n"
21485 ""},
21486 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21487 "Plot a glyph at the specified 3D points\n"
21488 "\n"
21489 "DESCRIPTION:\n"
21490 "\n"
21491 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21492 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21493 " this function similar to what is done for plline3. The glyph is\n"
21494 " specified with a PLplot user string. Note that the user string is not\n"
21495 " actually limited to one glyph so it is possible (but not normally\n"
21496 " useful) to plot more than one glyph at the specified points with this\n"
21497 " function. As with plmtex and plptex, the user string can contain FCI\n"
21498 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21499 " else PLplot escapes for Hershey or unicode text to determine the\n"
21500 " glyph.\n"
21501 "\n"
21502 " Redacted form: plstring3(x, y, z, string)\n"
21503 "\n"
21504 " This function is used in example 18.\n"
21505 "\n"
21506 "\n"
21507 "\n"
21508 "SYNOPSIS:\n"
21509 "\n"
21510 "plstring3(n, x, y, z, string)\n"
21511 "\n"
21512 "ARGUMENTS:\n"
21513 "\n"
21514 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21515 "\n"
21516 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21517 " the points.\n"
21518 "\n"
21519 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21520 " the points.\n"
21521 "\n"
21522 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21523 " the points.\n"
21524 "\n"
21525 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21526 " the glyph(s) to be plotted at each of the n points. points.\n"
21527 "\n"
21528 ""},
21529 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21530 "Add a point to a strip chart\n"
21531 "\n"
21532 "DESCRIPTION:\n"
21533 "\n"
21534 " Add a point to a given pen of a given strip chart. There is no need\n"
21535 " for all pens to have the same number of points or to be equally\n"
21536 " sampled in the x coordinate. Allocates memory and rescales as\n"
21537 " necessary.\n"
21538 "\n"
21539 " Redacted form: plstripa(id, pen, x, y)\n"
21540 "\n"
21541 " This function is used in example 17.\n"
21542 "\n"
21543 "\n"
21544 "\n"
21545 "SYNOPSIS:\n"
21546 "\n"
21547 "plstripa(id, pen, x, y)\n"
21548 "\n"
21549 "ARGUMENTS:\n"
21550 "\n"
21551 " id (PLINT, input) : Identification number of the strip chart (set\n"
21552 " up in plstripc).\n"
21553 "\n"
21554 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21555 "\n"
21556 " x (PLFLT, input) : X coordinate of point to plot.\n"
21557 "\n"
21558 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21559 "\n"
21560 ""},
21561 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21562 "Create a 4-pen strip chart\n"
21563 "\n"
21564 "DESCRIPTION:\n"
21565 "\n"
21566 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21567 "\n"
21568 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21569 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21570 " styline, legline, labx, laby, labz)\n"
21571 "\n"
21572 "\n"
21573 " This function is used in example 17.\n"
21574 "\n"
21575 "\n"
21576 "\n"
21577 "SYNOPSIS:\n"
21578 "\n"
21579 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21580 "\n"
21581 "ARGUMENTS:\n"
21582 "\n"
21583 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21584 " number of the strip chart to use on plstripa and plstripd.\n"
21585 "\n"
21586 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21587 " the x-axis specification as in plbox.\n"
21588 "\n"
21589 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21590 " the y-axis specification as in plbox.\n"
21591 "\n"
21592 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21593 " change as data are added.\n"
21594 "\n"
21595 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21596 " change as data are added.\n"
21597 "\n"
21598 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21599 " is multiplied by the factor (1 +\n"
21600 " xjump) .\n"
21601 "\n"
21602 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21603 " change as data are added.\n"
21604 "\n"
21605 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21606 " change as data are added.\n"
21607 "\n"
21608 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21609 "\n"
21610 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21611 "\n"
21612 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21613 " true, otherwise not.\n"
21614 "\n"
21615 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21616 " otherwise slide display.\n"
21617 "\n"
21618 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21619 "\n"
21620 " collab (PLINT, input) : Legend color index (cmap0).\n"
21621 "\n"
21622 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21623 " indices for the 4 pens.\n"
21624 "\n"
21625 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21626 " indices for the 4 pens.\n"
21627 "\n"
21628 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21629 " strings containing legends for the 4 pens.\n"
21630 "\n"
21631 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21632 " the label for the x axis.\n"
21633 "\n"
21634 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21635 " the label for the y axis.\n"
21636 "\n"
21637 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21638 " the plot title.\n"
21639 "\n"
21640 ""},
21641 { "plstripd", _wrap_plstripd, METH_O, "\n"
21642 "Deletes and releases memory used by a strip chart\n"
21643 "\n"
21644 "DESCRIPTION:\n"
21645 "\n"
21646 " Deletes and releases memory used by a strip chart.\n"
21647 "\n"
21648 " Redacted form: plstripd(id)\n"
21649 "\n"
21650 " This function is used in example 17.\n"
21651 "\n"
21652 "\n"
21653 "\n"
21654 "SYNOPSIS:\n"
21655 "\n"
21656 "plstripd(id)\n"
21657 "\n"
21658 "ARGUMENTS:\n"
21659 "\n"
21660 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21661 "\n"
21662 ""},
21663 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21664 "Set line style\n"
21665 "\n"
21666 "DESCRIPTION:\n"
21667 "\n"
21668 " This sets up the line style for all lines subsequently drawn. A line\n"
21669 " consists of segments in which the pen is alternately down and up. The\n"
21670 " lengths of these segments are passed in the vectors mark and space\n"
21671 " respectively. The number of mark-space pairs is specified by nms. In\n"
21672 " order to return the line style to the default continuous line, plstyl\n"
21673 " should be called with nms =0 .(see also pllsty)\n"
21674 "\n"
21675 " Redacted form: plstyl(mark, space)\n"
21676 "\n"
21677 " This function is used in examples 1, 9, and 14.\n"
21678 "\n"
21679 "\n"
21680 "\n"
21681 "SYNOPSIS:\n"
21682 "\n"
21683 "plstyl(nms, mark, space)\n"
21684 "\n"
21685 "ARGUMENTS:\n"
21686 "\n"
21687 " nms (PLINT, input) : The number of mark and space elements in a\n"
21688 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21689 " . A continuous line is specified by setting nms=0 .\n"
21690 "\n"
21691 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21692 " segments during which the pen is down, measured in micrometers.\n"
21693 "\n"
21694 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21695 " the segments during which the pen is up, measured in micrometers.\n"
21696 "\n"
21697 ""},
21698 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21699 "Set arrow style for vector plots\n"
21700 "\n"
21701 "DESCRIPTION:\n"
21702 "\n"
21703 " Set the style for the arrow used by plvect to plot vectors.\n"
21704 "\n"
21705 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21706 "\n"
21707 " This function is used in example 22.\n"
21708 "\n"
21709 "\n"
21710 "\n"
21711 "SYNOPSIS:\n"
21712 "\n"
21713 "plsvect(arrowx, arrowy, npts, fill)\n"
21714 "\n"
21715 "ARGUMENTS:\n"
21716 "\n"
21717 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21718 " the x and y points which make up the arrow. The arrow is plotted\n"
21719 " by joining these points to form a polygon. The scaling assumes\n"
21720 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21721 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21722 " will be reset to its default.\n"
21723 "\n"
21724 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21725 " arrowy.\n"
21726 "\n"
21727 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21728 " fill is false then the arrow is open.\n"
21729 "\n"
21730 ""},
21731 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21732 "Specify viewport in absolute coordinates\n"
21733 "\n"
21734 "DESCRIPTION:\n"
21735 "\n"
21736 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21737 " should be used only if the viewport is required to have a definite\n"
21738 " size in millimeters. The routine plgspa is useful for finding out the\n"
21739 " size of the current subpage.\n"
21740 "\n"
21741 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21742 "\n"
21743 " This function is used in example 10.\n"
21744 "\n"
21745 "\n"
21746 "\n"
21747 "SYNOPSIS:\n"
21748 "\n"
21749 "plsvpa(xmin, xmax, ymin, ymax)\n"
21750 "\n"
21751 "ARGUMENTS:\n"
21752 "\n"
21753 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21754 " viewport from the left-hand edge of the subpage in millimeters.\n"
21755 "\n"
21756 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21757 " viewport from the left-hand edge of the subpage in millimeters.\n"
21758 "\n"
21759 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21760 " viewport from the bottom edge of the subpage in millimeters.\n"
21761 "\n"
21762 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21763 " from the bottom edge of the subpage in millimeters.\n"
21764 "\n"
21765 ""},
21766 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21767 "Set x axis parameters\n"
21768 "\n"
21769 "DESCRIPTION:\n"
21770 "\n"
21771 " Sets values of the digmax and digits flags for the x axis. See the\n"
21772 " PLplot documentation for more information.\n"
21773 "\n"
21774 " Redacted form: plsxax(digmax, digits)\n"
21775 "\n"
21776 " This function is used in example 31.\n"
21777 "\n"
21778 "\n"
21779 "\n"
21780 "SYNOPSIS:\n"
21781 "\n"
21782 "plsxax(digmax, digits)\n"
21783 "\n"
21784 "ARGUMENTS:\n"
21785 "\n"
21786 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21787 " digits for the x axis. If nonzero, the printed label will be\n"
21788 " switched to a floating-point representation when the number of\n"
21789 " digits exceeds digmax.\n"
21790 "\n"
21791 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21792 " its value here has no effect since it is set only by plbox or\n"
21793 " plbox3. However, the user may obtain its value after a call to\n"
21794 " either of these functions by calling plgxax.\n"
21795 "\n"
21796 ""},
21797 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21798 "Set y axis parameters\n"
21799 "\n"
21800 "DESCRIPTION:\n"
21801 "\n"
21802 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21803 " the description of plsxax for more detail.\n"
21804 "\n"
21805 " Redacted form: plsyax(digmax, digits)\n"
21806 "\n"
21807 " This function is used in examples 1, 14, and 31.\n"
21808 "\n"
21809 "\n"
21810 "\n"
21811 "SYNOPSIS:\n"
21812 "\n"
21813 "plsyax(digmax, digits)\n"
21814 "\n"
21815 "ARGUMENTS:\n"
21816 "\n"
21817 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21818 " digits for the y axis. If nonzero, the printed label will be\n"
21819 " switched to a floating-point representation when the number of\n"
21820 " digits exceeds digmax.\n"
21821 "\n"
21822 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21823 " its value here has no effect since it is set only by plbox or\n"
21824 " plbox3. However, the user may obtain its value after a call to\n"
21825 " either of these functions by calling plgyax.\n"
21826 "\n"
21827 ""},
21828 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21829 "Plot a glyph at the specified points\n"
21830 "\n"
21831 "DESCRIPTION:\n"
21832 "\n"
21833 " Plot a glyph at the specified points. (This function is largely\n"
21834 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21835 "\n"
21836 " Redacted form: plsym(x, y, code)\n"
21837 "\n"
21838 " This function is used in example 7.\n"
21839 "\n"
21840 "\n"
21841 "\n"
21842 "SYNOPSIS:\n"
21843 "\n"
21844 "plsym(n, x, y, code)\n"
21845 "\n"
21846 "ARGUMENTS:\n"
21847 "\n"
21848 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21849 "\n"
21850 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21851 " the points.\n"
21852 "\n"
21853 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21854 " the points.\n"
21855 "\n"
21856 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21857 " to be plotted at each of the n points.\n"
21858 "\n"
21859 ""},
21860 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21861 "Set z axis parameters\n"
21862 "\n"
21863 "DESCRIPTION:\n"
21864 "\n"
21865 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21866 " the description of plsxax for more detail.\n"
21867 "\n"
21868 " Redacted form: plszax(digmax, digits)\n"
21869 "\n"
21870 " This function is used in example 31.\n"
21871 "\n"
21872 "\n"
21873 "\n"
21874 "SYNOPSIS:\n"
21875 "\n"
21876 "plszax(digmax, digits)\n"
21877 "\n"
21878 "ARGUMENTS:\n"
21879 "\n"
21880 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21881 " digits for the z axis. If nonzero, the printed label will be\n"
21882 " switched to a floating-point representation when the number of\n"
21883 " digits exceeds digmax.\n"
21884 "\n"
21885 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21886 " its value here has no effect since it is set only by plbox or\n"
21887 " plbox3. However, the user may obtain its value after a call to\n"
21888 " either of these functions by calling plgzax.\n"
21889 "\n"
21890 ""},
21891 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21892 "Switch to text screen\n"
21893 "\n"
21894 "DESCRIPTION:\n"
21895 "\n"
21896 " Sets an interactive device to text mode, used in conjunction with\n"
21897 " plgra to allow graphics and text to be interspersed. On a device\n"
21898 " which supports separate text and graphics windows, this command causes\n"
21899 " control to be switched to the text window. This can be useful for\n"
21900 " printing diagnostic messages or getting user input, which would\n"
21901 " otherwise interfere with the plots. The program must switch back to\n"
21902 " the graphics window before issuing plot commands, as the text (or\n"
21903 " console) device will probably become quite confused otherwise. If\n"
21904 " already in text mode, this command is ignored. It is also ignored on\n"
21905 " devices which only support a single window or use a different method\n"
21906 " for shifting focus (see also plgra).\n"
21907 "\n"
21908 " Redacted form: pltext()\n"
21909 "\n"
21910 " This function is used in example 1.\n"
21911 "\n"
21912 "\n"
21913 "\n"
21914 "SYNOPSIS:\n"
21915 "\n"
21916 "pltext()\n"
21917 "\n"
21918 ""},
21919 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21920 "Set format for date / time labels\n"
21921 "\n"
21922 "DESCRIPTION:\n"
21923 "\n"
21924 " Sets the format for date / time labels. To enable date / time format\n"
21925 " labels see the options to plbox, plbox3, and plenv.\n"
21926 "\n"
21927 " Redacted form: pltimefmt(fmt)\n"
21928 "\n"
21929 " This function is used in example 29.\n"
21930 "\n"
21931 "\n"
21932 "\n"
21933 "SYNOPSIS:\n"
21934 "\n"
21935 "pltimefmt(fmt)\n"
21936 "\n"
21937 "ARGUMENTS:\n"
21938 "\n"
21939 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21940 " interpreted similarly to the format specifier of typical system\n"
21941 " strftime routines except that PLplot ignores locale and also\n"
21942 " supplies some useful extensions in the context of plotting. All\n"
21943 " text in the string is printed as-is other than conversion\n"
21944 " specifications which take the form of a '%' character followed by\n"
21945 " further conversion specification character. The conversion\n"
21946 " specifications which are similar to those provided by system\n"
21947 " strftime routines are the following: %a: The abbreviated (English)\n"
21948 " weekday name.\n"
21949 " %A: The full (English) weekday name.\n"
21950 " %b: The abbreviated (English) month name.\n"
21951 " %B: The full (English) month name.\n"
21952 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21953 " %C: The century number (year/100) as a 2-digit integer.\n"
21954 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21955 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21956 " %e: Like %d, but a leading zero is replaced by a space.\n"
21957 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21958 " %h: Equivalent to %b.\n"
21959 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21960 " 00 to 23).\n"
21961 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21962 " 01 to 12).\n"
21963 " %j: The day of the year as a decimal number (range 001 to\n"
21964 " 366).\n"
21965 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21966 " 23); single digits are preceded by a blank. (See also %H.)\n"
21967 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21968 " 12); single digits are preceded by a blank. (See also %I.)\n"
21969 " %m: The month as a decimal number (range 01 to 12).\n"
21970 " %M: The minute as a decimal number (range 00 to 59).\n"
21971 " %n: A newline character.\n"
21972 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21973 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21974 " %r: Equivalent to %I:%M:%S %p.\n"
21975 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21976 " including the seconds, see %T below.\n"
21977 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21978 " +0000 (UTC).\n"
21979 " %S: The second as a decimal number (range 00 to 60). (The\n"
21980 " range is up to 60 to allow for occasional leap seconds.)\n"
21981 " %t: A tab character.\n"
21982 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21983 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21984 " being 1. See also %w.\n"
21985 " %U: The week number of the current year as a decimal number,\n"
21986 " range 00 to 53, starting with the first Sunday as the first\n"
21987 " day of week 01. See also %V and %W.\n"
21988 " %v: Equivalent to %e-%b-%Y.\n"
21989 " %V: The ISO 8601 week number of the current year as a decimal\n"
21990 " number, range 01 to 53, where week 1 is the first week that\n"
21991 " has at least 4 days in the new year. See also %U and %W.\n"
21992 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21993 " being 0. See also %u.\n"
21994 " %W: The week number of the current year as a decimal number,\n"
21995 " range 00 to 53, starting with the first Monday as the first\n"
21996 " day of week 01.\n"
21997 " %x: Equivalent to %a %b %d %Y.\n"
21998 " %X: Equivalent to %T.\n"
21999 " %y: The year as a decimal number without a century (range 00\n"
22000 " to 99).\n"
22001 " %Y: The year as a decimal number including a century.\n"
22002 " %z: The UTC time-zone string = \"+0000\".\n"
22003 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
22004 " %+: The UTC date and time in default format of the Unix date\n"
22005 " command which is equivalent to %a %b %d %T %Z %Y.\n"
22006 " %%: A literal \"%\" character.\n"
22007 " The conversion specifications which are extensions to those normally\n"
22008 " provided by system strftime routines are the following: %(0-9):\n"
22009 " The fractional part of the seconds field (including leading\n"
22010 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
22011 " seconds to millisecond accuracy (00.000).\n"
22012 " %.: The fractional part of the seconds field (including\n"
22013 " leading decimal point) to the maximum available accuracy. Thus\n"
22014 " %S%. would give seconds with fractional part up to 9 decimal\n"
22015 " places if available.\n"
22016 "\n"
22017 ""},
22018 { "plvasp", _wrap_plvasp, METH_O, "\n"
22019 "Specify viewport using aspect ratio only\n"
22020 "\n"
22021 "DESCRIPTION:\n"
22022 "\n"
22023 " Selects the largest viewport with the given aspect ratio within the\n"
22024 " subpage that leaves a standard margin (left-hand margin of eight\n"
22025 " character heights, and a margin around the other three sides of five\n"
22026 " character heights).\n"
22027 "\n"
22028 " Redacted form: plvasp(aspect)\n"
22029 "\n"
22030 " This function is used in example 13.\n"
22031 "\n"
22032 "\n"
22033 "\n"
22034 "SYNOPSIS:\n"
22035 "\n"
22036 "plvasp(aspect)\n"
22037 "\n"
22038 "ARGUMENTS:\n"
22039 "\n"
22040 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22041 " axis of resulting viewport.\n"
22042 "\n"
22043 ""},
22044 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22045 "Vector plot\n"
22046 "\n"
22047 "DESCRIPTION:\n"
22048 "\n"
22049 " Draws a plot of vector data contained in the matrices (\n"
22050 " u[\n"
22051 " nx][\n"
22052 " ny],\n"
22053 " v[\n"
22054 " nx][\n"
22055 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22056 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22057 " additional data required by the transformation routine to map indices\n"
22058 " within the matrices to the world coordinates. The style of the vector\n"
22059 " arrow may be set using plsvect.\n"
22060 "\n"
22061 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22062 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22063 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22064 " with either one or two dimensions.\n"
22065 "\n"
22066 " This function is used in example 22.\n"
22067 "\n"
22068 "\n"
22069 "\n"
22070 "SYNOPSIS:\n"
22071 "\n"
22072 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22073 "\n"
22074 "ARGUMENTS:\n"
22075 "\n"
22076 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22077 " and y components of the vector data to be plotted.\n"
22078 "\n"
22079 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22080 "\n"
22081 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22082 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22083 " automatically calculated for the data. If scale < 0 then the\n"
22084 " scaling factor is automatically calculated for the data and then\n"
22085 " multiplied by -\n"
22086 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22087 "\n"
22088 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22089 " defines the transformation between the zero-based indices of the\n"
22090 " matrices u and v and world coordinates.For the C case,\n"
22091 " transformation functions are provided in the PLplot library: pltr0\n"
22092 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22093 " mappings respectively defined by vectors and matrices. In\n"
22094 " addition, C callback routines for the transformation can be\n"
22095 " supplied by the user such as the mypltr function in\n"
22096 " examples/c/x09c.c which provides a general linear transformation\n"
22097 " between index coordinates and world coordinates.For languages\n"
22098 " other than C you should consult the PLplot documentation for the\n"
22099 " details concerning how PLTRANSFORM_callback arguments are\n"
22100 " interfaced. However, in general, a particular pattern of\n"
22101 " callback-associated arguments such as a tr vector with 6 elements;\n"
22102 " xg and yg vectors; or xg and yg matrices are respectively\n"
22103 " interfaced to a linear-transformation routine similar to the above\n"
22104 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22105 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22106 " support native language callbacks for handling index to\n"
22107 " world-coordinate transformations. Examples of these various\n"
22108 " approaches are given in examples/<language>x09*,\n"
22109 " examples/<language>x16*, examples/<language>x20*,\n"
22110 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22111 " supported languages.\n"
22112 "\n"
22113 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22114 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22115 " that is externally supplied.\n"
22116 "\n"
22117 ""},
22118 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22119 "Specify viewport using coordinates and aspect ratio\n"
22120 "\n"
22121 "DESCRIPTION:\n"
22122 "\n"
22123 " Device-independent routine for setting up the viewport. The viewport\n"
22124 " is chosen to be the largest with the given aspect ratio that fits\n"
22125 " within the specified region (in terms of normalized subpage\n"
22126 " coordinates). This routine is functionally equivalent to plvpor when\n"
22127 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22128 " routine reserves no extra space at the edges for labels.\n"
22129 "\n"
22130 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22131 "\n"
22132 " This function is used in example 9.\n"
22133 "\n"
22134 "\n"
22135 "\n"
22136 "SYNOPSIS:\n"
22137 "\n"
22138 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22139 "\n"
22140 "ARGUMENTS:\n"
22141 "\n"
22142 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22143 " left-hand edge of the viewport.\n"
22144 "\n"
22145 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22146 " right-hand edge of the viewport.\n"
22147 "\n"
22148 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22149 " bottom edge of the viewport.\n"
22150 "\n"
22151 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22152 " edge of the viewport.\n"
22153 "\n"
22154 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22155 " axis.\n"
22156 "\n"
22157 ""},
22158 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22159 "Specify viewport using normalized subpage coordinates\n"
22160 "\n"
22161 "DESCRIPTION:\n"
22162 "\n"
22163 " Device-independent routine for setting up the viewport. This defines\n"
22164 " the viewport in terms of normalized subpage coordinates which run from\n"
22165 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22166 " current subpage. Use the alternate routine plsvpa in order to create\n"
22167 " a viewport of a definite size.\n"
22168 "\n"
22169 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22170 "\n"
22171 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22172 " 24, 26, 27, and 31.\n"
22173 "\n"
22174 "\n"
22175 "\n"
22176 "SYNOPSIS:\n"
22177 "\n"
22178 "plvpor(xmin, xmax, ymin, ymax)\n"
22179 "\n"
22180 "ARGUMENTS:\n"
22181 "\n"
22182 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22183 " left-hand edge of the viewport.\n"
22184 "\n"
22185 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22186 " right-hand edge of the viewport.\n"
22187 "\n"
22188 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22189 " bottom edge of the viewport.\n"
22190 "\n"
22191 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22192 " edge of the viewport.\n"
22193 "\n"
22194 ""},
22195 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22196 "Select standard viewport\n"
22197 "\n"
22198 "DESCRIPTION:\n"
22199 "\n"
22200 " Selects the largest viewport within the subpage that leaves a standard\n"
22201 " margin (left-hand margin of eight character heights, and a margin\n"
22202 " around the other three sides of five character heights).\n"
22203 "\n"
22204 " Redacted form: plvsta()\n"
22205 "\n"
22206 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22207 "\n"
22208 "\n"
22209 "\n"
22210 "SYNOPSIS:\n"
22211 "\n"
22212 "plvsta()\n"
22213 "\n"
22214 ""},
22215 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22216 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22217 "\n"
22218 "DESCRIPTION:\n"
22219 "\n"
22220 " Configure the transformations required for projecting a 3D surface on\n"
22221 " an existing 2D window. Those transformations (see the PLplot\n"
22222 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22223 " surface which has its limits expressed in 3D world coordinates and\n"
22224 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22225 " azimuth of the viewing angle). The transformations consist of the\n"
22226 " linear transform from 3D world coordinates to normalized 3D\n"
22227 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22228 " align the pole of the new 3D coordinate system with the viewing\n"
22229 " direction specified by altitude and azimuth so that x and y of the\n"
22230 " surface elements in that transformed coordinate system are the\n"
22231 " projection of the 3D surface with given viewing direction on the 2D\n"
22232 " window.\n"
22233 "\n"
22234 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22235 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22236 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22237 " sizes of basex by basey by height so that xmin maps to -\n"
22238 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22239 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22240 " The resulting rectangular cuboid in normalized coordinates is then\n"
22241 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22242 " must be called before plbox3 or any of the 3D surface plotting\n"
22243 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22244 " plsurf3dl or plfill3.\n"
22245 "\n"
22246 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22247 " zmin, zmax, alt, az)\n"
22248 "\n"
22249 " This function is examples 8, 11, 18, and 21.\n"
22250 "\n"
22251 "\n"
22252 "\n"
22253 "SYNOPSIS:\n"
22254 "\n"
22255 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22256 "\n"
22257 "ARGUMENTS:\n"
22258 "\n"
22259 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22260 " rectangular cuboid.\n"
22261 "\n"
22262 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22263 " rectangular cuboid.\n"
22264 "\n"
22265 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22266 " rectangular cuboid.\n"
22267 "\n"
22268 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22269 " rectangular cuboid.\n"
22270 "\n"
22271 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22272 " rectangular cuboid.\n"
22273 "\n"
22274 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22275 " rectangular cuboid.\n"
22276 "\n"
22277 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22278 " rectangular cuboid.\n"
22279 "\n"
22280 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22281 " rectangular cuboid.\n"
22282 "\n"
22283 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22284 " rectangular cuboid.\n"
22285 "\n"
22286 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22287 " plane of the rectangular cuboid in normalized coordinates.\n"
22288 "\n"
22289 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22290 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22291 " observer is looking face onto the zx plane of the rectangular\n"
22292 " cuboid in normalized coordinates, and as az is increased, the\n"
22293 " observer moves clockwise around that cuboid when viewed from above\n"
22294 " the xy plane.\n"
22295 "\n"
22296 ""},
22297 { "plwidth", _wrap_plwidth, METH_O, "\n"
22298 "Set pen width\n"
22299 "\n"
22300 "DESCRIPTION:\n"
22301 "\n"
22302 " Sets the pen width.\n"
22303 "\n"
22304 " Redacted form: plwidth(width)\n"
22305 "\n"
22306 " This function is used in examples 1 and 2.\n"
22307 "\n"
22308 "\n"
22309 "\n"
22310 "SYNOPSIS:\n"
22311 "\n"
22312 "plwidth(width)\n"
22313 "\n"
22314 "ARGUMENTS:\n"
22315 "\n"
22316 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22317 " or the same as the previous value no action is taken. width = 0.\n"
22318 " should be interpreted as as the minimum valid pen width for the\n"
22319 " device. The interpretation of positive width values is also\n"
22320 " device dependent.\n"
22321 "\n"
22322 ""},
22323 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22324 "Specify window\n"
22325 "\n"
22326 "DESCRIPTION:\n"
22327 "\n"
22328 " Specify the window, i.e., the world coordinates of the edges of the\n"
22329 " viewport.\n"
22330 "\n"
22331 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22332 "\n"
22333 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22334 " 29, and 31.\n"
22335 "\n"
22336 "\n"
22337 "\n"
22338 "SYNOPSIS:\n"
22339 "\n"
22340 "plwind(xmin, xmax, ymin, ymax)\n"
22341 "\n"
22342 "ARGUMENTS:\n"
22343 "\n"
22344 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22345 " of the viewport.\n"
22346 "\n"
22347 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22348 " of the viewport.\n"
22349 "\n"
22350 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22351 " the viewport.\n"
22352 "\n"
22353 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22354 " viewport.\n"
22355 "\n"
22356 ""},
22357 { "plxormod", _wrap_plxormod, METH_O, "\n"
22358 "Enter or leave xor mode\n"
22359 "\n"
22360 "DESCRIPTION:\n"
22361 "\n"
22362 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22363 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22364 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22365 " is not capable of xor operation it returns a status of false.\n"
22366 "\n"
22367 " Redacted form: plxormod(mode, status)\n"
22368 "\n"
22369 " This function is used in examples 1 and 20.\n"
22370 "\n"
22371 "\n"
22372 "\n"
22373 "SYNOPSIS:\n"
22374 "\n"
22375 "plxormod(mode, status)\n"
22376 "\n"
22377 "ARGUMENTS:\n"
22378 "\n"
22379 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22380 " is false means leave xor mode.\n"
22381 "\n"
22382 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22383 " modestatus of true (false) means driver is capable (incapable) of\n"
22384 " xor mode.\n"
22385 "\n"
22386 ""},
22387 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22388 "Plot continental outline or shapefile data in world coordinates\n"
22389 "\n"
22390 "DESCRIPTION:\n"
22391 "\n"
22392 " Plots continental outlines or shapefile data in world coordinates. A\n"
22393 " demonstration of how to use this function to create different\n"
22394 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22395 " basic coastal outlines and USA state borders. To use the map\n"
22396 " functionality PLplot must be compiled with the shapelib library.\n"
22397 " Shapefiles have become a popular standard for geographical data and\n"
22398 " data in this format can be easily found from a number of online\n"
22399 " sources. Shapefile data is actually provided as three or more files\n"
22400 " with the same filename, but different extensions. The .shp and .shx\n"
22401 " files are required for plotting Shapefile data with PLplot.\n"
22402 "\n"
22403 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22404 " objects within shapefiles. However holes in polygons are not\n"
22405 " supported. When plmap is used the type of object is derived from the\n"
22406 " shapefile, if you wish to override the type then use one of the other\n"
22407 " plmap variants. The built in maps have line data only.\n"
22408 "\n"
22409 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22410 "\n"
22411 " This function is used in example 19.\n"
22412 "\n"
22413 "\n"
22414 "\n"
22415 "SYNOPSIS:\n"
22416 "\n"
22417 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22418 "\n"
22419 "ARGUMENTS:\n"
22420 "\n"
22421 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22422 " transform the original map data coordinates to a new coordinate\n"
22423 " system. The PLplot-supplied map data is provided as latitudes and\n"
22424 " longitudes; other Shapefile data may be provided in other\n"
22425 " coordinate systems as can be found in their .prj plain text files.\n"
22426 " For example, by using this transform we can change from a\n"
22427 " longitude, latitude coordinate to a polar stereographic\n"
22428 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22429 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22430 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22431 " data). After the call to mapform(), x[] and y[] should be\n"
22432 " replaced by the corresponding plot coordinates. If no transform is\n"
22433 " desired, mapform can be replaced by NULL.\n"
22434 "\n"
22435 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22436 " the type of map plotted. This is either one of the PLplot built-in\n"
22437 " maps or the file name of a set of Shapefile files without the file\n"
22438 " extensions. For the PLplot built-in maps the possible values are:\n"
22439 " \"globe\" -- continental outlines\n"
22440 " \"usa\" -- USA and state boundaries\n"
22441 " \"cglobe\" -- continental outlines and countries\n"
22442 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22443 "\n"
22444 "\n"
22445 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22446 " drawn. The units must match the shapefile (built in maps are\n"
22447 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22448 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22449 " note this is simply an optimisation, not a clipping so for objects\n"
22450 " with some points inside the box and some points outside the box\n"
22451 " all the points will be rendered. These parameters also define\n"
22452 " latitude and longitude wrapping for shapefiles using these units.\n"
22453 " Longitude points will be wrapped by integer multiples of 360\n"
22454 " degrees to place them in the box. This allows the same data to be\n"
22455 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22456 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22457 " value of minx must be less than the value of maxx. Passing in a\n"
22458 " nan, max/-max floating point number or +/-infinity will case the\n"
22459 " bounding box from the shapefile to be used.\n"
22460 "\n"
22461 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22462 " drawn - see minx.\n"
22463 "\n"
22464 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22465 " drawn - see minx.\n"
22466 "\n"
22467 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22468 " drawn - see minx.\n"
22469 "\n"
22470 ""},
22471 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22472 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22473 "\n"
22474 "DESCRIPTION:\n"
22475 "\n"
22476 " Plot all or a subset of Shapefile data using lines in world\n"
22477 " coordinates. Our 19th standard example demonstrates how to use this\n"
22478 " function. This function plots data from a Shapefile using lines as in\n"
22479 " plmap, however it also has the option of also only drawing specified\n"
22480 " elements from the Shapefile. The vector of indices of the required\n"
22481 " elements are passed as a function argument. The Shapefile data should\n"
22482 " include a metadata file (extension.dbf) listing all items within the\n"
22483 " Shapefile. This file can be opened by most popular spreadsheet\n"
22484 " programs and can be used to decide which indices to pass to this\n"
22485 " function.\n"
22486 "\n"
22487 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22488 " plotentries)\n"
22489 "\n"
22490 " This function is used in example 19.\n"
22491 "\n"
22492 "\n"
22493 "\n"
22494 "SYNOPSIS:\n"
22495 "\n"
22496 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22497 "\n"
22498 "ARGUMENTS:\n"
22499 "\n"
22500 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22501 " transform the coordinates given in the shapefile into a plot\n"
22502 " coordinate system. By using this transform, we can change from a\n"
22503 " longitude, latitude coordinate to a polar stereographic project,\n"
22504 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22505 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22506 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22507 " plot coordinates. If no transform is desired, mapform can be\n"
22508 " replaced by NULL.\n"
22509 "\n"
22510 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22511 " the file name of a set of Shapefile files without the file\n"
22512 " extension.\n"
22513 "\n"
22514 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22515 " be in the same units as used by the Shapefile. You could use a\n"
22516 " very large negative number to plot everything, but you can improve\n"
22517 " performance by limiting the area drawn. The units must match those\n"
22518 " of the Shapefile projection, which may be for example longitude or\n"
22519 " distance. The value of minx must be less than the value of maxx.\n"
22520 "\n"
22521 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22522 " use a very large number to plot everything, but you can improve\n"
22523 " performance by limiting the area drawn.\n"
22524 "\n"
22525 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22526 " be in the same units as used by the Shapefile. You could use a\n"
22527 " very large negative number to plot everything, but you can improve\n"
22528 " performance by limiting the area drawn. The units must match those\n"
22529 " of the Shapefile projection, which may be for example latitude or\n"
22530 " distance. The value of miny must be less than the value of maxy.\n"
22531 "\n"
22532 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22533 " use a very large number to plot everything, but you can improve\n"
22534 " performance by limiting the area drawn.\n"
22535 "\n"
22536 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22537 " zero-based indices of the Shapefile elements which will be drawn.\n"
22538 " Setting\n"
22539 " plotentries to NULL will plot all elements of the Shapefile.\n"
22540 "\n"
22541 " nplotentries (PLINT, input) : The number of items in\n"
22542 " plotentries. Ignored if\n"
22543 " plotentries is NULL.\n"
22544 "\n"
22545 ""},
22546 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22547 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22548 "\n"
22549 "DESCRIPTION:\n"
22550 "\n"
22551 " As per plmapline, however the items are plotted as strings or points\n"
22552 " in the same way as plstring.\n"
22553 "\n"
22554 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22555 " maxy, plotentries)\n"
22556 "\n"
22557 " This function is not used in any examples.\n"
22558 "\n"
22559 "\n"
22560 "\n"
22561 "SYNOPSIS:\n"
22562 "\n"
22563 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22564 "\n"
22565 "ARGUMENTS:\n"
22566 "\n"
22567 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22568 " transform the coordinates given in the shapefile into a plot\n"
22569 " coordinate system. By using this transform, we can change from a\n"
22570 " longitude, latitude coordinate to a polar stereographic project,\n"
22571 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22572 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22573 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22574 " plot coordinates. If no transform is desired, mapform can be\n"
22575 " replaced by NULL.\n"
22576 "\n"
22577 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22578 " the file name of a set of Shapefile files without the file\n"
22579 " extension.\n"
22580 "\n"
22581 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22582 " drawn.\n"
22583 "\n"
22584 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22585 " be in the same units as used by the Shapefile. You could use a\n"
22586 " very large negative number to plot everything, but you can improve\n"
22587 " performance by limiting the area drawn. The units must match those\n"
22588 " of the Shapefile projection, which may be for example longitude or\n"
22589 " distance. The value of minx must be less than the value of maxx.\n"
22590 "\n"
22591 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22592 " use a very large number to plot everything, but you can improve\n"
22593 " performance by limiting the area drawn.\n"
22594 "\n"
22595 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22596 " be in the same units as used by the Shapefile. You could use a\n"
22597 " very large negative number to plot everything, but you can improve\n"
22598 " performance by limiting the area drawn. The units must match those\n"
22599 " of the Shapefile projection, which may be for example latitude or\n"
22600 " distance. The value of miny must be less than the value of maxy.\n"
22601 "\n"
22602 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22603 " use a very large number to plot everything, but you can improve\n"
22604 " performance by limiting the area drawn.\n"
22605 "\n"
22606 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22607 " zero-based indices of the Shapefile elements which will be drawn.\n"
22608 " Setting\n"
22609 " plotentries to NULL will plot all elements of the Shapefile.\n"
22610 "\n"
22611 " nplotentries (PLINT, input) : The number of items in\n"
22612 " plotentries. Ignored if\n"
22613 " plotentries is NULL.\n"
22614 "\n"
22615 ""},
22616 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22617 "Draw text at points defined by Shapefile data in world coordinates\n"
22618 "\n"
22619 "DESCRIPTION:\n"
22620 "\n"
22621 " As per plmapline, however the items are plotted as text in the same\n"
22622 " way as plptex.\n"
22623 "\n"
22624 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22625 " miny, maxy, plotentry)\n"
22626 "\n"
22627 " This function is used in example 19.\n"
22628 "\n"
22629 "\n"
22630 "\n"
22631 "SYNOPSIS:\n"
22632 "\n"
22633 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22634 "\n"
22635 "ARGUMENTS:\n"
22636 "\n"
22637 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22638 " transform the coordinates given in the shapefile into a plot\n"
22639 " coordinate system. By using this transform, we can change from a\n"
22640 " longitude, latitude coordinate to a polar stereographic project,\n"
22641 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22642 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22643 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22644 " plot coordinates. If no transform is desired, mapform can be\n"
22645 " replaced by NULL.\n"
22646 "\n"
22647 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22648 " the file name of a set of Shapefile files without the file\n"
22649 " extension.\n"
22650 "\n"
22651 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22652 " dy/dx.\n"
22653 "\n"
22654 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22655 " dy/dx.\n"
22656 "\n"
22657 " just (PLFLT, input) : Set the justification of the text. The value\n"
22658 " given will be the fraction of the distance along the string that\n"
22659 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22660 " centralized text and 1.0 gives right aligned text.\n"
22661 "\n"
22662 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22663 "\n"
22664 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22665 " be in the same units as used by the Shapefile. You could use a\n"
22666 " very large negative number to plot everything, but you can improve\n"
22667 " performance by limiting the area drawn. The units must match those\n"
22668 " of the Shapefile projection, which may be for example longitude or\n"
22669 " distance. The value of minx must be less than the value of maxx.\n"
22670 "\n"
22671 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22672 " use a very large number to plot everything, but you can improve\n"
22673 " performance by limiting the area drawn.\n"
22674 "\n"
22675 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22676 " be in the same units as used by the Shapefile. You could use a\n"
22677 " very large negative number to plot everything, but you can improve\n"
22678 " performance by limiting the area drawn. The units must match those\n"
22679 " of the Shapefile projection, which may be for example latitude or\n"
22680 " distance. The value of miny must be less than the value of maxy.\n"
22681 "\n"
22682 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22683 " use a very large number to plot everything, but you can improve\n"
22684 " performance by limiting the area drawn.\n"
22685 "\n"
22686 " plotentry (PLINT, input) : An integer indicating which text string\n"
22687 " of the Shapefile (zero indexed) will be drawn.\n"
22688 "\n"
22689 ""},
22690 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22691 "Plot all or a subset of Shapefile data, filling the polygons\n"
22692 "\n"
22693 "DESCRIPTION:\n"
22694 "\n"
22695 " As per plmapline, however the items are filled in the same way as\n"
22696 " plfill.\n"
22697 "\n"
22698 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22699 " plotentries)\n"
22700 "\n"
22701 " This function is used in example 19.\n"
22702 "\n"
22703 "\n"
22704 "\n"
22705 "SYNOPSIS:\n"
22706 "\n"
22707 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22708 "\n"
22709 "ARGUMENTS:\n"
22710 "\n"
22711 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22712 " transform the coordinates given in the shapefile into a plot\n"
22713 " coordinate system. By using this transform, we can change from a\n"
22714 " longitude, latitude coordinate to a polar stereographic project,\n"
22715 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22716 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22717 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22718 " plot coordinates. If no transform is desired, mapform can be\n"
22719 " replaced by NULL.\n"
22720 "\n"
22721 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22722 " the file name of a set of Shapefile files without the file\n"
22723 " extension.\n"
22724 "\n"
22725 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22726 " be in the same units as used by the Shapefile. You could use a\n"
22727 " very large negative number to plot everything, but you can improve\n"
22728 " performance by limiting the area drawn. The units must match those\n"
22729 " of the Shapefile projection, which may be for example longitude or\n"
22730 " distance. The value of minx must be less than the value of maxx.\n"
22731 "\n"
22732 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22733 " use a very large number to plot everything, but you can improve\n"
22734 " performance by limiting the area drawn.\n"
22735 "\n"
22736 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22737 " be in the same units as used by the Shapefile. You could use a\n"
22738 " very large negative number to plot everything, but you can improve\n"
22739 " performance by limiting the area drawn. The units must match those\n"
22740 " of the Shapefile projection, which may be for example latitude or\n"
22741 " distance. The value of miny must be less than the value of maxy.\n"
22742 "\n"
22743 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22744 " use a very large number to plot everything, but you can improve\n"
22745 " performance by limiting the area drawn.\n"
22746 "\n"
22747 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22748 " zero-based indices of the Shapefile elements which will be drawn.\n"
22749 " Setting\n"
22750 " plotentries to NULL will plot all elements of the Shapefile.\n"
22751 "\n"
22752 " nplotentries (PLINT, input) : The number of items in\n"
22753 " plotentries. Ignored if\n"
22754 " plotentries is NULL.\n"
22755 "\n"
22756 ""},
22757 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22758 "Plot latitude and longitude lines\n"
22759 "\n"
22760 "DESCRIPTION:\n"
22761 "\n"
22762 " Displays latitude and longitude on the current plot. The lines are\n"
22763 " plotted in the current color and line style.\n"
22764 "\n"
22765 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22766 " minlat, maxlat)\n"
22767 "\n"
22768 " This function is used in example 19.\n"
22769 "\n"
22770 "\n"
22771 "\n"
22772 "SYNOPSIS:\n"
22773 "\n"
22774 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22775 "\n"
22776 "ARGUMENTS:\n"
22777 "\n"
22778 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22779 " transform the coordinate longitudes and latitudes to a plot\n"
22780 " coordinate system. By using this transform, we can change from a\n"
22781 " longitude, latitude coordinate to a polar stereographic project,\n"
22782 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22783 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22784 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22785 " plot coordinates. If no transform is desired, mapform can be\n"
22786 " replaced by NULL.\n"
22787 "\n"
22788 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22789 " longitude lines are to be plotted.\n"
22790 "\n"
22791 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22792 " lines are to be plotted.\n"
22793 "\n"
22794 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22795 " side of the plot. The value of minlong must be less than the value\n"
22796 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22797 " equal to 360.\n"
22798 "\n"
22799 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22800 " side of the plot.\n"
22801 "\n"
22802 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22803 " background. One can always use -90.0 as the boundary outside the\n"
22804 " plot window will be automatically eliminated. However, the\n"
22805 " program will be faster if one can reduce the size of the\n"
22806 " background plotted.\n"
22807 "\n"
22808 " maxlat (PLFLT, input) : The maximum latitudes 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.\n"
22811 "\n"
22812 ""},
22813 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22814 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22815 "\n"
22816 "DESCRIPTION:\n"
22817 "\n"
22818 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22819 " automatically adjusted to use the maximum and minimum values in idata\n"
22820 " as valuemin and valuemax in a call to plimagefr.\n"
22821 "\n"
22822 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22823 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22824 "\n"
22825 "\n"
22826 " This function is used in example 20.\n"
22827 "\n"
22828 "\n"
22829 "\n"
22830 "SYNOPSIS:\n"
22831 "\n"
22832 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22833 "\n"
22834 "ARGUMENTS:\n"
22835 "\n"
22836 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22837 " to plot. Should have dimensions of\n"
22838 " nx by\n"
22839 " ny.\n"
22840 "\n"
22841 " nx, ny (PLINT, input) : Dimensions of idata\n"
22842 "\n"
22843 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22844 " are linearly transformed to these world coordinate ranges such\n"
22845 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22846 " - 1] corresponds to (xmax, ymax).\n"
22847 "\n"
22848 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22849 " (inclusive) will be plotted.\n"
22850 "\n"
22851 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22852 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22853 " Dymin) to (Dxmax, Dymax).\n"
22854 "\n"
22855 ""},
22856 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22857 "Plot a 2D matrix using cmap1\n"
22858 "\n"
22859 "DESCRIPTION:\n"
22860 "\n"
22861 " Plot a 2D matrix using cmap1.\n"
22862 "\n"
22863 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22864 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22865 "\n"
22866 "\n"
22867 " This function is used in example 20.\n"
22868 "\n"
22869 "\n"
22870 "\n"
22871 "SYNOPSIS:\n"
22872 "\n"
22873 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22874 "\n"
22875 "ARGUMENTS:\n"
22876 "\n"
22877 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22878 " plot. Should have dimensions of\n"
22879 " nx by\n"
22880 " ny.\n"
22881 "\n"
22882 " nx, ny (PLINT, input) : Dimensions of idata\n"
22883 "\n"
22884 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22885 " pltr below for how these arguments are used (only for the special case\n"
22886 " when the callback function\n"
22887 " pltr is not supplied).\n"
22888 "\n"
22889 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22890 " (inclusive) will be plotted.\n"
22891 "\n"
22892 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22893 " values to use for value to color mappings. A datum equal to or\n"
22894 " less than valuemin will be plotted with color 0.0, while a datum\n"
22895 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22896 " Data between valuemin and valuemax map linearly to colors in the\n"
22897 " range (0.0-1.0).\n"
22898 "\n"
22899 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22900 " defines the transformation between the zero-based indices of the\n"
22901 " matrix idata and world coordinates. If\n"
22902 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22903 " indices of idata are mapped to the range\n"
22904 " xmin through\n"
22905 " xmax and the y indices of idata are mapped to the range\n"
22906 " ymin through\n"
22907 " ymax.For the C case, transformation functions are provided in the\n"
22908 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22909 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22910 " matrices. In addition, C callback routines for the transformation\n"
22911 " can be supplied by the user such as the mypltr function in\n"
22912 " examples/c/x09c.c which provides a general linear transformation\n"
22913 " between index coordinates and world coordinates.For languages\n"
22914 " other than C you should consult the PLplot documentation for the\n"
22915 " details concerning how PLTRANSFORM_callback arguments are\n"
22916 " interfaced. However, in general, a particular pattern of\n"
22917 " callback-associated arguments such as a tr vector with 6 elements;\n"
22918 " xg and yg vectors; or xg and yg matrices are respectively\n"
22919 " interfaced to a linear-transformation routine similar to the above\n"
22920 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22921 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22922 " support native language callbacks for handling index to\n"
22923 " world-coordinate transformations. Examples of these various\n"
22924 " approaches are given in examples/<language>x09*,\n"
22925 " examples/<language>x16*, examples/<language>x20*,\n"
22926 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22927 " supported languages.\n"
22928 "\n"
22929 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22930 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22931 " externally supplied.\n"
22932 "\n"
22933 ""},
22934 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22935 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22936 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22937 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22938 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22939 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22940 "Wait for graphics input event and translate to world coordinates.\n"
22941 "\n"
22942 "DESCRIPTION:\n"
22943 "\n"
22944 " Wait for graphics input event and translate to world coordinates.\n"
22945 " Returns 0 if no translation to world coordinates is possible.\n"
22946 "\n"
22947 " This function returns 1 on success and 0 if no translation to world\n"
22948 " coordinates is possible.\n"
22949 "\n"
22950 " Redacted form: plGetCursor(gin)\n"
22951 "\n"
22952 " This function is used in examples 1 and 20.\n"
22953 "\n"
22954 "\n"
22955 "\n"
22956 "SYNOPSIS:\n"
22957 "\n"
22958 "PLINT plGetCursor(gin)\n"
22959 "\n"
22960 "ARGUMENTS:\n"
22961 "\n"
22962 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22963 " which will contain the output. The structure is not allocated by\n"
22964 " the routine and must exist before the function is called.\n"
22965 "\n"
22966 ""},
22967 { NULL, NULL, 0, NULL }
22968};
22969
22970
22971/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22972
22973static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22974static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22975static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22976static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22977static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22978static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22979static 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};
22980static 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};
22981static 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};
22982static 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};
22983static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22984static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22985static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22986static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22987
23004
23005static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23006static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
23007static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
23008static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23009static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23015static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23016static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23017static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23018static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23019
23036
23037
23038/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23039
23041{0, 0, 0, 0.0, 0, 0}};
23042
23043#ifdef __cplusplus
23044}
23045#endif
23046/* -----------------------------------------------------------------------------
23047 * Type initialization:
23048 * This problem is tough by the requirement that no dynamic
23049 * memory is used. Also, since swig_type_info structures store pointers to
23050 * swig_cast_info structures and swig_cast_info structures store pointers back
23051 * to swig_type_info structures, we need some lookup code at initialization.
23052 * The idea is that swig generates all the structures that are needed.
23053 * The runtime then collects these partially filled structures.
23054 * The SWIG_InitializeModule function takes these initial arrays out of
23055 * swig_module, and does all the lookup, filling in the swig_module.types
23056 * array with the correct data and linking the correct swig_cast_info
23057 * structures together.
23058 *
23059 * The generated swig_type_info structures are assigned statically to an initial
23060 * array. We just loop through that array, and handle each type individually.
23061 * First we lookup if this type has been already loaded, and if so, use the
23062 * loaded structure instead of the generated one. Then we have to fill in the
23063 * cast linked list. The cast data is initially stored in something like a
23064 * two-dimensional array. Each row corresponds to a type (there are the same
23065 * number of rows as there are in the swig_type_initial array). Each entry in
23066 * a column is one of the swig_cast_info structures for that type.
23067 * The cast_initial array is actually an array of arrays, because each row has
23068 * a variable number of columns. So to actually build the cast linked list,
23069 * we find the array of casts associated with the type, and loop through it
23070 * adding the casts to the list. The one last trick we need to do is making
23071 * sure the type pointer in the swig_cast_info struct is correct.
23072 *
23073 * First off, we lookup the cast->type name to see if it is already loaded.
23074 * There are three cases to handle:
23075 * 1) If the cast->type has already been loaded AND the type we are adding
23076 * casting info to has not been loaded (it is in this module), THEN we
23077 * replace the cast->type pointer with the type pointer that has already
23078 * been loaded.
23079 * 2) If BOTH types (the one we are adding casting info to, and the
23080 * cast->type) are loaded, THEN the cast info has already been loaded by
23081 * the previous module so we just ignore it.
23082 * 3) Finally, if cast->type has not already been loaded, then we add that
23083 * swig_cast_info to the linked list (because the cast->type) pointer will
23084 * be correct.
23085 * ----------------------------------------------------------------------------- */
23086
23087#ifdef __cplusplus
23088extern "C" {
23089#if 0
23090} /* c-mode */
23091#endif
23092#endif
23093
23094#if 0
23095#define SWIGRUNTIME_DEBUG
23096#endif
23097
23098#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23099#define SWIG_INIT_CLIENT_DATA_TYPE void *
23100#endif
23101
23102SWIGRUNTIME void
23104 size_t i;
23105 swig_module_info *module_head, *iter;
23106 int init;
23107
23108 /* check to see if the circular list has been setup, if not, set it up */
23109 if (swig_module.next==0) {
23110 /* Initialize the swig_module */
23114 init = 1;
23115 } else {
23116 init = 0;
23117 }
23118
23119 /* Try and load any already created modules */
23120 module_head = SWIG_GetModule(clientdata);
23121 if (!module_head) {
23122 /* This is the first module loaded for this interpreter */
23123 /* so set the swig module into the interpreter */
23124 SWIG_SetModule(clientdata, &swig_module);
23125 } else {
23126 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23127 iter=module_head;
23128 do {
23129 if (iter==&swig_module) {
23130 /* Our module is already in the list, so there's nothing more to do. */
23131 return;
23132 }
23133 iter=iter->next;
23134 } while (iter!= module_head);
23135
23136 /* otherwise we must add our module into the list */
23137 swig_module.next = module_head->next;
23138 module_head->next = &swig_module;
23139 }
23140
23141 /* When multiple interpreters are used, a module could have already been initialized in
23142 a different interpreter, but not yet have a pointer in this interpreter.
23143 In this case, we do not want to continue adding types... everything should be
23144 set up already */
23145 if (init == 0) return;
23146
23147 /* Now work on filling in swig_module.types */
23148#ifdef SWIGRUNTIME_DEBUG
23149 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23150#endif
23151 for (i = 0; i < swig_module.size; ++i) {
23152 swig_type_info *type = 0;
23153 swig_type_info *ret;
23154 swig_cast_info *cast;
23155
23156#ifdef SWIGRUNTIME_DEBUG
23157 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23158#endif
23159
23160 /* if there is another module already loaded */
23161 if (swig_module.next != &swig_module) {
23163 }
23164 if (type) {
23165 /* Overwrite clientdata field */
23166#ifdef SWIGRUNTIME_DEBUG
23167 printf("SWIG_InitializeModule: found type %s\n", type->name);
23168#endif
23170 type->clientdata = swig_module.type_initial[i]->clientdata;
23171#ifdef SWIGRUNTIME_DEBUG
23172 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23173#endif
23174 }
23175 } else {
23176 type = swig_module.type_initial[i];
23177 }
23178
23179 /* Insert casting types */
23180 cast = swig_module.cast_initial[i];
23181 while (cast->type) {
23182 /* Don't need to add information already in the list */
23183 ret = 0;
23184#ifdef SWIGRUNTIME_DEBUG
23185 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23186#endif
23187 if (swig_module.next != &swig_module) {
23189#ifdef SWIGRUNTIME_DEBUG
23190 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23191#endif
23192 }
23193 if (ret) {
23194 if (type == swig_module.type_initial[i]) {
23195#ifdef SWIGRUNTIME_DEBUG
23196 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23197#endif
23198 cast->type = ret;
23199 ret = 0;
23200 } else {
23201 /* Check for casting already in the list */
23202 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23203#ifdef SWIGRUNTIME_DEBUG
23204 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23205#endif
23206 if (!ocast) ret = 0;
23207 }
23208 }
23209
23210 if (!ret) {
23211#ifdef SWIGRUNTIME_DEBUG
23212 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23213#endif
23214 if (type->cast) {
23215 type->cast->prev = cast;
23216 cast->next = type->cast;
23217 }
23218 type->cast = cast;
23219 }
23220 cast++;
23221 }
23222 /* Set entry in modules->types array equal to the type */
23223 swig_module.types[i] = type;
23224 }
23225 swig_module.types[i] = 0;
23226
23227#ifdef SWIGRUNTIME_DEBUG
23228 printf("**** SWIG_InitializeModule: Cast List ******\n");
23229 for (i = 0; i < swig_module.size; ++i) {
23230 int j = 0;
23232 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23233 while (cast->type) {
23234 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23235 cast++;
23236 ++j;
23237 }
23238 printf("---- Total casts: %d\n",j);
23239 }
23240 printf("**** SWIG_InitializeModule: Cast List ******\n");
23241#endif
23242}
23243
23244/* This function will propagate the clientdata field of type to
23245* any new swig_type_info structures that have been added into the list
23246* of equivalent types. It is like calling
23247* SWIG_TypeClientData(type, clientdata) a second time.
23248*/
23249SWIGRUNTIME void
23251 size_t i;
23252 swig_cast_info *equiv;
23253 static int init_run = 0;
23254
23255 if (init_run) return;
23256 init_run = 1;
23257
23258 for (i = 0; i < swig_module.size; i++) {
23259 if (swig_module.types[i]->clientdata) {
23260 equiv = swig_module.types[i]->cast;
23261 while (equiv) {
23262 if (!equiv->converter) {
23263 if (equiv->type && !equiv->type->clientdata)
23265 }
23266 equiv = equiv->next;
23267 }
23268 }
23269 }
23270}
23271
23272#ifdef __cplusplus
23273#if 0
23274{
23275 /* c-mode */
23276#endif
23277}
23278#endif
23279
23280
23281
23282#ifdef __cplusplus
23283extern "C" {
23284#endif
23285
23286 /* -----------------------------------------------------------------------------
23287 * constants/methods manipulation
23288 * ----------------------------------------------------------------------------- */
23289
23290 /* Install Constants */
23291 SWIGINTERN void
23293 PyObject *obj = 0;
23294 size_t i;
23295 for (i = 0; constants[i].type; ++i) {
23296 switch(constants[i].type) {
23297 case SWIG_PY_POINTER:
23298 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23299 break;
23300 case SWIG_PY_BINARY:
23301 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23302 break;
23303 default:
23304 obj = 0;
23305 break;
23306 }
23307 if (obj) {
23308 PyDict_SetItemString(d, constants[i].name, obj);
23309 SWIG_Py_DECREF(obj);
23310 }
23311 }
23312 }
23313
23314 /* -----------------------------------------------------------------------------
23315 * Patch %callback methods' docstrings to hold the callback ptrs
23316 * -----------------------------------------------------------------------------*/
23317
23318 SWIGINTERN void
23319 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23320 size_t i;
23321 for (i = 0; methods[i].ml_name; ++i) {
23322 const char *c = methods[i].ml_doc;
23323 if (!c) continue;
23324 c = strstr(c, "swig_ptr: ");
23325 if (c) {
23326 int j;
23327 const swig_const_info *ci = 0;
23328 const char *name = c + 10;
23329 for (j = 0; const_table[j].type; ++j) {
23330 if (strncmp(const_table[j].name, name,
23331 strlen(const_table[j].name)) == 0) {
23332 ci = &(const_table[j]);
23333 break;
23334 }
23335 }
23336 if (ci) {
23337 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23338 if (ptr) {
23339 size_t shift = (ci->ptype) - types;
23340 swig_type_info *ty = types_initial[shift];
23341 size_t ldoc = (c - methods[i].ml_doc);
23342 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23343 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23344 if (ndoc) {
23345 char *buff = ndoc;
23346 memcpy(buff, methods[i].ml_doc, ldoc);
23347 buff += ldoc;
23348 memcpy(buff, "swig_ptr: ", 10);
23349 buff += 10;
23350 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23351 methods[i].ml_doc = ndoc;
23352 }
23353 }
23354 }
23355 }
23356 }
23357 }
23358
23359#ifdef __cplusplus
23360}
23361#endif
23362
23363
23364
23365
23366/* -----------------------------------------------------------------------------*
23367 * Partial Init method
23368 * -----------------------------------------------------------------------------*/
23369
23370#ifdef __cplusplus
23371extern "C"
23372#endif
23373
23375#if PY_VERSION_HEX >= 0x03000000
23376PyObject*
23377#else
23378void
23379#endif
23381 PyObject *m, *d, *md, *globals;
23382
23383#if PY_VERSION_HEX >= 0x03000000
23384 static struct PyModuleDef SWIG_module = {
23385 PyModuleDef_HEAD_INIT,
23386 SWIG_name,
23387 NULL,
23388 -1,
23390 NULL,
23391 NULL,
23392 NULL,
23393 NULL
23394 };
23395#endif
23396
23397#if defined(SWIGPYTHON_BUILTIN)
23398 static SwigPyClientData SwigPyObject_clientdata = {
23399 0, 0, 0, 0, 0, 0, 0
23400 };
23401 static PyGetSetDef this_getset_def = {
23402 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23403 };
23404 static SwigPyGetSet thisown_getset_closure = {
23407 };
23408 static PyGetSetDef thisown_getset_def = {
23409 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23410 };
23411 PyTypeObject *builtin_pytype;
23412 int builtin_base_count;
23413 swig_type_info *builtin_basetype;
23414 PyObject *tuple;
23415 PyGetSetDescrObject *static_getset;
23416 PyTypeObject *metatype;
23417 PyTypeObject *swigpyobject;
23418 SwigPyClientData *cd;
23419 PyObject *public_interface, *public_symbol;
23420 PyObject *this_descr;
23421 PyObject *thisown_descr;
23422 PyObject *self = 0;
23423 int i;
23424
23425 (void)builtin_pytype;
23426 (void)builtin_base_count;
23427 (void)builtin_basetype;
23428 (void)tuple;
23429 (void)static_getset;
23430 (void)self;
23431
23432 /* Metaclass is used to implement static member variables */
23433 metatype = SwigPyObjectType();
23434 assert(metatype);
23435#endif
23436
23437 (void)globals;
23438
23439 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23440 SWIG_This();
23443#ifndef SWIGPYTHON_BUILTIN
23445#endif
23446
23447 /* Fix SwigMethods to carry the callback ptrs when needed */
23449
23450#if PY_VERSION_HEX >= 0x03000000
23451 m = PyModule_Create(&SWIG_module);
23452#else
23453 m = Py_InitModule(SWIG_name, SwigMethods);
23454#endif
23455
23456 md = d = PyModule_GetDict(m);
23457 (void)md;
23458
23460
23461#ifdef SWIGPYTHON_BUILTIN
23462 swigpyobject = SwigPyObject_TypeOnce();
23463
23464 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23465 assert(SwigPyObject_stype);
23466 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23467 if (!cd) {
23468 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23469 SwigPyObject_clientdata.pytype = swigpyobject;
23470 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23471 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23472# if PY_VERSION_HEX >= 0x03000000
23473 return NULL;
23474# else
23475 return;
23476# endif
23477 }
23478
23479 /* All objects have a 'this' attribute */
23480 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23481 (void)this_descr;
23482
23483 /* All objects have a 'thisown' attribute */
23484 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23485 (void)thisown_descr;
23486
23487 public_interface = PyList_New(0);
23488 public_symbol = 0;
23489 (void)public_symbol;
23490
23491 PyDict_SetItemString(md, "__all__", public_interface);
23492 SWIG_Py_DECREF(public_interface);
23493 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23494 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23495 for (i = 0; swig_const_table[i].name != 0; ++i)
23496 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23497#endif
23498
23500
23501
23502 import_array();
23503
23504 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23505 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23506 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23507 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23508 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23509 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23510 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23511 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23512 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23513 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23514 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23515 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23516 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23517 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23518 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23519 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23520 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23521 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23522 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23523 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23524 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23525 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23526 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23527 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23528 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23529 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23530 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23531 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23532 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23533 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23534 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23535 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23536 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23537 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23538 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23539 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23540 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23541 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23542 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23543 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23544 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23545 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23546 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23547 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23548 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23549 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23550 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23551 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23552 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23553 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23554 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23555 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23556 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23557 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23558 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23559 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23560 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23561 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23562 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23563 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23564 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23565 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23566 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23567 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23568 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23569 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23570 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23571 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23572 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23573 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23574 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23575 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23576 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23577 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23578 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23579 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23580 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23581 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23582 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23583 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23584 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23585 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23586 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23587 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23588 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23589 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23590 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23591 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23592 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23593 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23594 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23595 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23596 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23597 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23598 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23599 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23600 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23601 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23602 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23603 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23604 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23605 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23606 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23607 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23608 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23609 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23610 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23611 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23612 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23613 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23614 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23615 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23616 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23617 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23618 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23619 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23620 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23621 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23622 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23623 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23624 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23625 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23626 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23627 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23628 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23629 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23630 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23631 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23632 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23633 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23634 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23635 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23636 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23637 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23638 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23639 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23640 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23641 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23642 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23643 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23644 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23645 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23646 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23647 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23648 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23649 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23650 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23651 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23652 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23653 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23654 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23655 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23656 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23657 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23658 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23659 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23660 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23661 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23662 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23663 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23664 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23665 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23666 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23667 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23668 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23669 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23670 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23671 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23672 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23673 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23674 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23675 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23676 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23677 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23678 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23679 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23680 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23681 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23682 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23683 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23684 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23685 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23686 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23687 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23688 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23689#if PY_VERSION_HEX >= 0x03000000
23690 return m;
23691#else
23692 return;
23693#endif
23694}
23695
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_Py_XDECREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_Py_XINCREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
#define SWIG_Py_DECREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
#define SWIG_Py_INCREF
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj, int is_void)
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
char string[PL_MAXKEY]
Definition plplot.h:440
PLINT nx
Definition plplot.h:521
PLFLT_NC_MATRIX xg
Definition plplot.h:520
PLINT ny
Definition plplot.h:521
PLFLT_NC_MATRIX yg
Definition plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition plplot.h:508
PLINT nx
Definition plplot.h:509
PLINT ny
Definition plplot.h:509
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135