PLplot: plplotcPYTHON_wrap.c Source File

PLplot 5.15.0

plplotcPYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 3.0.12
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17
18 /* -----------------------------------------------------------------------------
19 * This section contains generic SWIG labels for method/variable
20 * declarations/attributes, and other compiler dependent labels.
21 * ----------------------------------------------------------------------------- */
22
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 # define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 # define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 # define SWIGINLINE inline
40 # else
41 # define SWIGINLINE
42 # endif
43 #endif
44
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 # elif defined(__ICC)
54 # define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 # define SWIGUNUSED
57 # endif
58 #endif
59
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 # define SWIGUNUSEDPARM(p)
69 # else
70 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83
84 /* exporting methods */
85 #if defined(__GNUC__)
86 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 # ifndef GCC_HASCLASSVISIBILITY
88 # define GCC_HASCLASSVISIBILITY
89 # endif
90 # endif
91 #endif
92
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 # if defined(STATIC_LINKED)
96 # define SWIGEXPORT
97 # else
98 # define SWIGEXPORT __declspec(dllexport)
99 # endif
100 # else
101 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 # define SWIGEXPORT __attribute__ ((visibility("default")))
103 # else
104 # define SWIGEXPORT
105 # endif
106 # endif
107 #endif
108
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # define SWIGSTDCALL __stdcall
113 # else
114 # define SWIGSTDCALL
115 # endif
116 #endif
117
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132
133 /* Intel's compiler complains if a variable which was never initialised is
134 * cast to void, which is a common idiom which we use to indicate that we
135 * are aware a variable isn't used. So we just silence that warning.
136 * See: https://github.com/swig/swig/issues/192 for more discussion.
137 */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141
142
143 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
144 /* Use debug wrappers with the Python release dll */
145 # undef _DEBUG
146 # include <Python.h>
147 # define _DEBUG
148 #else
149 # include <Python.h>
150 #endif
151
152 /* -----------------------------------------------------------------------------
153 * swigrun.swg
154 *
155 * This file contains generic C API SWIG runtime support for pointer
156 * type checking.
157 * ----------------------------------------------------------------------------- */
158
159 /* This should only be incremented when either the layout of swig_type_info changes,
160 or for whatever reason, the runtime changes incompatibly */
161 #define SWIG_RUNTIME_VERSION "4"
162
163 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
164 #ifdef SWIG_TYPE_TABLE
165 # define SWIG_QUOTE_STRING(x) #x
166 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
167 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
168 #else
169 # define SWIG_TYPE_TABLE_NAME
170 #endif
171
172 /*
173 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
174 creating a static or dynamic library from the SWIG runtime code.
175 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
176
177 But only do this if strictly necessary, ie, if you have problems
178 with your compiler or suchlike.
179 */
180
181 #ifndef SWIGRUNTIME
182 # define SWIGRUNTIME SWIGINTERN
183 #endif
184
185 #ifndef SWIGRUNTIMEINLINE
186 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
187 #endif
188
189 /* Generic buffer size */
190 #ifndef SWIG_BUFFER_SIZE
191 # define SWIG_BUFFER_SIZE 1024
192 #endif
193
194 /* Flags for pointer conversions */
195 #define SWIG_POINTER_DISOWN 0x1
196 #define SWIG_CAST_NEW_MEMORY 0x2
197
198 /* Flags for new pointer objects */
199 #define SWIG_POINTER_OWN 0x1
200
201
202 /*
203 Flags/methods for returning states.
204
205 The SWIG conversion methods, as ConvertPtr, return an integer
206 that tells if the conversion was successful or not. And if not,
207 an error code can be returned (see swigerrors.swg for the codes).
208
209 Use the following macros/flags to set or process the returning
210 states.
211
212 In old versions of SWIG, code such as the following was usually written:
213
214 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
215 // success code
216 } else {
217 //fail code
218 }
219
220 Now you can be more explicit:
221
222 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
223 if (SWIG_IsOK(res)) {
224 // success code
225 } else {
226 // fail code
227 }
228
229 which is the same really, but now you can also do
230
231 Type *ptr;
232 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
233 if (SWIG_IsOK(res)) {
234 // success code
235 if (SWIG_IsNewObj(res) {
236 ...
237 delete *ptr;
238 } else {
239 ...
240 }
241 } else {
242 // fail code
243 }
244
245 I.e., now SWIG_ConvertPtr can return new objects and you can
246 identify the case and take care of the deallocation. Of course that
247 also requires SWIG_ConvertPtr to return new result values, such as
248
249 int SWIG_ConvertPtr(obj, ptr,...) {
250 if (<obj is ok>) {
251 if (<need new object>) {
252 *ptr = <ptr to new allocated object>;
253 return SWIG_NEWOBJ;
254 } else {
255 *ptr = <ptr to old object>;
256 return SWIG_OLDOBJ;
257 }
258 } else {
259 return SWIG_BADOBJ;
260 }
261 }
262
263 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
264 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
265 SWIG errors code.
266
267 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
268 allows to return the 'cast rank', for example, if you have this
269
270 int food(double)
271 int fooi(int);
272
273 and you call
274
275 food(1) // cast rank '1' (1 -> 1.0)
276 fooi(1) // cast rank '0'
277
278 just use the SWIG_AddCast()/SWIG_CheckState()
279 */
280
281 #define SWIG_OK (0)
282 #define SWIG_ERROR (-1)
283 #define SWIG_IsOK(r) (r >= 0)
284 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
285
286 /* The CastRankLimit says how many bits are used for the cast rank */
287 #define SWIG_CASTRANKLIMIT (1 << 8)
288 /* The NewMask denotes the object was created (using new/malloc) */
289 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
290 /* The TmpMask is for in/out typemaps that use temporal objects */
291 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
292 /* Simple returning values */
293 #define SWIG_BADOBJ (SWIG_ERROR)
294 #define SWIG_OLDOBJ (SWIG_OK)
295 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
296 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
297 /* Check, add and del mask methods */
298 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
299 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
300 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
301 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
302 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
303 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
304
305 /* Cast-Rank Mode */
306 #if defined(SWIG_CASTRANK_MODE)
307 # ifndef SWIG_TypeRank
308 # define SWIG_TypeRank unsigned long
309 # endif
310 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
311 # define SWIG_MAXCASTRANK (2)
312 # endif
313 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
314 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
315 SWIGINTERNINLINE int SWIG_AddCast(int r) {
316 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
317 }
318 SWIGINTERNINLINE int SWIG_CheckState(int r) {
319 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
320 }
321 #else /* no cast-rank mode */
322 # define SWIG_AddCast(r) (r)
323 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
324 #endif
325
326
327 #include <string.h>
328
329 #ifdef __cplusplus
330 extern "C" {
331 #endif
332
333 typedef void *(*swig_converter_func)(void *, int *);
334 typedef struct swig_type_info *(*swig_dycast_func)(void **);
335
336 /* Structure to store information on one type */
337 typedef struct swig_type_info {
338 const char *name; /* mangled name of this type */
339 const char *str; /* human readable name of this type */
340 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
341 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
342 void *clientdata; /* language specific type data */
343 int owndata; /* flag if the structure owns the clientdata */
344 } swig_type_info;
345
346 /* Structure to store a type and conversion function used for casting */
347 typedef struct swig_cast_info {
348 swig_type_info *type; /* pointer to type that is equivalent to this type */
349 swig_converter_func converter; /* function to cast the void pointers */
350 struct swig_cast_info *next; /* pointer to next cast in linked list */
351 struct swig_cast_info *prev; /* pointer to the previous cast */
352 } swig_cast_info;
353
354 /* Structure used to store module information
355 * Each module generates one structure like this, and the runtime collects
356 * all of these structures and stores them in a circularly linked list.*/
357 typedef struct swig_module_info {
358 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
359 size_t size; /* Number of types in this module */
360 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
361 swig_type_info **type_initial; /* Array of initially generated type structures */
362 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
363 void *clientdata; /* Language specific module data */
364 } swig_module_info;
365
366 /*
367 Compare two type names skipping the space characters, therefore
368 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
369
370 Return 0 when the two name types are equivalent, as in
371 strncmp, but skipping ' '.
372 */
373 SWIGRUNTIME int
374 SWIG_TypeNameComp(const char *f1, const char *l1,
375 const char *f2, const char *l2) {
376 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
377 while ((*f1 == ' ') && (f1 != l1)) ++f1;
378 while ((*f2 == ' ') && (f2 != l2)) ++f2;
379 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
380 }
381 return (int)((l1 - f1) - (l2 - f2));
382 }
383
384 /*
385 Check type equivalence in a name list like <name1>|<name2>|...
386 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
387 */
388 SWIGRUNTIME int
389 SWIG_TypeCmp(const char *nb, const char *tb) {
390 int equiv = 1;
391 const char* te = tb + strlen(tb);
392 const char* ne = nb;
393 while (equiv != 0 && *ne) {
394 for (nb = ne; *ne; ++ne) {
395 if (*ne == '|') break;
396 }
397 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
398 if (*ne) ++ne;
399 }
400 return equiv;
401 }
402
403 /*
404 Check type equivalence in a name list like <name1>|<name2>|...
405 Return 0 if not equal, 1 if equal
406 */
407 SWIGRUNTIME int
408 SWIG_TypeEquiv(const char *nb, const char *tb) {
409 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
410 }
411
412 /*
413 Check the typename
414 */
415 SWIGRUNTIME swig_cast_info *
416 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
417 if (ty) {
418 swig_cast_info *iter = ty->cast;
419 while (iter) {
420 if (strcmp(iter->type->name, c) == 0) {
421 if (iter == ty->cast)
422 return iter;
423 /* Move iter to the top of the linked list */
424 iter->prev->next = iter->next;
425 if (iter->next)
426 iter->next->prev = iter->prev;
427 iter->next = ty->cast;
428 iter->prev = 0;
429 if (ty->cast) ty->cast->prev = iter;
430 ty->cast = iter;
431 return iter;
432 }
433 iter = iter->next;
434 }
435 }
436 return 0;
437 }
438
439 /*
440 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
441 */
442 SWIGRUNTIME swig_cast_info *
443 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
444 if (ty) {
445 swig_cast_info *iter = ty->cast;
446 while (iter) {
447 if (iter->type == from) {
448 if (iter == ty->cast)
449 return iter;
450 /* Move iter to the top of the linked list */
451 iter->prev->next = iter->next;
452 if (iter->next)
453 iter->next->prev = iter->prev;
454 iter->next = ty->cast;
455 iter->prev = 0;
456 if (ty->cast) ty->cast->prev = iter;
457 ty->cast = iter;
458 return iter;
459 }
460 iter = iter->next;
461 }
462 }
463 return 0;
464 }
465
466 /*
467 Cast a pointer up an inheritance hierarchy
468 */
469 SWIGRUNTIMEINLINE void *
470 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
471 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
472 }
473
474 /*
475 Dynamic pointer casting. Down an inheritance hierarchy
476 */
477 SWIGRUNTIME swig_type_info *
478 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
479 swig_type_info *lastty = ty;
480 if (!ty || !ty->dcast) return ty;
481 while (ty && (ty->dcast)) {
482 ty = (*ty->dcast)(ptr);
483 if (ty) lastty = ty;
484 }
485 return lastty;
486 }
487
488 /*
489 Return the name associated with this type
490 */
491 SWIGRUNTIMEINLINE const char *
492 SWIG_TypeName(const swig_type_info *ty) {
493 return ty->name;
494 }
495
496 /*
497 Return the pretty name associated with this type,
498 that is an unmangled type name in a form presentable to the user.
499 */
500 SWIGRUNTIME const char *
501 SWIG_TypePrettyName(const swig_type_info *type) {
502 /* The "str" field contains the equivalent pretty names of the
503 type, separated by vertical-bar characters. We choose
504 to print the last name, as it is often (?) the most
505 specific. */
506 if (!type) return NULL;
507 if (type->str != NULL) {
508 const char *last_name = type->str;
509 const char *s;
510 for (s = type->str; *s; s++)
511 if (*s == '|') last_name = s+1;
512 return last_name;
513 }
514 else
515 return type->name;
516 }
517
518 /*
519 Set the clientdata field for a type
520 */
521 SWIGRUNTIME void
522 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
523 swig_cast_info *cast = ti->cast;
524 /* if (ti->clientdata == clientdata) return; */
525 ti->clientdata = clientdata;
526
527 while (cast) {
528 if (!cast->converter) {
529 swig_type_info *tc = cast->type;
530 if (!tc->clientdata) {
531 SWIG_TypeClientData(tc, clientdata);
532 }
533 }
534 cast = cast->next;
535 }
536 }
537 SWIGRUNTIME void
538 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
539 SWIG_TypeClientData(ti, clientdata);
540 ti->owndata = 1;
541 }
542
543 /*
544 Search for a swig_type_info structure only by mangled name
545 Search is a O(log #types)
546
547 We start searching at module start, and finish searching when start == end.
548 Note: if start == end at the beginning of the function, we go all the way around
549 the circular list.
550 */
551 SWIGRUNTIME swig_type_info *
552 SWIG_MangledTypeQueryModule(swig_module_info *start,
553 swig_module_info *end,
554 const char *name) {
555 swig_module_info *iter = start;
556 do {
557 if (iter->size) {
558 size_t l = 0;
559 size_t r = iter->size - 1;
560 do {
561 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
562 size_t i = (l + r) >> 1;
563 const char *iname = iter->types[i]->name;
564 if (iname) {
565 int compare = strcmp(name, iname);
566 if (compare == 0) {
567 return iter->types[i];
568 } else if (compare < 0) {
569 if (i) {
570 r = i - 1;
571 } else {
572 break;
573 }
574 } else if (compare > 0) {
575 l = i + 1;
576 }
577 } else {
578 break; /* should never happen */
579 }
580 } while (l <= r);
581 }
582 iter = iter->next;
583 } while (iter != end);
584 return 0;
585 }
586
587 /*
588 Search for a swig_type_info structure for either a mangled name or a human readable name.
589 It first searches the mangled names of the types, which is a O(log #types)
590 If a type is not found it then searches the human readable names, which is O(#types).
591
592 We start searching at module start, and finish searching when start == end.
593 Note: if start == end at the beginning of the function, we go all the way around
594 the circular list.
595 */
596 SWIGRUNTIME swig_type_info *
597 SWIG_TypeQueryModule(swig_module_info *start,
598 swig_module_info *end,
599 const char *name) {
600 /* STEP 1: Search the name field using binary search */
601 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
602 if (ret) {
603 return ret;
604 } else {
605 /* STEP 2: If the type hasn't been found, do a complete search
606 of the str field (the human readable name) */
607 swig_module_info *iter = start;
608 do {
609 size_t i = 0;
610 for (; i < iter->size; ++i) {
611 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
612 return iter->types[i];
613 }
614 iter = iter->next;
615 } while (iter != end);
616 }
617
618 /* neither found a match */
619 return 0;
620 }
621
622 /*
623 Pack binary data into a string
624 */
625 SWIGRUNTIME char *
626 SWIG_PackData(char *c, void *ptr, size_t sz) {
627 static const char hex[17] = "0123456789abcdef";
628 const unsigned char *u = (unsigned char *) ptr;
629 const unsigned char *eu = u + sz;
630 for (; u != eu; ++u) {
631 unsigned char uu = *u;
632 *(c++) = hex[(uu & 0xf0) >> 4];
633 *(c++) = hex[uu & 0xf];
634 }
635 return c;
636 }
637
638 /*
639 Unpack binary data from a string
640 */
641 SWIGRUNTIME const char *
642 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
643 unsigned char *u = (unsigned char *) ptr;
644 const unsigned char *eu = u + sz;
645 for (; u != eu; ++u) {
646 char d = *(c++);
647 unsigned char uu;
648 if ((d >= '0') && (d <= '9'))
649 uu = (unsigned char)((d - '0') << 4);
650 else if ((d >= 'a') && (d <= 'f'))
651 uu = (unsigned char)((d - ('a'-10)) << 4);
652 else
653 return (char *) 0;
654 d = *(c++);
655 if ((d >= '0') && (d <= '9'))
656 uu |= (unsigned char)(d - '0');
657 else if ((d >= 'a') && (d <= 'f'))
658 uu |= (unsigned char)(d - ('a'-10));
659 else
660 return (char *) 0;
661 *u = uu;
662 }
663 return c;
664 }
665
666 /*
667 Pack 'void *' into a string buffer.
668 */
669 SWIGRUNTIME char *
670 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
671 char *r = buff;
672 if ((2*sizeof(void *) + 2) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,&ptr,sizeof(void *));
675 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
676 strcpy(r,name);
677 return buff;
678 }
679
680 SWIGRUNTIME const char *
681 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
682 if (*c != '_') {
683 if (strcmp(c,"NULL") == 0) {
684 *ptr = (void *) 0;
685 return name;
686 } else {
687 return 0;
688 }
689 }
690 return SWIG_UnpackData(++c,ptr,sizeof(void *));
691 }
692
693 SWIGRUNTIME char *
694 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
695 char *r = buff;
696 size_t lname = (name ? strlen(name) : 0);
697 if ((2*sz + 2 + lname) > bsz) return 0;
698 *(r++) = '_';
699 r = SWIG_PackData(r,ptr,sz);
700 if (lname) {
701 strncpy(r,name,lname+1);
702 } else {
703 *r = 0;
704 }
705 return buff;
706 }
707
708 SWIGRUNTIME const char *
709 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
710 if (*c != '_') {
711 if (strcmp(c,"NULL") == 0) {
712 memset(ptr,0,sz);
713 return name;
714 } else {
715 return 0;
716 }
717 }
718 return SWIG_UnpackData(++c,ptr,sz);
719 }
720
721 #ifdef __cplusplus
722 }
723 #endif
724
725 /* Errors in SWIG */
726 #define SWIG_UnknownError -1
727 #define SWIG_IOError -2
728 #define SWIG_RuntimeError -3
729 #define SWIG_IndexError -4
730 #define SWIG_TypeError -5
731 #define SWIG_DivisionByZero -6
732 #define SWIG_OverflowError -7
733 #define SWIG_SyntaxError -8
734 #define SWIG_ValueError -9
735 #define SWIG_SystemError -10
736 #define SWIG_AttributeError -11
737 #define SWIG_MemoryError -12
738 #define SWIG_NullReferenceError -13
739
740
741
742 /* Compatibility macros for Python 3 */
743 #if PY_VERSION_HEX >= 0x03000000
744
745 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
746 #define PyInt_Check(x) PyLong_Check(x)
747 #define PyInt_AsLong(x) PyLong_AsLong(x)
748 #define PyInt_FromLong(x) PyLong_FromLong(x)
749 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
750 #define PyString_Check(name) PyBytes_Check(name)
751 #define PyString_FromString(x) PyUnicode_FromString(x)
752 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
753 #define PyString_AsString(str) PyBytes_AsString(str)
754 #define PyString_Size(str) PyBytes_Size(str)
755 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
756 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
757 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
758 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
759
760 #endif
761
762 #ifndef Py_TYPE
763 # define Py_TYPE(op) ((op)->ob_type)
764 #endif
765
766 /* SWIG APIs for compatibility of both Python 2 & 3 */
767
768 #if PY_VERSION_HEX >= 0x03000000
769 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
770 #else
771 # define SWIG_Python_str_FromFormat PyString_FromFormat
772 #endif
773
774
775 /* Warning: This function will allocate a new string in Python 3,
776 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
777 */
778 SWIGINTERN char*
779 SWIG_Python_str_AsChar(PyObject *str)
780 {
781 #if PY_VERSION_HEX >= 0x03000000
782 char *cstr;
783 char *newstr;
784 Py_ssize_t len;
785 str = PyUnicode_AsUTF8String(str);
786 PyBytes_AsStringAndSize(str, &cstr, &len);
787 newstr = (char *) malloc(len+1);
788 memcpy(newstr, cstr, len+1);
789 Py_XDECREF(str);
790 return newstr;
791 #else
792 return PyString_AsString(str);
793 #endif
794 }
795
796 #if PY_VERSION_HEX >= 0x03000000
797 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
798 #else
799 # define SWIG_Python_str_DelForPy3(x)
800 #endif
801
802
803 SWIGINTERN PyObject*
804 SWIG_Python_str_FromChar(const char *c)
805 {
806 #if PY_VERSION_HEX >= 0x03000000
807 return PyUnicode_FromString(c);
808 #else
809 return PyString_FromString(c);
810 #endif
811 }
812
813 /* Add PyOS_snprintf for old Pythons */
814 #if PY_VERSION_HEX < 0x02020000
815 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
816 # define PyOS_snprintf _snprintf
817 # else
818 # define PyOS_snprintf snprintf
819 # endif
820 #endif
821
822 /* A crude PyString_FromFormat implementation for old Pythons */
823 #if PY_VERSION_HEX < 0x02020000
824
825 #ifndef SWIG_PYBUFFER_SIZE
826 # define SWIG_PYBUFFER_SIZE 1024
827 #endif
828
829 static PyObject *
830 PyString_FromFormat(const char *fmt, ...) {
831 va_list ap;
832 char buf[SWIG_PYBUFFER_SIZE * 2];
833 int res;
834 va_start(ap, fmt);
835 res = vsnprintf(buf, sizeof(buf), fmt, ap);
836 va_end(ap);
837 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
838 }
839 #endif
840
841 #ifndef PyObject_DEL
842 # define PyObject_DEL PyObject_Del
843 #endif
844
845 /* A crude PyExc_StopIteration exception for old Pythons */
846 #if PY_VERSION_HEX < 0x02020000
847 # ifndef PyExc_StopIteration
848 # define PyExc_StopIteration PyExc_RuntimeError
849 # endif
850 # ifndef PyObject_GenericGetAttr
851 # define PyObject_GenericGetAttr 0
852 # endif
853 #endif
854
855 /* Py_NotImplemented is defined in 2.1 and up. */
856 #if PY_VERSION_HEX < 0x02010000
857 # ifndef Py_NotImplemented
858 # define Py_NotImplemented PyExc_RuntimeError
859 # endif
860 #endif
861
862 /* A crude PyString_AsStringAndSize implementation for old Pythons */
863 #if PY_VERSION_HEX < 0x02010000
864 # ifndef PyString_AsStringAndSize
865 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
866 # endif
867 #endif
868
869 /* PySequence_Size for old Pythons */
870 #if PY_VERSION_HEX < 0x02000000
871 # ifndef PySequence_Size
872 # define PySequence_Size PySequence_Length
873 # endif
874 #endif
875
876 /* PyBool_FromLong for old Pythons */
877 #if PY_VERSION_HEX < 0x02030000
878 static
879 PyObject *PyBool_FromLong(long ok)
880 {
881 PyObject *result = ok ? Py_True : Py_False;
882 Py_INCREF(result);
883 return result;
884 }
885 #endif
886
887 /* Py_ssize_t for old Pythons */
888 /* This code is as recommended by: */
889 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
890 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
891 typedef int Py_ssize_t;
892 # define PY_SSIZE_T_MAX INT_MAX
893 # define PY_SSIZE_T_MIN INT_MIN
894 typedef inquiry lenfunc;
895 typedef intargfunc ssizeargfunc;
896 typedef intintargfunc ssizessizeargfunc;
897 typedef intobjargproc ssizeobjargproc;
898 typedef intintobjargproc ssizessizeobjargproc;
899 typedef getreadbufferproc readbufferproc;
900 typedef getwritebufferproc writebufferproc;
901 typedef getsegcountproc segcountproc;
902 typedef getcharbufferproc charbufferproc;
903 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
904 {
905 long result = 0;
906 PyObject *i = PyNumber_Int(x);
907 if (i) {
908 result = PyInt_AsLong(i);
909 Py_DECREF(i);
910 }
911 return result;
912 }
913 #endif
914
915 #if PY_VERSION_HEX < 0x02050000
916 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
917 #endif
918
919 #if PY_VERSION_HEX < 0x02040000
920 #define Py_VISIT(op) \
921 do { \
922 if (op) { \
923 int vret = visit((op), arg); \
924 if (vret) \
925 return vret; \
926 } \
927 } while (0)
928 #endif
929
930 #if PY_VERSION_HEX < 0x02030000
931 typedef struct {
932 PyTypeObject type;
933 PyNumberMethods as_number;
934 PyMappingMethods as_mapping;
935 PySequenceMethods as_sequence;
936 PyBufferProcs as_buffer;
937 PyObject *name, *slots;
938 } PyHeapTypeObject;
939 #endif
940
941 #if PY_VERSION_HEX < 0x02030000
942 typedef destructor freefunc;
943 #endif
944
945 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
946 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
947 (PY_MAJOR_VERSION > 3))
948 # define SWIGPY_USE_CAPSULE
949 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
950 #endif
951
952 #if PY_VERSION_HEX < 0x03020000
953 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
954 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
955 #define Py_hash_t long
956 #endif
957
958 /* -----------------------------------------------------------------------------
959 * error manipulation
960 * ----------------------------------------------------------------------------- */
961
962 SWIGRUNTIME PyObject*
963 SWIG_Python_ErrorType(int code) {
964 PyObject* type = 0;
965 switch(code) {
966 case SWIG_MemoryError:
967 type = PyExc_MemoryError;
968 break;
969 case SWIG_IOError:
970 type = PyExc_IOError;
971 break;
972 case SWIG_RuntimeError:
973 type = PyExc_RuntimeError;
974 break;
975 case SWIG_IndexError:
976 type = PyExc_IndexError;
977 break;
978 case SWIG_TypeError:
979 type = PyExc_TypeError;
980 break;
981 case SWIG_DivisionByZero:
982 type = PyExc_ZeroDivisionError;
983 break;
984 case SWIG_OverflowError:
985 type = PyExc_OverflowError;
986 break;
987 case SWIG_SyntaxError:
988 type = PyExc_SyntaxError;
989 break;
990 case SWIG_ValueError:
991 type = PyExc_ValueError;
992 break;
993 case SWIG_SystemError:
994 type = PyExc_SystemError;
995 break;
996 case SWIG_AttributeError:
997 type = PyExc_AttributeError;
998 break;
999 default:
1000 type = PyExc_RuntimeError;
1001 }
1002 return type;
1003 }
1004
1005
1006 SWIGRUNTIME void
1007 SWIG_Python_AddErrorMsg(const char* mesg)
1008 {
1009 PyObject *type = 0;
1010 PyObject *value = 0;
1011 PyObject *traceback = 0;
1012
1013 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1014 if (value) {
1015 char *tmp;
1016 PyObject *old_str = PyObject_Str(value);
1017 PyErr_Clear();
1018 Py_XINCREF(type);
1019
1020 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1021 SWIG_Python_str_DelForPy3(tmp);
1022 Py_DECREF(old_str);
1023 Py_DECREF(value);
1024 } else {
1025 PyErr_SetString(PyExc_RuntimeError, mesg);
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 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1037 # define SWIG_PYTHON_USE_GIL
1038 # endif
1039 # endif
1040 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1041 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1042 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1043 # endif
1044 # ifdef __cplusplus /* C++ code */
1045 class SWIG_Python_Thread_Block {
1046 bool status;
1047 PyGILState_STATE state;
1048 public:
1049 void end() { if (status) { PyGILState_Release(state); status = false;} }
1050 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1051 ~SWIG_Python_Thread_Block() { end(); }
1052 };
1053 class SWIG_Python_Thread_Allow {
1054 bool status;
1055 PyThreadState *save;
1056 public:
1057 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1058 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1059 ~SWIG_Python_Thread_Allow() { end(); }
1060 };
1061 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1062 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1063 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1064 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1065 # else /* C code */
1066 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1067 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1068 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1069 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1070 # endif
1071 # else /* Old thread way, not implemented, user must provide it */
1072 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1073 # define SWIG_PYTHON_INITIALIZE_THREADS
1074 # endif
1075 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1076 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1077 # endif
1078 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1079 # define SWIG_PYTHON_THREAD_END_BLOCK
1080 # endif
1081 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1082 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1083 # endif
1084 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1085 # define SWIG_PYTHON_THREAD_END_ALLOW
1086 # endif
1087 # endif
1088 #else /* No thread support */
1089 # define SWIG_PYTHON_INITIALIZE_THREADS
1090 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1091 # define SWIG_PYTHON_THREAD_END_BLOCK
1092 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1093 # define SWIG_PYTHON_THREAD_END_ALLOW
1094 #endif
1095
1096 /* -----------------------------------------------------------------------------
1097 * Python API portion that goes into the runtime
1098 * ----------------------------------------------------------------------------- */
1099
1100 #ifdef __cplusplus
1101 extern "C" {
1102 #endif
1103
1104 /* -----------------------------------------------------------------------------
1105 * Constant declarations
1106 * ----------------------------------------------------------------------------- */
1107
1108 /* Constant Types */
1109 #define SWIG_PY_POINTER 4
1110 #define SWIG_PY_BINARY 5
1111
1112 /* Constant information structure */
1113 typedef struct swig_const_info {
1114 int type;
1115 char *name;
1116 long lvalue;
1117 double dvalue;
1118 void *pvalue;
1119 swig_type_info **ptype;
1120 } swig_const_info;
1121
1122
1123 /* -----------------------------------------------------------------------------
1124 * Wrapper of PyInstanceMethod_New() used in Python 3
1125 * It is exported to the generated module, used for -fastproxy
1126 * ----------------------------------------------------------------------------- */
1127 #if PY_VERSION_HEX >= 0x03000000
1128 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1129 {
1130 return PyInstanceMethod_New(func);
1131 }
1132 #else
1133 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1134 {
1135 return NULL;
1136 }
1137 #endif
1138
1139 #ifdef __cplusplus
1140 }
1141 #endif
1142
1143
1144 /* -----------------------------------------------------------------------------
1145 * pyrun.swg
1146 *
1147 * This file contains the runtime support for Python modules
1148 * and includes code for managing global variables and pointer
1149 * type checking.
1150 *
1151 * ----------------------------------------------------------------------------- */
1152
1153 /* Common SWIG API */
1154
1155 /* for raw pointers */
1156 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1157 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1158 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1159
1160 #ifdef SWIGPYTHON_BUILTIN
1161 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1162 #else
1163 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1164 #endif
1165
1166 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1167
1168 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1169 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1170 #define swig_owntype int
1171
1172 /* for raw packed data */
1173 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1174 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1175
1176 /* for class or struct pointers */
1177 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1178 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1179
1180 /* for C or C++ function pointers */
1181 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1182 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1183
1184 /* for C++ member pointers, ie, member methods */
1185 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1186 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1187
1188
1189 /* Runtime API */
1190
1191 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1192 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1193 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1194
1195 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1196 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1197 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1198 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1199 #define SWIG_fail goto fail
1200
1201
1202 /* Runtime API implementation */
1203
1204 /* Error manipulation */
1205
1206 SWIGINTERN void
1207 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1208 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1209 PyErr_SetObject(errtype, obj);
1210 Py_DECREF(obj);
1211 SWIG_PYTHON_THREAD_END_BLOCK;
1212 }
1213
1214 SWIGINTERN void
1215 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1216 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1217 PyErr_SetString(errtype, msg);
1218 SWIG_PYTHON_THREAD_END_BLOCK;
1219 }
1220
1221 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1222
1223 /* Set a constant value */
1224
1225 #if defined(SWIGPYTHON_BUILTIN)
1226
1227 SWIGINTERN void
1228 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1229 PyObject *s = PyString_InternFromString(key);
1230 PyList_Append(seq, s);
1231 Py_DECREF(s);
1232 }
1233
1234 SWIGINTERN void
1235 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1236 #if PY_VERSION_HEX < 0x02030000
1237 PyDict_SetItemString(d, (char *)name, obj);
1238 #else
1239 PyDict_SetItemString(d, name, obj);
1240 #endif
1241 Py_DECREF(obj);
1242 if (public_interface)
1243 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1244 }
1245
1246 #else
1247
1248 SWIGINTERN void
1249 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1250 #if PY_VERSION_HEX < 0x02030000
1251 PyDict_SetItemString(d, (char *)name, obj);
1252 #else
1253 PyDict_SetItemString(d, name, obj);
1254 #endif
1255 Py_DECREF(obj);
1256 }
1257
1258 #endif
1259
1260 /* Append a value to the result obj */
1261
1262 SWIGINTERN PyObject*
1263 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1264 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1265 if (!result) {
1266 result = obj;
1267 } else if (result == Py_None) {
1268 Py_DECREF(result);
1269 result = obj;
1270 } else {
1271 if (!PyList_Check(result)) {
1272 PyObject *o2 = result;
1273 result = PyList_New(1);
1274 PyList_SetItem(result, 0, o2);
1275 }
1276 PyList_Append(result,obj);
1277 Py_DECREF(obj);
1278 }
1279 return result;
1280 #else
1281 PyObject* o2;
1282 PyObject* o3;
1283 if (!result) {
1284 result = obj;
1285 } else if (result == Py_None) {
1286 Py_DECREF(result);
1287 result = obj;
1288 } else {
1289 if (!PyTuple_Check(result)) {
1290 o2 = result;
1291 result = PyTuple_New(1);
1292 PyTuple_SET_ITEM(result, 0, o2);
1293 }
1294 o3 = PyTuple_New(1);
1295 PyTuple_SET_ITEM(o3, 0, obj);
1296 o2 = result;
1297 result = PySequence_Concat(o2, o3);
1298 Py_DECREF(o2);
1299 Py_DECREF(o3);
1300 }
1301 return result;
1302 #endif
1303 }
1304
1305 /* Unpack the argument tuple */
1306
1307 SWIGINTERN Py_ssize_t
1308 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1309 {
1310 if (!args) {
1311 if (!min && !max) {
1312 return 1;
1313 } else {
1314 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1315 name, (min == max ? "" : "at least "), (int)min);
1316 return 0;
1317 }
1318 }
1319 if (!PyTuple_Check(args)) {
1320 if (min <= 1 && max >= 1) {
1321 Py_ssize_t i;
1322 objs[0] = args;
1323 for (i = 1; i < max; ++i) {
1324 objs[i] = 0;
1325 }
1326 return 2;
1327 }
1328 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1329 return 0;
1330 } else {
1331 Py_ssize_t l = PyTuple_GET_SIZE(args);
1332 if (l < min) {
1333 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1334 name, (min == max ? "" : "at least "), (int)min, (int)l);
1335 return 0;
1336 } else if (l > max) {
1337 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1338 name, (min == max ? "" : "at most "), (int)max, (int)l);
1339 return 0;
1340 } else {
1341 Py_ssize_t i;
1342 for (i = 0; i < l; ++i) {
1343 objs[i] = PyTuple_GET_ITEM(args, i);
1344 }
1345 for (; l < max; ++l) {
1346 objs[l] = 0;
1347 }
1348 return i + 1;
1349 }
1350 }
1351 }
1352
1353 /* A functor is a function object with one single object argument */
1354 #if PY_VERSION_HEX >= 0x02020000
1355 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1356 #else
1357 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1358 #endif
1359
1360 /*
1361 Helper for static pointer initialization for both C and C++ code, for example
1362 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1363 */
1364 #ifdef __cplusplus
1365 #define SWIG_STATIC_POINTER(var) var
1366 #else
1367 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1368 #endif
1369
1370 /* -----------------------------------------------------------------------------
1371 * Pointer declarations
1372 * ----------------------------------------------------------------------------- */
1373
1374 /* Flags for new pointer objects */
1375 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1376 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1377
1378 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1379
1380 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1381 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1382
1383 #ifdef __cplusplus
1384 extern "C" {
1385 #endif
1386
1387 /* How to access Py_None */
1388 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1389 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1390 # ifndef SWIG_PYTHON_BUILD_NONE
1391 # define SWIG_PYTHON_BUILD_NONE
1392 # endif
1393 # endif
1394 #endif
1395
1396 #ifdef SWIG_PYTHON_BUILD_NONE
1397 # ifdef Py_None
1398 # undef Py_None
1399 # define Py_None SWIG_Py_None()
1400 # endif
1401 SWIGRUNTIMEINLINE PyObject *
1402 _SWIG_Py_None(void)
1403 {
1404 PyObject *none = Py_BuildValue((char*)"");
1405 Py_DECREF(none);
1406 return none;
1407 }
1408 SWIGRUNTIME PyObject *
1409 SWIG_Py_None(void)
1410 {
1411 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1412 return none;
1413 }
1414 #endif
1415
1416 /* The python void return value */
1417
1418 SWIGRUNTIMEINLINE PyObject *
1419 SWIG_Py_Void(void)
1420 {
1421 PyObject *none = Py_None;
1422 Py_INCREF(none);
1423 return none;
1424 }
1425
1426 /* SwigPyClientData */
1427
1428 typedef struct {
1429 PyObject *klass;
1430 PyObject *newraw;
1431 PyObject *newargs;
1432 PyObject *destroy;
1433 int delargs;
1434 int implicitconv;
1435 PyTypeObject *pytype;
1436 } SwigPyClientData;
1437
1438 SWIGRUNTIMEINLINE int
1439 SWIG_Python_CheckImplicit(swig_type_info *ty)
1440 {
1441 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1442 return data ? data->implicitconv : 0;
1443 }
1444
1445 SWIGRUNTIMEINLINE PyObject *
1446 SWIG_Python_ExceptionType(swig_type_info *desc) {
1447 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1448 PyObject *klass = data ? data->klass : 0;
1449 return (klass ? klass : PyExc_RuntimeError);
1450 }
1451
1452
1453 SWIGRUNTIME SwigPyClientData *
1454 SwigPyClientData_New(PyObject* obj)
1455 {
1456 if (!obj) {
1457 return 0;
1458 } else {
1459 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1460 /* the klass element */
1461 data->klass = obj;
1462 Py_INCREF(data->klass);
1463 /* the newraw method and newargs arguments used to create a new raw instance */
1464 if (PyClass_Check(obj)) {
1465 data->newraw = 0;
1466 data->newargs = obj;
1467 Py_INCREF(obj);
1468 } else {
1469 #if (PY_VERSION_HEX < 0x02020000)
1470 data->newraw = 0;
1471 #else
1472 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1473 #endif
1474 if (data->newraw) {
1475 Py_INCREF(data->newraw);
1476 data->newargs = PyTuple_New(1);
1477 PyTuple_SetItem(data->newargs, 0, obj);
1478 } else {
1479 data->newargs = obj;
1480 }
1481 Py_INCREF(data->newargs);
1482 }
1483 /* the destroy method, aka as the C++ delete method */
1484 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1485 if (PyErr_Occurred()) {
1486 PyErr_Clear();
1487 data->destroy = 0;
1488 }
1489 if (data->destroy) {
1490 int flags;
1491 Py_INCREF(data->destroy);
1492 flags = PyCFunction_GET_FLAGS(data->destroy);
1493 #ifdef METH_O
1494 data->delargs = !(flags & (METH_O));
1495 #else
1496 data->delargs = 0;
1497 #endif
1498 } else {
1499 data->delargs = 0;
1500 }
1501 data->implicitconv = 0;
1502 data->pytype = 0;
1503 return data;
1504 }
1505 }
1506
1507 SWIGRUNTIME void
1508 SwigPyClientData_Del(SwigPyClientData *data) {
1509 Py_XDECREF(data->newraw);
1510 Py_XDECREF(data->newargs);
1511 Py_XDECREF(data->destroy);
1512 }
1513
1514 /* =============== SwigPyObject =====================*/
1515
1516 typedef struct {
1517 PyObject_HEAD
1518 void *ptr;
1519 swig_type_info *ty;
1520 int own;
1521 PyObject *next;
1522 #ifdef SWIGPYTHON_BUILTIN
1523 PyObject *dict;
1524 #endif
1525 } SwigPyObject;
1526
1527
1528 #ifdef SWIGPYTHON_BUILTIN
1529
1530 SWIGRUNTIME PyObject *
1531 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1532 {
1533 SwigPyObject *sobj = (SwigPyObject *)v;
1534
1535 if (!sobj->dict)
1536 sobj->dict = PyDict_New();
1537
1538 Py_INCREF(sobj->dict);
1539 return sobj->dict;
1540 }
1541
1542 #endif
1543
1544 SWIGRUNTIME PyObject *
1545 SwigPyObject_long(SwigPyObject *v)
1546 {
1547 return PyLong_FromVoidPtr(v->ptr);
1548 }
1549
1550 SWIGRUNTIME PyObject *
1551 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1552 {
1553 PyObject *res = NULL;
1554 PyObject *args = PyTuple_New(1);
1555 if (args) {
1556 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1557 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1558 if (ofmt) {
1559 #if PY_VERSION_HEX >= 0x03000000
1560 res = PyUnicode_Format(ofmt,args);
1561 #else
1562 res = PyString_Format(ofmt,args);
1563 #endif
1564 Py_DECREF(ofmt);
1565 }
1566 Py_DECREF(args);
1567 }
1568 }
1569 return res;
1570 }
1571
1572 SWIGRUNTIME PyObject *
1573 SwigPyObject_oct(SwigPyObject *v)
1574 {
1575 return SwigPyObject_format("%o",v);
1576 }
1577
1578 SWIGRUNTIME PyObject *
1579 SwigPyObject_hex(SwigPyObject *v)
1580 {
1581 return SwigPyObject_format("%x",v);
1582 }
1583
1584 SWIGRUNTIME PyObject *
1585 #ifdef METH_NOARGS
1586 SwigPyObject_repr(SwigPyObject *v)
1587 #else
1588 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1589 #endif
1590 {
1591 const char *name = SWIG_TypePrettyName(v->ty);
1592 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1593 if (v->next) {
1594 # ifdef METH_NOARGS
1595 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1596 # else
1597 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1598 # endif
1599 # if PY_VERSION_HEX >= 0x03000000
1600 PyObject *joined = PyUnicode_Concat(repr, nrep);
1601 Py_DecRef(repr);
1602 Py_DecRef(nrep);
1603 repr = joined;
1604 # else
1605 PyString_ConcatAndDel(&repr,nrep);
1606 # endif
1607 }
1608 return repr;
1609 }
1610
1611 /* We need a version taking two PyObject* parameters so it's a valid
1612 * PyCFunction to use in swigobject_methods[]. */
1613 SWIGRUNTIME PyObject *
1614 SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1615 {
1616 return SwigPyObject_repr((SwigPyObject*)v);
1617 }
1618
1619 SWIGRUNTIME int
1620 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1621 {
1622 void *i = v->ptr;
1623 void *j = w->ptr;
1624 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1625 }
1626
1627 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1628 SWIGRUNTIME PyObject*
1629 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1630 {
1631 PyObject* res;
1632 if( op != Py_EQ && op != Py_NE ) {
1633 Py_INCREF(Py_NotImplemented);
1634 return Py_NotImplemented;
1635 }
1636 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1637 return res;
1638 }
1639
1640
1641 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1642
1643 #ifdef SWIGPYTHON_BUILTIN
1644 static swig_type_info *SwigPyObject_stype = 0;
1645 SWIGRUNTIME PyTypeObject*
1646 SwigPyObject_type(void) {
1647 SwigPyClientData *cd;
1648 assert(SwigPyObject_stype);
1649 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1650 assert(cd);
1651 assert(cd->pytype);
1652 return cd->pytype;
1653 }
1654 #else
1655 SWIGRUNTIME PyTypeObject*
1656 SwigPyObject_type(void) {
1657 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1658 return type;
1659 }
1660 #endif
1661
1662 SWIGRUNTIMEINLINE int
1663 SwigPyObject_Check(PyObject *op) {
1664 #ifdef SWIGPYTHON_BUILTIN
1665 PyTypeObject *target_tp = SwigPyObject_type();
1666 if (PyType_IsSubtype(op->ob_type, target_tp))
1667 return 1;
1668 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1669 #else
1670 return (Py_TYPE(op) == SwigPyObject_type())
1671 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1672 #endif
1673 }
1674
1675 SWIGRUNTIME PyObject *
1676 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1677
1678 SWIGRUNTIME void
1679 SwigPyObject_dealloc(PyObject *v)
1680 {
1681 SwigPyObject *sobj = (SwigPyObject *) v;
1682 PyObject *next = sobj->next;
1683 if (sobj->own == SWIG_POINTER_OWN) {
1684 swig_type_info *ty = sobj->ty;
1685 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1686 PyObject *destroy = data ? data->destroy : 0;
1687 if (destroy) {
1688 /* destroy is always a VARARGS method */
1689 PyObject *res;
1690
1691 /* PyObject_CallFunction() has the potential to silently drop
1692 the active active exception. In cases of unnamed temporary
1693 variable or where we just finished iterating over a generator
1694 StopIteration will be active right now, and this needs to
1695 remain true upon return from SwigPyObject_dealloc. So save
1696 and restore. */
1697
1698 PyObject *val = NULL, *type = NULL, *tb = NULL;
1699 PyErr_Fetch(&val, &type, &tb);
1700
1701 if (data->delargs) {
1702 /* we need to create a temporary object to carry the destroy operation */
1703 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1704 res = SWIG_Python_CallFunctor(destroy, tmp);
1705 Py_DECREF(tmp);
1706 } else {
1707 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1708 PyObject *mself = PyCFunction_GET_SELF(destroy);
1709 res = ((*meth)(mself, v));
1710 }
1711 if (!res)
1712 PyErr_WriteUnraisable(destroy);
1713
1714 PyErr_Restore(val, type, tb);
1715
1716 Py_XDECREF(res);
1717 }
1718 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1719 else {
1720 const char *name = SWIG_TypePrettyName(ty);
1721 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1722 }
1723 #endif
1724 }
1725 Py_XDECREF(next);
1726 PyObject_DEL(v);
1727 }
1728
1729 SWIGRUNTIME PyObject*
1730 SwigPyObject_append(PyObject* v, PyObject* next)
1731 {
1732 SwigPyObject *sobj = (SwigPyObject *) v;
1733 #ifndef METH_O
1734 PyObject *tmp = 0;
1735 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1736 next = tmp;
1737 #endif
1738 if (!SwigPyObject_Check(next)) {
1739 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1740 return NULL;
1741 }
1742 sobj->next = next;
1743 Py_INCREF(next);
1744 return SWIG_Py_Void();
1745 }
1746
1747 SWIGRUNTIME PyObject*
1748 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1749 {
1750 SwigPyObject *sobj = (SwigPyObject *) v;
1751 if (sobj->next) {
1752 Py_INCREF(sobj->next);
1753 return sobj->next;
1754 } else {
1755 return SWIG_Py_Void();
1756 }
1757 }
1758
1759 SWIGINTERN PyObject*
1760 #ifdef METH_NOARGS
1761 SwigPyObject_disown(PyObject *v)
1762 #else
1763 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1764 #endif
1765 {
1766 SwigPyObject *sobj = (SwigPyObject *)v;
1767 sobj->own = 0;
1768 return SWIG_Py_Void();
1769 }
1770
1771 SWIGINTERN PyObject*
1772 #ifdef METH_NOARGS
1773 SwigPyObject_acquire(PyObject *v)
1774 #else
1775 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1776 #endif
1777 {
1778 SwigPyObject *sobj = (SwigPyObject *)v;
1779 sobj->own = SWIG_POINTER_OWN;
1780 return SWIG_Py_Void();
1781 }
1782
1783 #ifdef METH_NOARGS
1784 static PyObject*
1785 SwigPyObject_disown2(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1786 {
1787 return SwigPyObject_disown(v);
1788 }
1789
1790 static PyObject*
1791 SwigPyObject_acquire2(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1792 {
1793 return SwigPyObject_acquire(v);
1794 }
1795 #endif
1796
1797 SWIGINTERN PyObject*
1798 SwigPyObject_own(PyObject *v, PyObject *args)
1799 {
1800 PyObject *val = 0;
1801 #if (PY_VERSION_HEX < 0x02020000)
1802 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1803 #elif (PY_VERSION_HEX < 0x02050000)
1804 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1805 #else
1806 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1807 #endif
1808 {
1809 return NULL;
1810 }
1811 else
1812 {
1813 SwigPyObject *sobj = (SwigPyObject *)v;
1814 PyObject *obj = PyBool_FromLong(sobj->own);
1815 if (val) {
1816 #ifdef METH_NOARGS
1817 if (PyObject_IsTrue(val)) {
1818 SwigPyObject_acquire(v);
1819 } else {
1820 SwigPyObject_disown(v);
1821 }
1822 #else
1823 if (PyObject_IsTrue(val)) {
1824 SwigPyObject_acquire(v,args);
1825 } else {
1826 SwigPyObject_disown(v,args);
1827 }
1828 #endif
1829 }
1830 return obj;
1831 }
1832 }
1833
1834 #ifdef METH_O
1835 static PyMethodDef
1836 swigobject_methods[] = {
1837 {(char *)"disown", (PyCFunction)SwigPyObject_disown2, METH_NOARGS, (char *)"releases ownership of the pointer"},
1838 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire2,METH_NOARGS, (char *)"acquires ownership of the pointer"},
1839 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1840 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1841 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1842 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr2, METH_NOARGS, (char *)"returns object representation"},
1843 {0, 0, 0, 0}
1844 };
1845 #else
1846 static PyMethodDef
1847 swigobject_methods[] = {
1848 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1849 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1850 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1851 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1852 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1853 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1854 {0, 0, 0, 0}
1855 };
1856 #endif
1857
1858 #if PY_VERSION_HEX < 0x02020000
1859 SWIGINTERN PyObject *
1860 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1861 {
1862 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1863 }
1864 #endif
1865
1866 SWIGRUNTIME PyTypeObject*
1867 SwigPyObject_TypeOnce(void) {
1868 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1869
1870 static PyNumberMethods SwigPyObject_as_number = {
1871 (binaryfunc)0, /*nb_add*/
1872 (binaryfunc)0, /*nb_subtract*/
1873 (binaryfunc)0, /*nb_multiply*/
1874 /* nb_divide removed in Python 3 */
1875 #if PY_VERSION_HEX < 0x03000000
1876 (binaryfunc)0, /*nb_divide*/
1877 #endif
1878 (binaryfunc)0, /*nb_remainder*/
1879 (binaryfunc)0, /*nb_divmod*/
1880 (ternaryfunc)0,/*nb_power*/
1881 (unaryfunc)0, /*nb_negative*/
1882 (unaryfunc)0, /*nb_positive*/
1883 (unaryfunc)0, /*nb_absolute*/
1884 (inquiry)0, /*nb_nonzero*/
1885 0, /*nb_invert*/
1886 0, /*nb_lshift*/
1887 0, /*nb_rshift*/
1888 0, /*nb_and*/
1889 0, /*nb_xor*/
1890 0, /*nb_or*/
1891 #if PY_VERSION_HEX < 0x03000000
1892 0, /*nb_coerce*/
1893 #endif
1894 (unaryfunc)SwigPyObject_long, /*nb_int*/
1895 #if PY_VERSION_HEX < 0x03000000
1896 (unaryfunc)SwigPyObject_long, /*nb_long*/
1897 #else
1898 0, /*nb_reserved*/
1899 #endif
1900 (unaryfunc)0, /*nb_float*/
1901 #if PY_VERSION_HEX < 0x03000000
1902 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1903 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1904 #endif
1905 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1906 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1907 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1908 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1909 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1910 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1911 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1912 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1913 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1914 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1915 #endif
1916 };
1917
1918 static PyTypeObject swigpyobject_type;
1919 static int type_init = 0;
1920 if (!type_init) {
1921 const PyTypeObject tmp = {
1922 #if PY_VERSION_HEX >= 0x03000000
1923 PyVarObject_HEAD_INIT(NULL, 0)
1924 #else
1925 PyObject_HEAD_INIT(NULL)
1926 0, /* ob_size */
1927 #endif
1928 (char *)"SwigPyObject", /* tp_name */
1929 sizeof(SwigPyObject), /* tp_basicsize */
1930 0, /* tp_itemsize */
1931 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1932 0, /* tp_print */
1933 #if PY_VERSION_HEX < 0x02020000
1934 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1935 #else
1936 (getattrfunc)0, /* tp_getattr */
1937 #endif
1938 (setattrfunc)0, /* tp_setattr */
1939 #if PY_VERSION_HEX >= 0x03000000
1940 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1941 #else
1942 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1943 #endif
1944 (reprfunc)SwigPyObject_repr, /* tp_repr */
1945 &SwigPyObject_as_number, /* tp_as_number */
1946 0, /* tp_as_sequence */
1947 0, /* tp_as_mapping */
1948 (hashfunc)0, /* tp_hash */
1949 (ternaryfunc)0, /* tp_call */
1950 0, /* tp_str */
1951 PyObject_GenericGetAttr, /* tp_getattro */
1952 0, /* tp_setattro */
1953 0, /* tp_as_buffer */
1954 Py_TPFLAGS_DEFAULT, /* tp_flags */
1955 swigobject_doc, /* tp_doc */
1956 0, /* tp_traverse */
1957 0, /* tp_clear */
1958 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1959 0, /* tp_weaklistoffset */
1960 #if PY_VERSION_HEX >= 0x02020000
1961 0, /* tp_iter */
1962 0, /* tp_iternext */
1963 swigobject_methods, /* tp_methods */
1964 0, /* tp_members */
1965 0, /* tp_getset */
1966 0, /* tp_base */
1967 0, /* tp_dict */
1968 0, /* tp_descr_get */
1969 0, /* tp_descr_set */
1970 0, /* tp_dictoffset */
1971 0, /* tp_init */
1972 0, /* tp_alloc */
1973 0, /* tp_new */
1974 0, /* tp_free */
1975 0, /* tp_is_gc */
1976 0, /* tp_bases */
1977 0, /* tp_mro */
1978 0, /* tp_cache */
1979 0, /* tp_subclasses */
1980 0, /* tp_weaklist */
1981 #endif
1982 #if PY_VERSION_HEX >= 0x02030000
1983 0, /* tp_del */
1984 #endif
1985 #if PY_VERSION_HEX >= 0x02060000
1986 0, /* tp_version_tag */
1987 #endif
1988 #if PY_VERSION_HEX >= 0x03040000
1989 0, /* tp_finalize */
1990 #endif
1991 #ifdef COUNT_ALLOCS
1992 0, /* tp_allocs */
1993 0, /* tp_frees */
1994 0, /* tp_maxalloc */
1995 #if PY_VERSION_HEX >= 0x02050000
1996 0, /* tp_prev */
1997 #endif
1998 0 /* tp_next */
1999 #endif
2000 };
2001 swigpyobject_type = tmp;
2002 type_init = 1;
2003 #if PY_VERSION_HEX < 0x02020000
2004 swigpyobject_type.ob_type = &PyType_Type;
2005 #else
2006 if (PyType_Ready(&swigpyobject_type) < 0)
2007 return NULL;
2008 #endif
2009 }
2010 return &swigpyobject_type;
2011 }
2012
2013 SWIGRUNTIME PyObject *
2014 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2015 {
2016 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2017 if (sobj) {
2018 sobj->ptr = ptr;
2019 sobj->ty = ty;
2020 sobj->own = own;
2021 sobj->next = 0;
2022 }
2023 return (PyObject *)sobj;
2024 }
2025
2026 /* -----------------------------------------------------------------------------
2027 * Implements a simple Swig Packed type, and use it instead of string
2028 * ----------------------------------------------------------------------------- */
2029
2030 typedef struct {
2031 PyObject_HEAD
2032 void *pack;
2033 swig_type_info *ty;
2034 size_t size;
2035 } SwigPyPacked;
2036
2037 SWIGRUNTIME int
2038 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2039 {
2040 char result[SWIG_BUFFER_SIZE];
2041 fputs("<Swig Packed ", fp);
2042 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2043 fputs("at ", fp);
2044 fputs(result, fp);
2045 }
2046 fputs(v->ty->name,fp);
2047 fputs(">", fp);
2048 return 0;
2049 }
2050
2051 SWIGRUNTIME PyObject *
2052 SwigPyPacked_repr(SwigPyPacked *v)
2053 {
2054 char result[SWIG_BUFFER_SIZE];
2055 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2056 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2057 } else {
2058 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2059 }
2060 }
2061
2062 SWIGRUNTIME PyObject *
2063 SwigPyPacked_str(SwigPyPacked *v)
2064 {
2065 char result[SWIG_BUFFER_SIZE];
2066 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2067 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2068 } else {
2069 return SWIG_Python_str_FromChar(v->ty->name);
2070 }
2071 }
2072
2073 SWIGRUNTIME int
2074 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2075 {
2076 size_t i = v->size;
2077 size_t j = w->size;
2078 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2079 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2080 }
2081
2082 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2083
2084 SWIGRUNTIME PyTypeObject*
2085 SwigPyPacked_type(void) {
2086 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2087 return type;
2088 }
2089
2090 SWIGRUNTIMEINLINE int
2091 SwigPyPacked_Check(PyObject *op) {
2092 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2093 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2094 }
2095
2096 SWIGRUNTIME void
2097 SwigPyPacked_dealloc(PyObject *v)
2098 {
2099 if (SwigPyPacked_Check(v)) {
2100 SwigPyPacked *sobj = (SwigPyPacked *) v;
2101 free(sobj->pack);
2102 }
2103 PyObject_DEL(v);
2104 }
2105
2106 SWIGRUNTIME PyTypeObject*
2107 SwigPyPacked_TypeOnce(void) {
2108 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2109 static PyTypeObject swigpypacked_type;
2110 static int type_init = 0;
2111 if (!type_init) {
2112 const PyTypeObject tmp = {
2113 #if PY_VERSION_HEX>=0x03000000
2114 PyVarObject_HEAD_INIT(NULL, 0)
2115 #else
2116 PyObject_HEAD_INIT(NULL)
2117 0, /* ob_size */
2118 #endif
2119 (char *)"SwigPyPacked", /* tp_name */
2120 sizeof(SwigPyPacked), /* tp_basicsize */
2121 0, /* tp_itemsize */
2122 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2123 (printfunc)SwigPyPacked_print, /* tp_print */
2124 (getattrfunc)0, /* tp_getattr */
2125 (setattrfunc)0, /* tp_setattr */
2126 #if PY_VERSION_HEX>=0x03000000
2127 0, /* tp_reserved in 3.0.1 */
2128 #else
2129 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2130 #endif
2131 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2132 0, /* tp_as_number */
2133 0, /* tp_as_sequence */
2134 0, /* tp_as_mapping */
2135 (hashfunc)0, /* tp_hash */
2136 (ternaryfunc)0, /* tp_call */
2137 (reprfunc)SwigPyPacked_str, /* tp_str */
2138 PyObject_GenericGetAttr, /* tp_getattro */
2139 0, /* tp_setattro */
2140 0, /* tp_as_buffer */
2141 Py_TPFLAGS_DEFAULT, /* tp_flags */
2142 swigpacked_doc, /* tp_doc */
2143 0, /* tp_traverse */
2144 0, /* tp_clear */
2145 0, /* tp_richcompare */
2146 0, /* tp_weaklistoffset */
2147 #if PY_VERSION_HEX >= 0x02020000
2148 0, /* tp_iter */
2149 0, /* tp_iternext */
2150 0, /* tp_methods */
2151 0, /* tp_members */
2152 0, /* tp_getset */
2153 0, /* tp_base */
2154 0, /* tp_dict */
2155 0, /* tp_descr_get */
2156 0, /* tp_descr_set */
2157 0, /* tp_dictoffset */
2158 0, /* tp_init */
2159 0, /* tp_alloc */
2160 0, /* tp_new */
2161 0, /* tp_free */
2162 0, /* tp_is_gc */
2163 0, /* tp_bases */
2164 0, /* tp_mro */
2165 0, /* tp_cache */
2166 0, /* tp_subclasses */
2167 0, /* tp_weaklist */
2168 #endif
2169 #if PY_VERSION_HEX >= 0x02030000
2170 0, /* tp_del */
2171 #endif
2172 #if PY_VERSION_HEX >= 0x02060000
2173 0, /* tp_version_tag */
2174 #endif
2175 #if PY_VERSION_HEX >= 0x03040000
2176 0, /* tp_finalize */
2177 #endif
2178 #ifdef COUNT_ALLOCS
2179 0, /* tp_allocs */
2180 0, /* tp_frees */
2181 0, /* tp_maxalloc */
2182 #if PY_VERSION_HEX >= 0x02050000
2183 0, /* tp_prev */
2184 #endif
2185 0 /* tp_next */
2186 #endif
2187 };
2188 swigpypacked_type = tmp;
2189 type_init = 1;
2190 #if PY_VERSION_HEX < 0x02020000
2191 swigpypacked_type.ob_type = &PyType_Type;
2192 #else
2193 if (PyType_Ready(&swigpypacked_type) < 0)
2194 return NULL;
2195 #endif
2196 }
2197 return &swigpypacked_type;
2198 }
2199
2200 SWIGRUNTIME PyObject *
2201 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2202 {
2203 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2204 if (sobj) {
2205 void *pack = malloc(size);
2206 if (pack) {
2207 memcpy(pack, ptr, size);
2208 sobj->pack = pack;
2209 sobj->ty = ty;
2210 sobj->size = size;
2211 } else {
2212 PyObject_DEL((PyObject *) sobj);
2213 sobj = 0;
2214 }
2215 }
2216 return (PyObject *) sobj;
2217 }
2218
2219 SWIGRUNTIME swig_type_info *
2220 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2221 {
2222 if (SwigPyPacked_Check(obj)) {
2223 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2224 if (sobj->size != size) return 0;
2225 memcpy(ptr, sobj->pack, size);
2226 return sobj->ty;
2227 } else {
2228 return 0;
2229 }
2230 }
2231
2232 /* -----------------------------------------------------------------------------
2233 * pointers/data manipulation
2234 * ----------------------------------------------------------------------------- */
2235
2236 SWIGRUNTIMEINLINE PyObject *
2237 _SWIG_This(void)
2238 {
2239 return SWIG_Python_str_FromChar("this");
2240 }
2241
2242 static PyObject *swig_this = NULL;
2243
2244 SWIGRUNTIME PyObject *
2245 SWIG_This(void)
2246 {
2247 if (swig_this == NULL)
2248 swig_this = _SWIG_This();
2249 return swig_this;
2250 }
2251
2252 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2253
2254 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2255 #if PY_VERSION_HEX>=0x03000000
2256 #define SWIG_PYTHON_SLOW_GETSET_THIS
2257 #endif
2258
2259 SWIGRUNTIME SwigPyObject *
2260 SWIG_Python_GetSwigThis(PyObject *pyobj)
2261 {
2262 PyObject *obj;
2263
2264 if (SwigPyObject_Check(pyobj))
2265 return (SwigPyObject *) pyobj;
2266
2267 #ifdef SWIGPYTHON_BUILTIN
2268 (void)obj;
2269 # ifdef PyWeakref_CheckProxy
2270 if (PyWeakref_CheckProxy(pyobj)) {
2271 pyobj = PyWeakref_GET_OBJECT(pyobj);
2272 if (pyobj && SwigPyObject_Check(pyobj))
2273 return (SwigPyObject*) pyobj;
2274 }
2275 # endif
2276 return NULL;
2277 #else
2278
2279 obj = 0;
2280
2281 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2282 if (PyInstance_Check(pyobj)) {
2283 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2284 } else {
2285 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2286 if (dictptr != NULL) {
2287 PyObject *dict = *dictptr;
2288 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2289 } else {
2290 #ifdef PyWeakref_CheckProxy
2291 if (PyWeakref_CheckProxy(pyobj)) {
2292 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2293 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2294 }
2295 #endif
2296 obj = PyObject_GetAttr(pyobj,SWIG_This());
2297 if (obj) {
2298 Py_DECREF(obj);
2299 } else {
2300 if (PyErr_Occurred()) PyErr_Clear();
2301 return 0;
2302 }
2303 }
2304 }
2305 #else
2306 obj = PyObject_GetAttr(pyobj,SWIG_This());
2307 if (obj) {
2308 Py_DECREF(obj);
2309 } else {
2310 if (PyErr_Occurred()) PyErr_Clear();
2311 return 0;
2312 }
2313 #endif
2314 if (obj && !SwigPyObject_Check(obj)) {
2315 /* a PyObject is called 'this', try to get the 'real this'
2316 SwigPyObject from it */
2317 return SWIG_Python_GetSwigThis(obj);
2318 }
2319 return (SwigPyObject *)obj;
2320 #endif
2321 }
2322
2323 /* Acquire a pointer value */
2324
2325 SWIGRUNTIME int
2326 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2327 if (own == SWIG_POINTER_OWN) {
2328 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2329 if (sobj) {
2330 int oldown = sobj->own;
2331 sobj->own = own;
2332 return oldown;
2333 }
2334 }
2335 return 0;
2336 }
2337
2338 /* Convert a pointer value */
2339
2340 SWIGRUNTIME int
2341 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2342 int res;
2343 SwigPyObject *sobj;
2344 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2345
2346 if (!obj)
2347 return SWIG_ERROR;
2348 if (obj == Py_None && !implicit_conv) {
2349 if (ptr)
2350 *ptr = 0;
2351 return SWIG_OK;
2352 }
2353
2354 res = SWIG_ERROR;
2355
2356 sobj = SWIG_Python_GetSwigThis(obj);
2357 if (own)
2358 *own = 0;
2359 while (sobj) {
2360 void *vptr = sobj->ptr;
2361 if (ty) {
2362 swig_type_info *to = sobj->ty;
2363 if (to == ty) {
2364 /* no type cast needed */
2365 if (ptr) *ptr = vptr;
2366 break;
2367 } else {
2368 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2369 if (!tc) {
2370 sobj = (SwigPyObject *)sobj->next;
2371 } else {
2372 if (ptr) {
2373 int newmemory = 0;
2374 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2375 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2376 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2377 if (own)
2378 *own = *own | SWIG_CAST_NEW_MEMORY;
2379 }
2380 }
2381 break;
2382 }
2383 }
2384 } else {
2385 if (ptr) *ptr = vptr;
2386 break;
2387 }
2388 }
2389 if (sobj) {
2390 if (own)
2391 *own = *own | sobj->own;
2392 if (flags & SWIG_POINTER_DISOWN) {
2393 sobj->own = 0;
2394 }
2395 res = SWIG_OK;
2396 } else {
2397 if (implicit_conv) {
2398 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2399 if (data && !data->implicitconv) {
2400 PyObject *klass = data->klass;
2401 if (klass) {
2402 PyObject *impconv;
2403 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2404 impconv = SWIG_Python_CallFunctor(klass, obj);
2405 data->implicitconv = 0;
2406 if (PyErr_Occurred()) {
2407 PyErr_Clear();
2408 impconv = 0;
2409 }
2410 if (impconv) {
2411 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2412 if (iobj) {
2413 void *vptr;
2414 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2415 if (SWIG_IsOK(res)) {
2416 if (ptr) {
2417 *ptr = vptr;
2418 /* transfer the ownership to 'ptr' */
2419 iobj->own = 0;
2420 res = SWIG_AddCast(res);
2421 res = SWIG_AddNewMask(res);
2422 } else {
2423 res = SWIG_AddCast(res);
2424 }
2425 }
2426 }
2427 Py_DECREF(impconv);
2428 }
2429 }
2430 }
2431 }
2432 if (!SWIG_IsOK(res) && obj == Py_None) {
2433 if (ptr)
2434 *ptr = 0;
2435 if (PyErr_Occurred())
2436 PyErr_Clear();
2437 res = SWIG_OK;
2438 }
2439 }
2440 return res;
2441 }
2442
2443 /* Convert a function ptr value */
2444
2445 SWIGRUNTIME int
2446 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2447 if (!PyCFunction_Check(obj)) {
2448 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2449 } else {
2450 void *vptr = 0;
2451
2452 /* here we get the method pointer for callbacks */
2453 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2454 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2455 if (desc)
2456 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2457 if (!desc)
2458 return SWIG_ERROR;
2459 if (ty) {
2460 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2461 if (tc) {
2462 int newmemory = 0;
2463 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2464 assert(!newmemory); /* newmemory handling not yet implemented */
2465 } else {
2466 return SWIG_ERROR;
2467 }
2468 } else {
2469 *ptr = vptr;
2470 }
2471 return SWIG_OK;
2472 }
2473 }
2474
2475 /* Convert a packed value value */
2476
2477 SWIGRUNTIME int
2478 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2479 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2480 if (!to) return SWIG_ERROR;
2481 if (ty) {
2482 if (to != ty) {
2483 /* check type cast? */
2484 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2485 if (!tc) return SWIG_ERROR;
2486 }
2487 }
2488 return SWIG_OK;
2489 }
2490
2491 /* -----------------------------------------------------------------------------
2492 * Create a new pointer object
2493 * ----------------------------------------------------------------------------- */
2494
2495 /*
2496 Create a new instance object, without calling __init__, and set the
2497 'this' attribute.
2498 */
2499
2500 SWIGRUNTIME PyObject*
2501 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2502 {
2503 #if (PY_VERSION_HEX >= 0x02020000)
2504 PyObject *inst = 0;
2505 PyObject *newraw = data->newraw;
2506 if (newraw) {
2507 inst = PyObject_Call(newraw, data->newargs, NULL);
2508 if (inst) {
2509 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2510 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2511 if (dictptr != NULL) {
2512 PyObject *dict = *dictptr;
2513 if (dict == NULL) {
2514 dict = PyDict_New();
2515 *dictptr = dict;
2516 PyDict_SetItem(dict, SWIG_This(), swig_this);
2517 }
2518 }
2519 #else
2520 PyObject *key = SWIG_This();
2521 PyObject_SetAttr(inst, key, swig_this);
2522 #endif
2523 }
2524 } else {
2525 #if PY_VERSION_HEX >= 0x03000000
2526 inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2527 if (inst) {
2528 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2529 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2530 }
2531 #else
2532 PyObject *dict = PyDict_New();
2533 if (dict) {
2534 PyDict_SetItem(dict, SWIG_This(), swig_this);
2535 inst = PyInstance_NewRaw(data->newargs, dict);
2536 Py_DECREF(dict);
2537 }
2538 #endif
2539 }
2540 return inst;
2541 #else
2542 #if (PY_VERSION_HEX >= 0x02010000)
2543 PyObject *inst = 0;
2544 PyObject *dict = PyDict_New();
2545 if (dict) {
2546 PyDict_SetItem(dict, SWIG_This(), swig_this);
2547 inst = PyInstance_NewRaw(data->newargs, dict);
2548 Py_DECREF(dict);
2549 }
2550 return (PyObject *) inst;
2551 #else
2552 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2553 if (inst == NULL) {
2554 return NULL;
2555 }
2556 inst->in_class = (PyClassObject *)data->newargs;
2557 Py_INCREF(inst->in_class);
2558 inst->in_dict = PyDict_New();
2559 if (inst->in_dict == NULL) {
2560 Py_DECREF(inst);
2561 return NULL;
2562 }
2563 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2564 inst->in_weakreflist = NULL;
2565 #endif
2566 #ifdef Py_TPFLAGS_GC
2567 PyObject_GC_Init(inst);
2568 #endif
2569 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2570 return (PyObject *) inst;
2571 #endif
2572 #endif
2573 }
2574
2575 SWIGRUNTIME void
2576 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2577 {
2578 PyObject *dict;
2579 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2580 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2581 if (dictptr != NULL) {
2582 dict = *dictptr;
2583 if (dict == NULL) {
2584 dict = PyDict_New();
2585 *dictptr = dict;
2586 }
2587 PyDict_SetItem(dict, SWIG_This(), swig_this);
2588 return;
2589 }
2590 #endif
2591 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2592 PyDict_SetItem(dict, SWIG_This(), swig_this);
2593 Py_DECREF(dict);
2594 }
2595
2596
2597 SWIGINTERN PyObject *
2598 SWIG_Python_InitShadowInstance(PyObject *args) {
2599 PyObject *obj[2];
2600 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2601 return NULL;
2602 } else {
2603 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2604 if (sthis) {
2605 SwigPyObject_append((PyObject*) sthis, obj[1]);
2606 } else {
2607 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2608 }
2609 return SWIG_Py_Void();
2610 }
2611 }
2612
2613 /* Create a new pointer object */
2614
2615 SWIGRUNTIME PyObject *
2616 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2617 SwigPyClientData *clientdata;
2618 PyObject * robj;
2619 int own;
2620
2621 if (!ptr)
2622 return SWIG_Py_Void();
2623
2624 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2625 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2626 if (clientdata && clientdata->pytype) {
2627 SwigPyObject *newobj;
2628 if (flags & SWIG_BUILTIN_TP_INIT) {
2629 newobj = (SwigPyObject*) self;
2630 if (newobj->ptr) {
2631 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2632 while (newobj->next)
2633 newobj = (SwigPyObject *) newobj->next;
2634 newobj->next = next_self;
2635 newobj = (SwigPyObject *)next_self;
2636 #ifdef SWIGPYTHON_BUILTIN
2637 newobj->dict = 0;
2638 #endif
2639 }
2640 } else {
2641 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2642 #ifdef SWIGPYTHON_BUILTIN
2643 newobj->dict = 0;
2644 #endif
2645 }
2646 if (newobj) {
2647 newobj->ptr = ptr;
2648 newobj->ty = type;
2649 newobj->own = own;
2650 newobj->next = 0;
2651 return (PyObject*) newobj;
2652 }
2653 return SWIG_Py_Void();
2654 }
2655
2656 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2657
2658 robj = SwigPyObject_New(ptr, type, own);
2659 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2660 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2661 Py_DECREF(robj);
2662 robj = inst;
2663 }
2664 return robj;
2665 }
2666
2667 /* Create a new packed object */
2668
2669 SWIGRUNTIMEINLINE PyObject *
2670 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2671 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2672 }
2673
2674 /* -----------------------------------------------------------------------------*
2675 * Get type list
2676 * -----------------------------------------------------------------------------*/
2677
2678 #ifdef SWIG_LINK_RUNTIME
2679 void *SWIG_ReturnGlobalTypeList(void *);
2680 #endif
2681
2682 SWIGRUNTIME swig_module_info *
2683 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2684 static void *type_pointer = (void *)0;
2685 /* first check if module already created */
2686 if (!type_pointer) {
2687 #ifdef SWIG_LINK_RUNTIME
2688 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2689 #else
2690 # ifdef SWIGPY_USE_CAPSULE
2691 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2692 # else
2693 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2694 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2695 # endif
2696 if (PyErr_Occurred()) {
2697 PyErr_Clear();
2698 type_pointer = (void *)0;
2699 }
2700 #endif
2701 }
2702 return (swig_module_info *) type_pointer;
2703 }
2704
2705 #if PY_MAJOR_VERSION < 2
2706 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2707 is copied out of Python/modsupport.c in python version 2.3.4 */
2708 SWIGINTERN int
2709 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2710 {
2711 PyObject *dict;
2712 if (!PyModule_Check(m)) {
2713 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2714 return SWIG_ERROR;
2715 }
2716 if (!o) {
2717 PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2718 return SWIG_ERROR;
2719 }
2720
2721 dict = PyModule_GetDict(m);
2722 if (dict == NULL) {
2723 /* Internal error -- modules must have a dict! */
2724 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2725 PyModule_GetName(m));
2726 return SWIG_ERROR;
2727 }
2728 if (PyDict_SetItemString(dict, name, o))
2729 return SWIG_ERROR;
2730 Py_DECREF(o);
2731 return SWIG_OK;
2732 }
2733 #endif
2734
2735 SWIGRUNTIME void
2736 #ifdef SWIGPY_USE_CAPSULE
2737 SWIG_Python_DestroyModule(PyObject *obj)
2738 #else
2739 SWIG_Python_DestroyModule(void *vptr)
2740 #endif
2741 {
2742 #ifdef SWIGPY_USE_CAPSULE
2743 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2744 #else
2745 swig_module_info *swig_module = (swig_module_info *) vptr;
2746 #endif
2747 swig_type_info **types = swig_module->types;
2748 size_t i;
2749 for (i =0; i < swig_module->size; ++i) {
2750 swig_type_info *ty = types[i];
2751 if (ty->owndata) {
2752 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2753 if (data) SwigPyClientData_Del(data);
2754 }
2755 }
2756 Py_DECREF(SWIG_This());
2757 swig_this = NULL;
2758 }
2759
2760 SWIGRUNTIME void
2761 SWIG_Python_SetModule(swig_module_info *swig_module) {
2762 #if PY_VERSION_HEX >= 0x03000000
2763 /* Add a dummy module object into sys.modules */
2764 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2765 #else
2766 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2767 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2768 #endif
2769 #ifdef SWIGPY_USE_CAPSULE
2770 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2771 if (pointer && module) {
2772 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2773 } else {
2774 Py_XDECREF(pointer);
2775 }
2776 #else
2777 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2778 if (pointer && module) {
2779 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2780 } else {
2781 Py_XDECREF(pointer);
2782 }
2783 #endif
2784 }
2785
2786 /* The python cached type query */
2787 SWIGRUNTIME PyObject *
2788 SWIG_Python_TypeCache(void) {
2789 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2790 return cache;
2791 }
2792
2793 SWIGRUNTIME swig_type_info *
2794 SWIG_Python_TypeQuery(const char *type)
2795 {
2796 PyObject *cache = SWIG_Python_TypeCache();
2797 PyObject *key = SWIG_Python_str_FromChar(type);
2798 PyObject *obj = PyDict_GetItem(cache, key);
2799 swig_type_info *descriptor;
2800 if (obj) {
2801 #ifdef SWIGPY_USE_CAPSULE
2802 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2803 #else
2804 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2805 #endif
2806 } else {
2807 swig_module_info *swig_module = SWIG_GetModule(0);
2808 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2809 if (descriptor) {
2810 #ifdef SWIGPY_USE_CAPSULE
2811 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2812 #else
2813 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2814 #endif
2815 PyDict_SetItem(cache, key, obj);
2816 Py_DECREF(obj);
2817 }
2818 }
2819 Py_DECREF(key);
2820 return descriptor;
2821 }
2822
2823 /*
2824 For backward compatibility only
2825 */
2826 #define SWIG_POINTER_EXCEPTION 0
2827 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2828 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2829
2830 SWIGRUNTIME int
2831 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2832 {
2833 if (PyErr_Occurred()) {
2834 PyObject *type = 0;
2835 PyObject *value = 0;
2836 PyObject *traceback = 0;
2837 PyErr_Fetch(&type, &value, &traceback);
2838 if (value) {
2839 char *tmp;
2840 PyObject *old_str = PyObject_Str(value);
2841 Py_XINCREF(type);
2842 PyErr_Clear();
2843 if (infront) {
2844 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2845 } else {
2846 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2847 }
2848 SWIG_Python_str_DelForPy3(tmp);
2849 Py_DECREF(old_str);
2850 }
2851 return 1;
2852 } else {
2853 return 0;
2854 }
2855 }
2856
2857 SWIGRUNTIME int
2858 SWIG_Python_ArgFail(int argnum)
2859 {
2860 if (PyErr_Occurred()) {
2861 /* add information about failing argument */
2862 char mesg[256];
2863 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2864 return SWIG_Python_AddErrMesg(mesg, 1);
2865 } else {
2866 return 0;
2867 }
2868 }
2869
2870 SWIGRUNTIMEINLINE const char *
2871 SwigPyObject_GetDesc(PyObject *self)
2872 {
2873 SwigPyObject *v = (SwigPyObject *)self;
2874 swig_type_info *ty = v ? v->ty : 0;
2875 return ty ? ty->str : "";
2876 }
2877
2878 SWIGRUNTIME void
2879 SWIG_Python_TypeError(const char *type, PyObject *obj)
2880 {
2881 if (type) {
2882 #if defined(SWIG_COBJECT_TYPES)
2883 if (obj && SwigPyObject_Check(obj)) {
2884 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2885 if (otype) {
2886 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2887 type, otype);
2888 return;
2889 }
2890 } else
2891 #endif
2892 {
2893 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2894 if (otype) {
2895 PyObject *str = PyObject_Str(obj);
2896 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2897 if (cstr) {
2898 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2899 type, otype, cstr);
2900 SWIG_Python_str_DelForPy3(cstr);
2901 } else {
2902 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2903 type, otype);
2904 }
2905 Py_XDECREF(str);
2906 return;
2907 }
2908 }
2909 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2910 } else {
2911 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2912 }
2913 }
2914
2915
2916 /* Convert a pointer value, signal an exception on a type mismatch */
2917 SWIGRUNTIME void *
2918 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2919 void *result;
2920 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2921 PyErr_Clear();
2922 #if SWIG_POINTER_EXCEPTION
2923 if (flags) {
2924 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2925 SWIG_Python_ArgFail(argnum);
2926 }
2927 #endif
2928 }
2929 return result;
2930 }
2931
2932 #ifdef SWIGPYTHON_BUILTIN
2933 SWIGRUNTIME int
2934 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2935 PyTypeObject *tp = obj->ob_type;
2936 PyObject *descr;
2937 PyObject *encoded_name;
2938 descrsetfunc f;
2939 int res = -1;
2940
2941 # ifdef Py_USING_UNICODE
2942 if (PyString_Check(name)) {
2943 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2944 if (!name)
2945 return -1;
2946 } else if (!PyUnicode_Check(name))
2947 # else
2948 if (!PyString_Check(name))
2949 # endif
2950 {
2951 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2952 return -1;
2953 } else {
2954 Py_INCREF(name);
2955 }
2956
2957 if (!tp->tp_dict) {
2958 if (PyType_Ready(tp) < 0)
2959 goto done;
2960 }
2961
2962 descr = _PyType_Lookup(tp, name);
2963 f = NULL;
2964 if (descr != NULL)
2965 f = descr->ob_type->tp_descr_set;
2966 if (!f) {
2967 if (PyString_Check(name)) {
2968 encoded_name = name;
2969 Py_INCREF(name);
2970 } else {
2971 encoded_name = PyUnicode_AsUTF8String(name);
2972 }
2973 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2974 Py_DECREF(encoded_name);
2975 } else {
2976 res = f(descr, obj, value);
2977 }
2978
2979 done:
2980 Py_DECREF(name);
2981 return res;
2982 }
2983 #endif
2984
2985
2986 #ifdef __cplusplus
2987 }
2988 #endif
2989
2990
2991
2992 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2993
2994 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2995
2996
2997
2998 /* -------- TYPES TABLE (BEGIN) -------- */
2999
3000 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3001 #define SWIGTYPE_p_PLcGrid swig_types[1]
3002 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
3003 #define SWIGTYPE_p_char swig_types[3]
3004 #define SWIGTYPE_p_double swig_types[4]
3005 #define SWIGTYPE_p_f_double_double__int swig_types[5]
3006 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3007 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3008 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3009 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3010 #define SWIGTYPE_p_int swig_types[10]
3011 #define SWIGTYPE_p_p_char swig_types[11]
3012 #define SWIGTYPE_p_p_double swig_types[12]
3013 #define SWIGTYPE_p_unsigned_int swig_types[13]
3014 static swig_type_info *swig_types[15];
3015 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3016 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3017 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3018
3019 /* -------- TYPES TABLE (END) -------- */
3020
3021 #if (PY_VERSION_HEX <= 0x02000000)
3022 # if !defined(SWIG_PYTHON_CLASSIC)
3023 # error "This python version requires swig to be run with the '-classic' option"
3024 # endif
3025 #endif
3026
3027 /*-----------------------------------------------
3028 @(target):= _plplotc.so
3029 ------------------------------------------------*/
3030 #if PY_VERSION_HEX >= 0x03000000
3031 # define SWIG_init PyInit__plplotc
3032
3033 #else
3034 # define SWIG_init init_plplotc
3035
3036 #endif
3037 #define SWIG_name "_plplotc"
3038
3039 #define SWIGVERSION 0x030012
3040 #define SWIG_VERSION SWIGVERSION
3041
3042
3043 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3044 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3045
3046
3047 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3048 #include <arrayobject.h>
3049 #include "plplot.h"
3050 #include "plplotP.h"
3051
3052 #define NPY_PLINT NPY_INT32
3053
3054 #ifdef PL_DOUBLE
3055 #define NPY_PLFLT NPY_FLOAT64
3056 #else
3057 #define NPY_PLFLT NPY_FLOAT32
3058 #endif
3059
3060 // python-1.5 compatibility mode?
3061 #if !defined ( PySequence_Fast_GET_ITEM )
3062 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3063 #endif
3064 #define PySequence_Size PySequence_Length
3065
3066
3067 static PLINT Alen = 0;
3068 static PLINT Xlen = 0, Ylen = 0;
3069
3070
3071 SWIGINTERN int
3072 SWIG_AsVal_double (PyObject *obj, double *val)
3073 {
3074 int res = SWIG_TypeError;
3075 if (PyFloat_Check(obj)) {
3076 if (val) *val = PyFloat_AsDouble(obj);
3077 return SWIG_OK;
3078 #if PY_VERSION_HEX < 0x03000000
3079 } else if (PyInt_Check(obj)) {
3080 if (val) *val = (double) PyInt_AsLong(obj);
3081 return SWIG_OK;
3082 #endif
3083 } else if (PyLong_Check(obj)) {
3084 double v = PyLong_AsDouble(obj);
3085 if (!PyErr_Occurred()) {
3086 if (val) *val = v;
3087 return SWIG_OK;
3088 } else {
3089 PyErr_Clear();
3090 }
3091 }
3092 #ifdef SWIG_PYTHON_CAST_MODE
3093 {
3094 int dispatch = 0;
3095 double d = PyFloat_AsDouble(obj);
3096 if (!PyErr_Occurred()) {
3097 if (val) *val = d;
3098 return SWIG_AddCast(SWIG_OK);
3099 } else {
3100 PyErr_Clear();
3101 }
3102 if (!dispatch) {
3103 long v = PyLong_AsLong(obj);
3104 if (!PyErr_Occurred()) {
3105 if (val) *val = v;
3106 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3107 } else {
3108 PyErr_Clear();
3109 }
3110 }
3111 }
3112 #endif
3113 return res;
3114 }
3115
3116
3117 #define SWIG_From_double PyFloat_FromDouble
3118
3119
3120 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3121 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3122 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3123 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3124 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3125 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
3126 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3127
3128
3129 SWIGINTERNINLINE PyObject*
3130 SWIG_From_int (int value)
3131 {
3132 return PyInt_FromLong((long) value);
3133 }
3134
3135
3136 #include <limits.h>
3137 #if !defined(SWIG_NO_LLONG_MAX)
3138 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3139 # define LLONG_MAX __LONG_LONG_MAX__
3140 # define LLONG_MIN (-LLONG_MAX - 1LL)
3141 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3142 # endif
3143 #endif
3144
3145
3146 #include <float.h>
3147
3148
3149 #include <math.h>
3150
3151
3152 SWIGINTERNINLINE int
3153 SWIG_CanCastAsInteger(double *d, double min, double max) {
3154 double x = *d;
3155 if ((min <= x && x <= max)) {
3156 double fx = floor(x);
3157 double cx = ceil(x);
3158 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3159 if ((errno == EDOM) || (errno == ERANGE)) {
3160 errno = 0;
3161 } else {
3162 double summ, reps, diff;
3163 if (rd < x) {
3164 diff = x - rd;
3165 } else if (rd > x) {
3166 diff = rd - x;
3167 } else {
3168 return 1;
3169 }
3170 summ = rd + x;
3171 reps = diff/summ;
3172 if (reps < 8*DBL_EPSILON) {
3173 *d = rd;
3174 return 1;
3175 }
3176 }
3177 }
3178 return 0;
3179 }
3180
3181
3182 SWIGINTERN int
3183 SWIG_AsVal_long (PyObject *obj, long* val)
3184 {
3185 #if PY_VERSION_HEX < 0x03000000
3186 if (PyInt_Check(obj)) {
3187 if (val) *val = PyInt_AsLong(obj);
3188 return SWIG_OK;
3189 } else
3190 #endif
3191 if (PyLong_Check(obj)) {
3192 long v = PyLong_AsLong(obj);
3193 if (!PyErr_Occurred()) {
3194 if (val) *val = v;
3195 return SWIG_OK;
3196 } else {
3197 PyErr_Clear();
3198 return SWIG_OverflowError;
3199 }
3200 }
3201 #ifdef SWIG_PYTHON_CAST_MODE
3202 {
3203 int dispatch = 0;
3204 long v = PyInt_AsLong(obj);
3205 if (!PyErr_Occurred()) {
3206 if (val) *val = v;
3207 return SWIG_AddCast(SWIG_OK);
3208 } else {
3209 PyErr_Clear();
3210 }
3211 if (!dispatch) {
3212 double d;
3213 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3214 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3215 if (val) *val = (long)(d);
3216 return res;
3217 }
3218 }
3219 }
3220 #endif
3221 return SWIG_TypeError;
3222 }
3223
3224
3225 SWIGINTERN int
3226 SWIG_AsVal_int (PyObject * obj, int *val)
3227 {
3228 long v;
3229 int res = SWIG_AsVal_long (obj, &v);
3230 if (SWIG_IsOK(res)) {
3231 if ((v < INT_MIN || v > INT_MAX)) {
3232 return SWIG_OverflowError;
3233 } else {
3234 if (val) *val = (int)(v);
3235 }
3236 }
3237 return res;
3238 }
3239
3240
3241 SWIGINTERN int
3242 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3243 {
3244 #if PY_VERSION_HEX < 0x03000000
3245 if (PyInt_Check(obj)) {
3246 long v = PyInt_AsLong(obj);
3247 if (v >= 0) {
3248 if (val) *val = v;
3249 return SWIG_OK;
3250 } else {
3251 return SWIG_OverflowError;
3252 }
3253 } else
3254 #endif
3255 if (PyLong_Check(obj)) {
3256 unsigned long v = PyLong_AsUnsignedLong(obj);
3257 if (!PyErr_Occurred()) {
3258 if (val) *val = v;
3259 return SWIG_OK;
3260 } else {
3261 PyErr_Clear();
3262 return SWIG_OverflowError;
3263 }
3264 }
3265 #ifdef SWIG_PYTHON_CAST_MODE
3266 {
3267 int dispatch = 0;
3268 unsigned long v = PyLong_AsUnsignedLong(obj);
3269 if (!PyErr_Occurred()) {
3270 if (val) *val = v;
3271 return SWIG_AddCast(SWIG_OK);
3272 } else {
3273 PyErr_Clear();
3274 }
3275 if (!dispatch) {
3276 double d;
3277 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3278 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3279 if (val) *val = (unsigned long)(d);
3280 return res;
3281 }
3282 }
3283 }
3284 #endif
3285 return SWIG_TypeError;
3286 }
3287
3288
3289 SWIGINTERN int
3290 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3291 {
3292 unsigned long v;
3293 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3294 if (SWIG_IsOK(res)) {
3295 if ((v > UINT_MAX)) {
3296 return SWIG_OverflowError;
3297 } else {
3298 if (val) *val = (unsigned int)(v);
3299 }
3300 }
3301 return res;
3302 }
3303
3304
3305 SWIGINTERNINLINE PyObject*
3306 SWIG_From_unsigned_SS_int (unsigned int value)
3307 {
3308 return PyInt_FromSize_t((size_t) value);
3309 }
3310
3311
3312 SWIGINTERN swig_type_info*
3313 SWIG_pchar_descriptor(void)
3314 {
3315 static int init = 0;
3316 static swig_type_info* info = 0;
3317 if (!init) {
3318 info = SWIG_TypeQuery("_p_char");
3319 init = 1;
3320 }
3321 return info;
3322 }
3323
3324
3325 SWIGINTERN int
3326 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3327 {
3328 #if PY_VERSION_HEX>=0x03000000
3329 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3330 if (PyBytes_Check(obj))
3331 #else
3332 if (PyUnicode_Check(obj))
3333 #endif
3334 #else
3335 if (PyString_Check(obj))
3336 #endif
3337 {
3338 char *cstr; Py_ssize_t len;
3339 #if PY_VERSION_HEX>=0x03000000
3340 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3341 if (!alloc && cptr) {
3342 /* We can't allow converting without allocation, since the internal
3343 representation of string in Python 3 is UCS-2/UCS-4 but we require
3344 a UTF-8 representation.
3345 TODO(bhy) More detailed explanation */
3346 return SWIG_RuntimeError;
3347 }
3348 obj = PyUnicode_AsUTF8String(obj);
3349 if(alloc) *alloc = SWIG_NEWOBJ;
3350 #endif
3351 PyBytes_AsStringAndSize(obj, &cstr, &len);
3352 #else
3353 PyString_AsStringAndSize(obj, &cstr, &len);
3354 #endif
3355 if (cptr) {
3356 if (alloc) {
3357 /*
3358 In python the user should not be able to modify the inner
3359 string representation. To warranty that, if you define
3360 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3361 buffer is always returned.
3362
3363 The default behavior is just to return the pointer value,
3364 so, be careful.
3365 */
3366 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3367 if (*alloc != SWIG_OLDOBJ)
3368 #else
3369 if (*alloc == SWIG_NEWOBJ)
3370 #endif
3371 {
3372 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3373 *alloc = SWIG_NEWOBJ;
3374 } else {
3375 *cptr = cstr;
3376 *alloc = SWIG_OLDOBJ;
3377 }
3378 } else {
3379 #if PY_VERSION_HEX>=0x03000000
3380 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3381 *cptr = PyBytes_AsString(obj);
3382 #else
3383 assert(0); /* Should never reach here with Unicode strings in Python 3 */
3384 #endif
3385 #else
3386 *cptr = SWIG_Python_str_AsChar(obj);
3387 #endif
3388 }
3389 }
3390 if (psize) *psize = len + 1;
3391 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3392 Py_XDECREF(obj);
3393 #endif
3394 return SWIG_OK;
3395 } else {
3396 #if defined(SWIG_PYTHON_2_UNICODE)
3397 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3398 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3399 #endif
3400 #if PY_VERSION_HEX<0x03000000
3401 if (PyUnicode_Check(obj)) {
3402 char *cstr; Py_ssize_t len;
3403 if (!alloc && cptr) {
3404 return SWIG_RuntimeError;
3405 }
3406 obj = PyUnicode_AsUTF8String(obj);
3407 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3408 if (cptr) {
3409 if (alloc) *alloc = SWIG_NEWOBJ;
3410 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3411 }
3412 if (psize) *psize = len + 1;
3413
3414 Py_XDECREF(obj);
3415 return SWIG_OK;
3416 } else {
3417 Py_XDECREF(obj);
3418 }
3419 }
3420 #endif
3421 #endif
3422
3423 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3424 if (pchar_descriptor) {
3425 void* vptr = 0;
3426 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3427 if (cptr) *cptr = (char *) vptr;
3428 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3429 if (alloc) *alloc = SWIG_OLDOBJ;
3430 return SWIG_OK;
3431 }
3432 }
3433 }
3434 return SWIG_TypeError;
3435 }
3436
3437
3438 SWIGINTERN int
3439 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3440 {
3441 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3442 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3443 if (SWIG_IsOK(res)) {
3444 /* special case of single char conversion when we don't need space for NUL */
3445 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3446 if (csize <= size) {
3447 if (val) {
3448 if (csize) memcpy(val, cptr, csize*sizeof(char));
3449 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3450 }
3451 if (alloc == SWIG_NEWOBJ) {
3452 free((char*)cptr);
3453 res = SWIG_DelNewMask(res);
3454 }
3455 return res;
3456 }
3457 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3458 }
3459 return SWIG_TypeError;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3465 {
3466 if (carray) {
3467 if (size > INT_MAX) {
3468 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3469 return pchar_descriptor ?
3470 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3471 } else {
3472 #if PY_VERSION_HEX >= 0x03000000
3473 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3474 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3475 #else
3476 #if PY_VERSION_HEX >= 0x03010000
3477 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3478 #else
3479 return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3480 #endif
3481 #endif
3482 #else
3483 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3484 #endif
3485 }
3486 } else {
3487 return SWIG_Py_Void();
3488 }
3489 }
3490
3491
3492 SWIGINTERN size_t
3493 SWIG_strnlen(const char* s, size_t maxlen)
3494 {
3495 const char *p;
3496 for (p = s; maxlen-- && *p; p++)
3497 ;
3498 return p - s;
3499 }
3500
3501
3502
3503
3504
3505 #define t_output_helper SWIG_Python_AppendOutput
3506
3507
3508 SWIGINTERN int
3509 SWIG_AsVal_char (PyObject * obj, char *val)
3510 {
3511 int res = SWIG_AsCharArray(obj, val, 1);
3512 if (!SWIG_IsOK(res)) {
3513 long v;
3514 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3515 if (SWIG_IsOK(res)) {
3516 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3517 if (val) *val = (char)(v);
3518 } else {
3519 res = SWIG_OverflowError;
3520 }
3521 }
3522 }
3523 return res;
3524 }
3525
3526 #ifdef __cplusplus
3527 extern "C" {
3528 #endif
3529
3530 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3531
3532 // some really twisted stuff to allow calling a single precision library from python
3533 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3534 {
3535 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3536 mindims, maxdims );
3537 if ( !tmp )
3538 {
3539 // could be an incoming long array which can't be "safely" converted, do it anyway
3540 if ( PyArray_Check( in ) )
3541 {
3542 PyErr_Clear();
3543 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3544 }
3545 }
3546 return tmp;
3547 }
3548
3549
3550 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3551
3552 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3553 PyObject *resultobj = 0;
3554 PLFLT arg1 ;
3555 PLFLT arg2 ;
3556 PLFLT *arg3 = (PLFLT *) 0 ;
3557 PLFLT *arg4 = (PLFLT *) 0 ;
3558 PLPointer arg5 = (PLPointer) 0 ;
3559 double val1 ;
3560 int ecode1 = 0 ;
3561 double val2 ;
3562 int ecode2 = 0 ;
3563 PLFLT temp3 ;
3564 int res3 = SWIG_TMPOBJ ;
3565 PLFLT temp4 ;
3566 int res4 = SWIG_TMPOBJ ;
3567 PyObject * obj0 = 0 ;
3568 PyObject * obj1 = 0 ;
3569
3570 arg3 = &temp3;
3571 arg4 = &temp4;
3572 {
3573 arg5 = NULL;
3574 }
3575 if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3576 ecode1 = SWIG_AsVal_double(obj0, &val1);
3577 if (!SWIG_IsOK(ecode1)) {
3578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3579 }
3580 arg1 = (PLFLT)(val1);
3581 ecode2 = SWIG_AsVal_double(obj1, &val2);
3582 if (!SWIG_IsOK(ecode2)) {
3583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3584 }
3585 arg2 = (PLFLT)(val2);
3586 pltr0(arg1,arg2,arg3,arg4,arg5);
3587 resultobj = SWIG_Py_Void();
3588 if (SWIG_IsTmpObj(res3)) {
3589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3590 } else {
3591 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3593 }
3594 if (SWIG_IsTmpObj(res4)) {
3595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3596 } else {
3597 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3599 }
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606
3607 PyArrayObject *pltr_xg, *pltr_yg;
3608 static PLcGrid tmpGrid1;
3609 static PLcGrid2 tmpGrid2;
3610
3611 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3612 void cleanup_PLcGrid1( void );
3613 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3614 void cleanup_PLcGrid2( void );
3615
3616 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3617 {
3618 // fprintf(stderr, "marshal PLcGrid1\n");
3619 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3620 {
3621 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3622 return NULL;
3623 }
3624 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3625 NPY_PLFLT, 1, 1 );
3626 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3627 NPY_PLFLT, 1, 1 );
3628 if ( pltr_xg == 0 || pltr_yg == 0 )
3629 {
3630 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3631 return NULL;
3632 }
3633 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3634 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3635 if ( isimg == 0 )
3636 {
3637 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3638 {
3639 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3640 return NULL;
3641 }
3642 }
3643 else
3644 {
3645 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3646 {
3647 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3648 return NULL;
3649 }
3650 }
3651 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3652 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3653 return &tmpGrid1;
3654 }
3655
3656 void cleanup_PLcGrid1( void )
3657 {
3658 // fprintf(stderr, "cleanup PLcGrid1\n");
3659 Py_CLEAR( pltr_xg );
3660 Py_CLEAR( pltr_yg );
3661 }
3662
3663 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3664 {
3665 int i, size;
3666 // fprintf(stderr, "marshal PLcGrid2\n");
3667 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3668 {
3669 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3670 return NULL;
3671 }
3672 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3673 NPY_PLFLT, 2, 2 );
3674 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3675 NPY_PLFLT, 2, 2 );
3676 if ( pltr_xg == 0 || pltr_yg == 0 )
3677 {
3678 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3679 return NULL;
3680 }
3681 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3682 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3683 {
3684 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3685 return NULL;
3686 }
3687 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3688 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3689 if ( isimg == 0 )
3690 {
3691 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3692 {
3693 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3694 return NULL;
3695 }
3696 }
3697 else
3698 {
3699 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3700 {
3701 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3702 return NULL;
3703 }
3704 }
3705 size = tmpGrid2.ny;
3706 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3707 for ( i = 0; i < tmpGrid2.nx; i++ )
3708 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3709 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3710 for ( i = 0; i < tmpGrid2.nx; i++ )
3711 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3712 return &tmpGrid2;
3713 }
3714
3715 void cleanup_PLcGrid2( void )
3716 {
3717 // fprintf(stderr, "cleanup PLcGrid2\n");
3718 free( tmpGrid2.xg );
3719 free( tmpGrid2.yg );
3720 Py_CLEAR( pltr_xg );
3721 Py_CLEAR( pltr_yg );
3722 }
3723
3724 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3725 PyObject *resultobj = 0;
3726 PLFLT arg1 ;
3727 PLFLT arg2 ;
3728 PLFLT *arg3 = (PLFLT *) 0 ;
3729 PLFLT *arg4 = (PLFLT *) 0 ;
3730 PLcGrid *arg5 = (PLcGrid *) 0 ;
3731 double val1 ;
3732 int ecode1 = 0 ;
3733 double val2 ;
3734 int ecode2 = 0 ;
3735 PLFLT temp3 ;
3736 int res3 = SWIG_TMPOBJ ;
3737 PLFLT temp4 ;
3738 int res4 = SWIG_TMPOBJ ;
3739 PyObject * obj0 = 0 ;
3740 PyObject * obj1 = 0 ;
3741 PyObject * obj2 = 0 ;
3742
3743 arg3 = &temp3;
3744 arg4 = &temp4;
3745 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3746 ecode1 = SWIG_AsVal_double(obj0, &val1);
3747 if (!SWIG_IsOK(ecode1)) {
3748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3749 }
3750 arg1 = (PLFLT)(val1);
3751 ecode2 = SWIG_AsVal_double(obj1, &val2);
3752 if (!SWIG_IsOK(ecode2)) {
3753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3754 }
3755 arg2 = (PLFLT)(val2);
3756 {
3757 arg5 = marshal_PLcGrid1( obj2, 0 );
3758 if ( !arg5 )
3759 return NULL;
3760 }
3761 pltr1(arg1,arg2,arg3,arg4,arg5);
3762 resultobj = SWIG_Py_Void();
3763 if (SWIG_IsTmpObj(res3)) {
3764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3765 } else {
3766 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3768 }
3769 if (SWIG_IsTmpObj(res4)) {
3770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3771 } else {
3772 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3774 }
3775 {
3776 cleanup_PLcGrid1();
3777 }
3778 return resultobj;
3779 fail:
3780 {
3781 cleanup_PLcGrid1();
3782 }
3783 return NULL;
3784 }
3785
3786
3787 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3788 PyObject *resultobj = 0;
3789 PLFLT arg1 ;
3790 PLFLT arg2 ;
3791 PLFLT *arg3 = (PLFLT *) 0 ;
3792 PLFLT *arg4 = (PLFLT *) 0 ;
3793 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3794 double val1 ;
3795 int ecode1 = 0 ;
3796 double val2 ;
3797 int ecode2 = 0 ;
3798 PLFLT temp3 ;
3799 int res3 = SWIG_TMPOBJ ;
3800 PLFLT temp4 ;
3801 int res4 = SWIG_TMPOBJ ;
3802 PyObject * obj0 = 0 ;
3803 PyObject * obj1 = 0 ;
3804 PyObject * obj2 = 0 ;
3805
3806 arg3 = &temp3;
3807 arg4 = &temp4;
3808 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3809 ecode1 = SWIG_AsVal_double(obj0, &val1);
3810 if (!SWIG_IsOK(ecode1)) {
3811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3812 }
3813 arg1 = (PLFLT)(val1);
3814 ecode2 = SWIG_AsVal_double(obj1, &val2);
3815 if (!SWIG_IsOK(ecode2)) {
3816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3817 }
3818 arg2 = (PLFLT)(val2);
3819 {
3820 arg5 = marshal_PLcGrid2( obj2, 0 );
3821 if ( !arg5 )
3822 return NULL;
3823 }
3824 pltr2(arg1,arg2,arg3,arg4,arg5);
3825 resultobj = SWIG_Py_Void();
3826 if (SWIG_IsTmpObj(res3)) {
3827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3828 } else {
3829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3831 }
3832 if (SWIG_IsTmpObj(res4)) {
3833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3834 } else {
3835 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3837 }
3838 {
3839 cleanup_PLcGrid2();
3840 }
3841 return resultobj;
3842 fail:
3843 {
3844 cleanup_PLcGrid2();
3845 }
3846 return NULL;
3847 }
3848
3849
3850
3851 // helper code for handling the callback
3852 #if 0
3853 static PyInterpreterState *save_interp = NULL;
3854 #endif
3855 enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type;
3856 PyObject* python_pltr = NULL;
3857 PyObject* python_f2eval = NULL;
3858 PyObject* python_ct = NULL;
3859 PyObject* python_mapform = NULL;
3860 PyObject* python_label = NULL;
3861
3862 #if 0
3863 #define MY_BLOCK_THREADS { \
3864 PyThreadState *prev_state, *new_state; \
3865 /* need to have started a thread at some stage */ \
3866 /* for the following to work */ \
3867 PyEval_AcquireLock(); \
3868 new_state = PyThreadState_New( save_interp ); \
3869 prev_state = PyThreadState_Swap( new_state );
3870 #define MY_UNBLOCK_THREADS \
3871 new_state = PyThreadState_Swap( prev_state ); \
3872 PyThreadState_Clear( new_state ); \
3873 PyEval_ReleaseLock(); \
3874 PyThreadState_Delete( new_state ); \
3875 }
3876 #else
3877 #define MY_BLOCK_THREADS
3878 #define MY_UNBLOCK_THREADS
3879 #endif
3880
3881 // Function prototypes
3882 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3883 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data );
3884 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3885 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3886 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3887 pltr_func marshal_pltr( PyObject* input );
3888 void cleanup_pltr( void );
3889 ct_func marshal_ct( PyObject* input );
3890 void cleanup_ct( void );
3891 mapform_func marshal_mapform( PyObject* input );
3892 void cleanup_mapform( void );
3893 PLPointer marshal_PLPointer( PyObject* input, int isimg );
3894 void cleanup_PLPointer( void );
3895
3896
3897 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3898
3899 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3900 {
3901 PyObject *pdata, *arglist, *result;
3902 PyArrayObject *tmp;
3903
3904 // the data argument is acutally a pointer to a python object
3905 pdata = (PyObject *) data;
3906 if ( data == NULL )
3907 {
3908 pdata = Py_None;
3909 }
3910 if ( python_pltr ) // if not something is terribly wrong
3911 { // hold a reference to the data object
3912 Py_XINCREF( pdata );
3913 // grab the Global Interpreter Lock to be sure threads don't mess us up
3914 MY_BLOCK_THREADS
3915 // build the argument list
3916 #ifdef PL_DOUBLE
3917 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3918 #else
3919 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3920 #endif
3921 if ( arglist == NULL )
3922 {
3923 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3924 *tx = *ty = 0;
3925 return;
3926 }
3927 // call the python function
3928 result = PyEval_CallObject( python_pltr, arglist );
3929 // release the argument list
3930 Py_CLEAR( arglist );
3931 // check and unpack the result
3932 if ( result == NULL )
3933 {
3934 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3935 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3936 *tx = *ty = 0;
3937 }
3938 else
3939 {
3940 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3941 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3942 {
3943 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3944 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3945 *tx = *ty = 0;
3946 }
3947 else
3948 {
3949 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3950 *tx = t[0];
3951 *ty = t[1];
3952 Py_CLEAR( tmp );
3953 }
3954 }
3955 // release the result
3956 Py_CLEAR( result );
3957 // release the global interpreter lock
3958 MY_UNBLOCK_THREADS
3959 }
3960 }
3961
3962 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3963 {
3964 PyObject *pdata, *arglist, *result;
3965 PLFLT fresult = 0.0;
3966
3967 // the data argument is acutally a pointer to a python object
3968 pdata = (PyObject *) data;
3969 if ( python_f2eval ) // if not something is terribly wrong
3970 { // hold a reference to the data object
3971 Py_XINCREF( pdata );
3972 // grab the Global Interpreter Lock to be sure threads don't mess us up
3973 MY_BLOCK_THREADS
3974 // build the argument list
3975 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3976 // call the python function
3977 result = PyEval_CallObject( python_f2eval, arglist );
3978 // release the argument list
3979 Py_CLEAR( arglist );
3980 // check and unpack the result
3981 if ( !PyFloat_Check( result ) )
3982 {
3983 fprintf( stderr, "f2eval callback must return a float\n" );
3984 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3985 }
3986 else
3987 {
3988 // should I test the type here?
3989 fresult = (PLFLT) PyFloat_AsDouble( result );
3990 }
3991 // release the result
3992 Py_CLEAR( result );
3993 // release the global interpreter lock
3994 MY_UNBLOCK_THREADS
3995 }
3996 return fresult;
3997 }
3998
3999 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4000 {
4001 PyObject *pdata, *arglist, *result, *unicode_string;
4002 char *pystring;
4003
4004 // the data argument is acutally a pointer to a python object
4005 if ( data )
4006 pdata = (PyObject *) data;
4007 else
4008 pdata = Py_None;
4009 if ( python_label ) // if not something is terribly wrong
4010 { // hold a reference to the data object
4011 Py_XINCREF( pdata );
4012 // grab the Global Interpreter Lock to be sure threads don't mess us up
4013 MY_BLOCK_THREADS
4014 // build the argument list
4015 #ifdef PL_DOUBLE
4016 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4017 #else
4018 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4019 #endif
4020 // call the python function
4021 result = PyEval_CallObject( python_label, arglist );
4022 // release the argument list
4023 //Py_CLEAR(arglist);
4024 // check and unpack the result
4025 if ( result == NULL )
4026 {
4027 fprintf( stderr, "label callback failed with 3 arguments\n" );
4028 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4029 }
4030 else if ( PyString_Check( result ) )
4031 {
4032 // should I test the type here?
4033 pystring = PyString_AsString( result );
4034 strncpy( string, pystring, len );
4035 }
4036 else if ( PyUnicode_Check( result ) )
4037 {
4038 // unicode_string is never freed? memory leak here?
4039 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4040 pystring = PyBytes_AS_STRING( unicode_string );
4041 // len may be different then the byte string length w/ unicode?
4042 strncpy( string, pystring, len );
4043 }
4044 else
4045 {
4046 fprintf( stderr, "label callback must return a string\n" );
4047 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4048 }
4049 // release the result
4050 Py_CLEAR( result );
4051 // release the global interpreter lock
4052 MY_UNBLOCK_THREADS
4053 }
4054 }
4055
4056 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4057 {
4058 PyObject *px, *py, *pdata, *arglist, *result;
4059 npy_intp n;
4060 n = 1;
4061
4062 // the data argument is acutally a pointer to a python object
4063 pdata = (PyObject *) data;
4064 if ( data == NULL )
4065 {
4066 pdata = Py_None;
4067 }
4068 if ( python_ct ) // if not something is terribly wrong
4069 { // hold a reference to the data object
4070 Py_XINCREF( pdata );
4071 // grab the Global Interpreter Lock to be sure threads don't mess us up
4072 MY_BLOCK_THREADS
4073 // build the argument list
4074 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4075 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4076 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4077 // call the python function
4078 result = PyEval_CallObject( python_ct, arglist );
4079 // release the argument list
4080 Py_CLEAR( arglist );
4081 Py_CLEAR( px );
4082 Py_CLEAR( py );
4083 Py_CLEAR( pdata );
4084 // check and unpack the result
4085 if ( result == NULL )
4086 {
4087 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4088 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4089 }
4090 // release the result
4091 Py_CLEAR( result );
4092 // release the global interpreter lock
4093 MY_UNBLOCK_THREADS
4094 }
4095 }
4096
4097 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
4098 {
4099 PyObject *px, *py, *arglist, *result;
4100 // PyArrayObject *tmpx, *tmpy;
4101 // PLFLT *xx, *yy;
4102 // PLINT i;
4103 npy_intp nn;
4104 nn = n;
4105
4106 if ( python_mapform ) // if not something is terribly wrong
4107 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4108 MY_BLOCK_THREADS
4109 // build the argument list
4110 #ifdef PL_HAVE_PTHREAD
4111 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4112 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4113 #else
4114 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4115 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4116 #endif
4117 arglist = Py_BuildValue( "(iOO)", n, px, py );
4118 // call the python function
4119 result = PyEval_CallObject( python_mapform, arglist );
4120 // release the argument list
4121 Py_CLEAR( arglist );
4122 Py_CLEAR( px );
4123 Py_CLEAR( py );
4124 // check and unpack the result
4125 if ( result == NULL )
4126 {
4127 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4128 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4129 }
4130 // release the result
4131 Py_CLEAR( result );
4132 // release the global interpreter lock
4133 MY_UNBLOCK_THREADS
4134 }
4135 }
4136
4137 // marshal the pltr function pointer argument
4138 pltr_func marshal_pltr( PyObject* input )
4139 {
4140 pltr_func result = do_pltr_callback;
4141 PyObject * rep = PyObject_Repr( input );
4142 if ( rep )
4143 {
4144 // Memory leaks here? str and uni_str are not freed?
4145 char* str;
4146 if ( PyUnicode_Check( rep ) )
4147 {
4148 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4149 str = PyBytes_AS_STRING( uni_str );
4150 }
4151 else
4152 {
4153 str = PyString_AsString( rep );
4154 }
4155 if ( strstr( str, "function pltr0" ) != 0 )
4156 {
4157 result = pltr0;
4158 pltr_type = CB_0;
4159 python_pltr = NULL;
4160 }
4161 else if ( strstr( str, "function pltr1" ) != 0 )
4162 {
4163 result = pltr1;
4164 pltr_type = CB_1;
4165 python_pltr = NULL;
4166 }
4167 else if ( strstr( str, "function pltr2" ) != 0 )
4168 {
4169 result = pltr2;
4170 pltr_type = CB_2;
4171 python_pltr = NULL;
4172 }
4173 else
4174 {
4175 python_pltr = input;
4176 pltr_type = CB_Python;
4177 Py_XINCREF( input );
4178 }
4179 Py_CLEAR( rep );
4180 }
4181 else
4182 {
4183 python_pltr = input;
4184 pltr_type = CB_Python;
4185 Py_XINCREF( input );
4186 }
4187 return result;
4188 }
4189
4190 void cleanup_pltr( void )
4191 {
4192 Py_CLEAR( python_pltr );
4193 python_pltr = 0;
4194 }
4195
4196 // marshal the ct function pointer argument
4197 ct_func marshal_ct( PyObject* input )
4198 {
4199 ct_func result = do_ct_callback;
4200 python_ct = input;
4201 Py_XINCREF( input );
4202 return result;
4203 }
4204
4205 void cleanup_ct( void )
4206 {
4207 Py_CLEAR( python_ct );
4208 python_ct = 0;
4209 }
4210
4211 // marshal the mapform function pointer argument
4212 mapform_func marshal_mapform( PyObject* input )
4213 {
4214 mapform_func result = do_mapform_callback;
4215 python_mapform = input;
4216 Py_XINCREF( input );
4217 return result;
4218 }
4219
4220 void cleanup_mapform( void )
4221 {
4222 Py_CLEAR( python_mapform );
4223 python_mapform = 0;
4224 }
4225
4226 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4227 {
4228 PLPointer result = NULL;
4229 switch ( pltr_type )
4230 {
4231 case CB_0:
4232 break;
4233 case CB_1:
4234 if ( input != Py_None )
4235 result = marshal_PLcGrid1( input, isimg );
4236 break;
4237 case CB_2:
4238 if ( input != Py_None )
4239 result = marshal_PLcGrid2( input, isimg );
4240 break;
4241 case CB_Python:
4242 Py_XINCREF( input );
4243 result = (PLPointer *) input;
4244 break;
4245 default:
4246 fprintf( stderr, "pltr_type is invalid\n" );
4247 }
4248 return result;
4249 }
4250
4251 void cleanup_PLPointer( void )
4252 {
4253 switch ( pltr_type )
4254 {
4255 case CB_0:
4256 break;
4257 case CB_1:
4258 cleanup_PLcGrid1();
4259 break;
4260 case CB_2:
4261 cleanup_PLcGrid2();
4262 break;
4263 case CB_Python:
4264 Py_CLEAR( python_pltr );
4265 break;
4266 default:
4267 fprintf( stderr, "pltr_type is invalid\n" );
4268 }
4269 python_pltr = 0;
4270 pltr_type = CB_0;
4271 }
4272
4273
4274
4275 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276 PyObject *resultobj = 0;
4277 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4278 int arg2 ;
4279 void *argp1 = 0 ;
4280 int res1 = 0 ;
4281 int val2 ;
4282 int ecode2 = 0 ;
4283 PyObject * obj0 = 0 ;
4284 PyObject * obj1 = 0 ;
4285
4286 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4288 if (!SWIG_IsOK(res1)) {
4289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4290 }
4291 arg1 = (PLGraphicsIn *)(argp1);
4292 ecode2 = SWIG_AsVal_int(obj1, &val2);
4293 if (!SWIG_IsOK(ecode2)) {
4294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4295 }
4296 arg2 = (int)(val2);
4297 if (arg1) (arg1)->type = arg2;
4298 resultobj = SWIG_Py_Void();
4299 return resultobj;
4300 fail:
4301 return NULL;
4302 }
4303
4304
4305 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4306 PyObject *resultobj = 0;
4307 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4308 void *argp1 = 0 ;
4309 int res1 = 0 ;
4310 PyObject * obj0 = 0 ;
4311 int result;
4312
4313 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4315 if (!SWIG_IsOK(res1)) {
4316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4317 }
4318 arg1 = (PLGraphicsIn *)(argp1);
4319 result = (int) ((arg1)->type);
4320 resultobj = SWIG_From_int((int)(result));
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4328 PyObject *resultobj = 0;
4329 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4330 unsigned int arg2 ;
4331 void *argp1 = 0 ;
4332 int res1 = 0 ;
4333 unsigned int val2 ;
4334 int ecode2 = 0 ;
4335 PyObject * obj0 = 0 ;
4336 PyObject * obj1 = 0 ;
4337
4338 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4340 if (!SWIG_IsOK(res1)) {
4341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4342 }
4343 arg1 = (PLGraphicsIn *)(argp1);
4344 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4345 if (!SWIG_IsOK(ecode2)) {
4346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4347 }
4348 arg2 = (unsigned int)(val2);
4349 if (arg1) (arg1)->state = arg2;
4350 resultobj = SWIG_Py_Void();
4351 return resultobj;
4352 fail:
4353 return NULL;
4354 }
4355
4356
4357 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4358 PyObject *resultobj = 0;
4359 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4360 void *argp1 = 0 ;
4361 int res1 = 0 ;
4362 PyObject * obj0 = 0 ;
4363 unsigned int result;
4364
4365 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4367 if (!SWIG_IsOK(res1)) {
4368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4369 }
4370 arg1 = (PLGraphicsIn *)(argp1);
4371 result = (unsigned int) ((arg1)->state);
4372 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4373 return resultobj;
4374 fail:
4375 return NULL;
4376 }
4377
4378
4379 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4380 PyObject *resultobj = 0;
4381 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4382 unsigned int arg2 ;
4383 void *argp1 = 0 ;
4384 int res1 = 0 ;
4385 unsigned int val2 ;
4386 int ecode2 = 0 ;
4387 PyObject * obj0 = 0 ;
4388 PyObject * obj1 = 0 ;
4389
4390 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4392 if (!SWIG_IsOK(res1)) {
4393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4394 }
4395 arg1 = (PLGraphicsIn *)(argp1);
4396 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4397 if (!SWIG_IsOK(ecode2)) {
4398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4399 }
4400 arg2 = (unsigned int)(val2);
4401 if (arg1) (arg1)->keysym = arg2;
4402 resultobj = SWIG_Py_Void();
4403 return resultobj;
4404 fail:
4405 return NULL;
4406 }
4407
4408
4409 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4410 PyObject *resultobj = 0;
4411 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4412 void *argp1 = 0 ;
4413 int res1 = 0 ;
4414 PyObject * obj0 = 0 ;
4415 unsigned int result;
4416
4417 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4419 if (!SWIG_IsOK(res1)) {
4420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4421 }
4422 arg1 = (PLGraphicsIn *)(argp1);
4423 result = (unsigned int) ((arg1)->keysym);
4424 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4434 unsigned int arg2 ;
4435 void *argp1 = 0 ;
4436 int res1 = 0 ;
4437 unsigned int val2 ;
4438 int ecode2 = 0 ;
4439 PyObject * obj0 = 0 ;
4440 PyObject * obj1 = 0 ;
4441
4442 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4444 if (!SWIG_IsOK(res1)) {
4445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4446 }
4447 arg1 = (PLGraphicsIn *)(argp1);
4448 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4449 if (!SWIG_IsOK(ecode2)) {
4450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4451 }
4452 arg2 = (unsigned int)(val2);
4453 if (arg1) (arg1)->button = arg2;
4454 resultobj = SWIG_Py_Void();
4455 return resultobj;
4456 fail:
4457 return NULL;
4458 }
4459
4460
4461 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4464 void *argp1 = 0 ;
4465 int res1 = 0 ;
4466 PyObject * obj0 = 0 ;
4467 unsigned int result;
4468
4469 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4471 if (!SWIG_IsOK(res1)) {
4472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4473 }
4474 arg1 = (PLGraphicsIn *)(argp1);
4475 result = (unsigned int) ((arg1)->button);
4476 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4484 PyObject *resultobj = 0;
4485 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4486 PLINT arg2 ;
4487 void *argp1 = 0 ;
4488 int res1 = 0 ;
4489 int val2 ;
4490 int ecode2 = 0 ;
4491 PyObject * obj0 = 0 ;
4492 PyObject * obj1 = 0 ;
4493
4494 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4496 if (!SWIG_IsOK(res1)) {
4497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4498 }
4499 arg1 = (PLGraphicsIn *)(argp1);
4500 ecode2 = SWIG_AsVal_int(obj1, &val2);
4501 if (!SWIG_IsOK(ecode2)) {
4502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4503 }
4504 arg2 = (PLINT)(val2);
4505 if (arg1) (arg1)->subwindow = arg2;
4506 resultobj = SWIG_Py_Void();
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4516 void *argp1 = 0 ;
4517 int res1 = 0 ;
4518 PyObject * obj0 = 0 ;
4519 PLINT result;
4520
4521 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4525 }
4526 arg1 = (PLGraphicsIn *)(argp1);
4527 result = (PLINT) ((arg1)->subwindow);
4528 resultobj = SWIG_From_int((int)(result));
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536 PyObject *resultobj = 0;
4537 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4538 char *arg2 ;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 char temp2[16] ;
4542 int res2 ;
4543 PyObject * obj0 = 0 ;
4544 PyObject * obj1 = 0 ;
4545
4546 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4550 }
4551 arg1 = (PLGraphicsIn *)(argp1);
4552 res2 = SWIG_AsCharArray(obj1, temp2, 16);
4553 if (!SWIG_IsOK(res2)) {
4554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4555 }
4556 arg2 = (char *)(temp2);
4557 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4558 else memset(arg1->string,0,16*sizeof(char));
4559 resultobj = SWIG_Py_Void();
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567 PyObject *resultobj = 0;
4568 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4569 void *argp1 = 0 ;
4570 int res1 = 0 ;
4571 PyObject * obj0 = 0 ;
4572 char *result = 0 ;
4573
4574 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4576 if (!SWIG_IsOK(res1)) {
4577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4578 }
4579 arg1 = (PLGraphicsIn *)(argp1);
4580 result = (char *)(char *) ((arg1)->string);
4581 {
4582 size_t size = SWIG_strnlen(result, 16);
4583
4584
4585
4586 resultobj = SWIG_FromCharPtrAndSize(result, size);
4587 }
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4597 int arg2 ;
4598 void *argp1 = 0 ;
4599 int res1 = 0 ;
4600 int val2 ;
4601 int ecode2 = 0 ;
4602 PyObject * obj0 = 0 ;
4603 PyObject * obj1 = 0 ;
4604
4605 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4607 if (!SWIG_IsOK(res1)) {
4608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4609 }
4610 arg1 = (PLGraphicsIn *)(argp1);
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = (int)(val2);
4616 if (arg1) (arg1)->pX = arg2;
4617 resultobj = SWIG_Py_Void();
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4625 PyObject *resultobj = 0;
4626 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 PyObject * obj0 = 0 ;
4630 int result;
4631
4632 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4636 }
4637 arg1 = (PLGraphicsIn *)(argp1);
4638 result = (int) ((arg1)->pX);
4639 resultobj = SWIG_From_int((int)(result));
4640 return resultobj;
4641 fail:
4642 return NULL;
4643 }
4644
4645
4646 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4647 PyObject *resultobj = 0;
4648 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4649 int arg2 ;
4650 void *argp1 = 0 ;
4651 int res1 = 0 ;
4652 int val2 ;
4653 int ecode2 = 0 ;
4654 PyObject * obj0 = 0 ;
4655 PyObject * obj1 = 0 ;
4656
4657 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4661 }
4662 arg1 = (PLGraphicsIn *)(argp1);
4663 ecode2 = SWIG_AsVal_int(obj1, &val2);
4664 if (!SWIG_IsOK(ecode2)) {
4665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4666 }
4667 arg2 = (int)(val2);
4668 if (arg1) (arg1)->pY = arg2;
4669 resultobj = SWIG_Py_Void();
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4677 PyObject *resultobj = 0;
4678 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4679 void *argp1 = 0 ;
4680 int res1 = 0 ;
4681 PyObject * obj0 = 0 ;
4682 int result;
4683
4684 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4688 }
4689 arg1 = (PLGraphicsIn *)(argp1);
4690 result = (int) ((arg1)->pY);
4691 resultobj = SWIG_From_int((int)(result));
4692 return resultobj;
4693 fail:
4694 return NULL;
4695 }
4696
4697
4698 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4699 PyObject *resultobj = 0;
4700 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4701 PLFLT arg2 ;
4702 void *argp1 = 0 ;
4703 int res1 = 0 ;
4704 double val2 ;
4705 int ecode2 = 0 ;
4706 PyObject * obj0 = 0 ;
4707 PyObject * obj1 = 0 ;
4708
4709 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4711 if (!SWIG_IsOK(res1)) {
4712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4713 }
4714 arg1 = (PLGraphicsIn *)(argp1);
4715 ecode2 = SWIG_AsVal_double(obj1, &val2);
4716 if (!SWIG_IsOK(ecode2)) {
4717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4718 }
4719 arg2 = (PLFLT)(val2);
4720 if (arg1) (arg1)->dX = arg2;
4721 resultobj = SWIG_Py_Void();
4722 return resultobj;
4723 fail:
4724 return NULL;
4725 }
4726
4727
4728 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4729 PyObject *resultobj = 0;
4730 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PLFLT result;
4735
4736 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4738 if (!SWIG_IsOK(res1)) {
4739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4740 }
4741 arg1 = (PLGraphicsIn *)(argp1);
4742 result = (PLFLT) ((arg1)->dX);
4743 resultobj = SWIG_From_double((double)(result));
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4751 PyObject *resultobj = 0;
4752 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4753 PLFLT arg2 ;
4754 void *argp1 = 0 ;
4755 int res1 = 0 ;
4756 double val2 ;
4757 int ecode2 = 0 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760
4761 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4765 }
4766 arg1 = (PLGraphicsIn *)(argp1);
4767 ecode2 = SWIG_AsVal_double(obj1, &val2);
4768 if (!SWIG_IsOK(ecode2)) {
4769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4770 }
4771 arg2 = (PLFLT)(val2);
4772 if (arg1) (arg1)->dY = arg2;
4773 resultobj = SWIG_Py_Void();
4774 return resultobj;
4775 fail:
4776 return NULL;
4777 }
4778
4779
4780 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4781 PyObject *resultobj = 0;
4782 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4783 void *argp1 = 0 ;
4784 int res1 = 0 ;
4785 PyObject * obj0 = 0 ;
4786 PLFLT result;
4787
4788 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4792 }
4793 arg1 = (PLGraphicsIn *)(argp1);
4794 result = (PLFLT) ((arg1)->dY);
4795 resultobj = SWIG_From_double((double)(result));
4796 return resultobj;
4797 fail:
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4803 PyObject *resultobj = 0;
4804 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4805 PLFLT arg2 ;
4806 void *argp1 = 0 ;
4807 int res1 = 0 ;
4808 double val2 ;
4809 int ecode2 = 0 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812
4813 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4817 }
4818 arg1 = (PLGraphicsIn *)(argp1);
4819 ecode2 = SWIG_AsVal_double(obj1, &val2);
4820 if (!SWIG_IsOK(ecode2)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4822 }
4823 arg2 = (PLFLT)(val2);
4824 if (arg1) (arg1)->wX = arg2;
4825 resultobj = SWIG_Py_Void();
4826 return resultobj;
4827 fail:
4828 return NULL;
4829 }
4830
4831
4832 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4833 PyObject *resultobj = 0;
4834 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4835 void *argp1 = 0 ;
4836 int res1 = 0 ;
4837 PyObject * obj0 = 0 ;
4838 PLFLT result;
4839
4840 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4842 if (!SWIG_IsOK(res1)) {
4843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4844 }
4845 arg1 = (PLGraphicsIn *)(argp1);
4846 result = (PLFLT) ((arg1)->wX);
4847 resultobj = SWIG_From_double((double)(result));
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4855 PyObject *resultobj = 0;
4856 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4857 PLFLT arg2 ;
4858 void *argp1 = 0 ;
4859 int res1 = 0 ;
4860 double val2 ;
4861 int ecode2 = 0 ;
4862 PyObject * obj0 = 0 ;
4863 PyObject * obj1 = 0 ;
4864
4865 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4867 if (!SWIG_IsOK(res1)) {
4868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4869 }
4870 arg1 = (PLGraphicsIn *)(argp1);
4871 ecode2 = SWIG_AsVal_double(obj1, &val2);
4872 if (!SWIG_IsOK(ecode2)) {
4873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4874 }
4875 arg2 = (PLFLT)(val2);
4876 if (arg1) (arg1)->wY = arg2;
4877 resultobj = SWIG_Py_Void();
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4885 PyObject *resultobj = 0;
4886 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 PyObject * obj0 = 0 ;
4890 PLFLT result;
4891
4892 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4894 if (!SWIG_IsOK(res1)) {
4895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4896 }
4897 arg1 = (PLGraphicsIn *)(argp1);
4898 result = (PLFLT) ((arg1)->wY);
4899 resultobj = SWIG_From_double((double)(result));
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4907 PyObject *resultobj = 0;
4908 PLGraphicsIn *result = 0 ;
4909
4910 if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4911 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW | 0 );
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4920 PyObject *resultobj = 0;
4921 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 PyObject * obj0 = 0 ;
4925
4926 if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4928 if (!SWIG_IsOK(res1)) {
4929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4930 }
4931 arg1 = (PLGraphicsIn *)(argp1);
4932 free((char *) arg1);
4933 resultobj = SWIG_Py_Void();
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *obj;
4942 if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
4943 SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj));
4944 return SWIG_Py_Void();
4945 }
4946
4947 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4948 PyObject *resultobj = 0;
4949 PLINT arg1 ;
4950 int val1 ;
4951 int ecode1 = 0 ;
4952 PyObject * obj0 = 0 ;
4953
4954 if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4955 ecode1 = SWIG_AsVal_int(obj0, &val1);
4956 if (!SWIG_IsOK(ecode1)) {
4957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4958 }
4959 arg1 = (PLINT)(val1);
4960 plsxwin(arg1);
4961 resultobj = SWIG_Py_Void();
4962 return resultobj;
4963 fail:
4964 return NULL;
4965 }
4966
4967
4968 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4969 PyObject *resultobj = 0;
4970 PLINT arg1 ;
4971 PLINT arg2 ;
4972 int val1 ;
4973 int ecode1 = 0 ;
4974 int val2 ;
4975 int ecode2 = 0 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978
4979 if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4980 ecode1 = SWIG_AsVal_int(obj0, &val1);
4981 if (!SWIG_IsOK(ecode1)) {
4982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4983 }
4984 arg1 = (PLINT)(val1);
4985 ecode2 = SWIG_AsVal_int(obj1, &val2);
4986 if (!SWIG_IsOK(ecode2)) {
4987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4988 }
4989 arg2 = (PLINT)(val2);
4990 pl_setcontlabelformat(arg1,arg2);
4991 resultobj = SWIG_Py_Void();
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000 PLFLT arg1 ;
5001 PLFLT arg2 ;
5002 PLFLT arg3 ;
5003 PLINT arg4 ;
5004 double val1 ;
5005 int ecode1 = 0 ;
5006 double val2 ;
5007 int ecode2 = 0 ;
5008 double val3 ;
5009 int ecode3 = 0 ;
5010 int val4 ;
5011 int ecode4 = 0 ;
5012 PyObject * obj0 = 0 ;
5013 PyObject * obj1 = 0 ;
5014 PyObject * obj2 = 0 ;
5015 PyObject * obj3 = 0 ;
5016
5017 if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5018 ecode1 = SWIG_AsVal_double(obj0, &val1);
5019 if (!SWIG_IsOK(ecode1)) {
5020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5021 }
5022 arg1 = (PLFLT)(val1);
5023 ecode2 = SWIG_AsVal_double(obj1, &val2);
5024 if (!SWIG_IsOK(ecode2)) {
5025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5026 }
5027 arg2 = (PLFLT)(val2);
5028 ecode3 = SWIG_AsVal_double(obj2, &val3);
5029 if (!SWIG_IsOK(ecode3)) {
5030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5031 }
5032 arg3 = (PLFLT)(val3);
5033 ecode4 = SWIG_AsVal_int(obj3, &val4);
5034 if (!SWIG_IsOK(ecode4)) {
5035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5036 }
5037 arg4 = (PLINT)(val4);
5038 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5039 resultobj = SWIG_Py_Void();
5040 return resultobj;
5041 fail:
5042 return NULL;
5043 }
5044
5045
5046 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047 PyObject *resultobj = 0;
5048 PLINT arg1 ;
5049 int val1 ;
5050 int ecode1 = 0 ;
5051 PyObject * obj0 = 0 ;
5052
5053 if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
5054 ecode1 = SWIG_AsVal_int(obj0, &val1);
5055 if (!SWIG_IsOK(ecode1)) {
5056 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5057 }
5058 arg1 = (PLINT)(val1);
5059 pladv(arg1);
5060 resultobj = SWIG_Py_Void();
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 PLFLT arg1 ;
5070 PLFLT arg2 ;
5071 PLFLT arg3 ;
5072 PLFLT arg4 ;
5073 PLFLT arg5 ;
5074 PLFLT arg6 ;
5075 PLFLT arg7 ;
5076 PLBOOL arg8 ;
5077 double val1 ;
5078 int ecode1 = 0 ;
5079 double val2 ;
5080 int ecode2 = 0 ;
5081 double val3 ;
5082 int ecode3 = 0 ;
5083 double val4 ;
5084 int ecode4 = 0 ;
5085 double val5 ;
5086 int ecode5 = 0 ;
5087 double val6 ;
5088 int ecode6 = 0 ;
5089 double val7 ;
5090 int ecode7 = 0 ;
5091 int val8 ;
5092 int ecode8 = 0 ;
5093 PyObject * obj0 = 0 ;
5094 PyObject * obj1 = 0 ;
5095 PyObject * obj2 = 0 ;
5096 PyObject * obj3 = 0 ;
5097 PyObject * obj4 = 0 ;
5098 PyObject * obj5 = 0 ;
5099 PyObject * obj6 = 0 ;
5100 PyObject * obj7 = 0 ;
5101
5102 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5103 ecode1 = SWIG_AsVal_double(obj0, &val1);
5104 if (!SWIG_IsOK(ecode1)) {
5105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5106 }
5107 arg1 = (PLFLT)(val1);
5108 ecode2 = SWIG_AsVal_double(obj1, &val2);
5109 if (!SWIG_IsOK(ecode2)) {
5110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5111 }
5112 arg2 = (PLFLT)(val2);
5113 ecode3 = SWIG_AsVal_double(obj2, &val3);
5114 if (!SWIG_IsOK(ecode3)) {
5115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5116 }
5117 arg3 = (PLFLT)(val3);
5118 ecode4 = SWIG_AsVal_double(obj3, &val4);
5119 if (!SWIG_IsOK(ecode4)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5121 }
5122 arg4 = (PLFLT)(val4);
5123 ecode5 = SWIG_AsVal_double(obj4, &val5);
5124 if (!SWIG_IsOK(ecode5)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5126 }
5127 arg5 = (PLFLT)(val5);
5128 ecode6 = SWIG_AsVal_double(obj5, &val6);
5129 if (!SWIG_IsOK(ecode6)) {
5130 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5131 }
5132 arg6 = (PLFLT)(val6);
5133 ecode7 = SWIG_AsVal_double(obj6, &val7);
5134 if (!SWIG_IsOK(ecode7)) {
5135 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5136 }
5137 arg7 = (PLFLT)(val7);
5138 ecode8 = SWIG_AsVal_int(obj7, &val8);
5139 if (!SWIG_IsOK(ecode8)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5141 }
5142 arg8 = (PLBOOL)(val8);
5143 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5144 resultobj = SWIG_Py_Void();
5145 return resultobj;
5146 fail:
5147 return NULL;
5148 }
5149
5150
5151 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5152 PyObject *resultobj = 0;
5153 PLFLT arg1 ;
5154 PLFLT arg2 ;
5155 char *arg3 = (char *) 0 ;
5156 PLFLT arg4 ;
5157 PLINT arg5 ;
5158 char *arg6 = (char *) 0 ;
5159 PLFLT arg7 ;
5160 PLINT arg8 ;
5161 double val1 ;
5162 int ecode1 = 0 ;
5163 double val2 ;
5164 int ecode2 = 0 ;
5165 int res3 ;
5166 char *buf3 = 0 ;
5167 int alloc3 = 0 ;
5168 double val4 ;
5169 int ecode4 = 0 ;
5170 int val5 ;
5171 int ecode5 = 0 ;
5172 int res6 ;
5173 char *buf6 = 0 ;
5174 int alloc6 = 0 ;
5175 double val7 ;
5176 int ecode7 = 0 ;
5177 int val8 ;
5178 int ecode8 = 0 ;
5179 PyObject * obj0 = 0 ;
5180 PyObject * obj1 = 0 ;
5181 PyObject * obj2 = 0 ;
5182 PyObject * obj3 = 0 ;
5183 PyObject * obj4 = 0 ;
5184 PyObject * obj5 = 0 ;
5185 PyObject * obj6 = 0 ;
5186 PyObject * obj7 = 0 ;
5187
5188 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5189 ecode1 = SWIG_AsVal_double(obj0, &val1);
5190 if (!SWIG_IsOK(ecode1)) {
5191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5192 }
5193 arg1 = (PLFLT)(val1);
5194 ecode2 = SWIG_AsVal_double(obj1, &val2);
5195 if (!SWIG_IsOK(ecode2)) {
5196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5197 }
5198 arg2 = (PLFLT)(val2);
5199 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5200 if (!SWIG_IsOK(res3)) {
5201 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5202 }
5203 arg3 = (char *)(buf3);
5204 ecode4 = SWIG_AsVal_double(obj3, &val4);
5205 if (!SWIG_IsOK(ecode4)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5207 }
5208 arg4 = (PLFLT)(val4);
5209 ecode5 = SWIG_AsVal_int(obj4, &val5);
5210 if (!SWIG_IsOK(ecode5)) {
5211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5212 }
5213 arg5 = (PLINT)(val5);
5214 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5215 if (!SWIG_IsOK(res6)) {
5216 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5217 }
5218 arg6 = (char *)(buf6);
5219 ecode7 = SWIG_AsVal_double(obj6, &val7);
5220 if (!SWIG_IsOK(ecode7)) {
5221 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5222 }
5223 arg7 = (PLFLT)(val7);
5224 ecode8 = SWIG_AsVal_int(obj7, &val8);
5225 if (!SWIG_IsOK(ecode8)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5227 }
5228 arg8 = (PLINT)(val8);
5229 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5230 resultobj = SWIG_Py_Void();
5231 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5232 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5233 return resultobj;
5234 fail:
5235 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5236 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5237 return NULL;
5238 }
5239
5240
5241 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5242 PyObject *resultobj = 0;
5243 PLINT arg1 ;
5244 PLFLT *arg2 = (PLFLT *) 0 ;
5245 PLFLT *arg3 = (PLFLT *) 0 ;
5246 PLINT arg4 ;
5247 PyArrayObject *tmp1 = NULL ;
5248 PyArrayObject *tmp3 = NULL ;
5249 int val4 ;
5250 int ecode4 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 PyObject * obj2 = 0 ;
5254
5255 if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5256 {
5257 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5258 if ( tmp1 == NULL )
5259 return NULL;
5260 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5261 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5262 }
5263 {
5264 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5265 if ( tmp3 == NULL )
5266 return NULL;
5267 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5268 {
5269 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5270 return NULL;
5271 }
5272 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5273 }
5274 ecode4 = SWIG_AsVal_int(obj2, &val4);
5275 if (!SWIG_IsOK(ecode4)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5277 }
5278 arg4 = (PLINT)(val4);
5279 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5280 resultobj = SWIG_Py_Void();
5281 {
5282 Py_CLEAR( tmp1 );
5283 }
5284 {
5285 Py_CLEAR( tmp3 );
5286 }
5287 return resultobj;
5288 fail:
5289 {
5290 Py_CLEAR( tmp1 );
5291 }
5292 {
5293 Py_CLEAR( tmp3 );
5294 }
5295 return NULL;
5296 }
5297
5298
5299 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5300 PyObject *resultobj = 0;
5301 PLINT *arg1 = (PLINT *) 0 ;
5302 PLINT *arg2 = (PLINT *) 0 ;
5303 PLINT *arg3 = (PLINT *) 0 ;
5304 PLINT *arg4 = (PLINT *) 0 ;
5305 PLINT *arg5 = (PLINT *) 0 ;
5306 PLFLT *arg6 = (PLFLT *) 0 ;
5307 PLFLT arg7 ;
5308 PLINT temp1 ;
5309 int res1 = SWIG_TMPOBJ ;
5310 PLINT temp2 ;
5311 int res2 = SWIG_TMPOBJ ;
5312 PLINT temp3 ;
5313 int res3 = SWIG_TMPOBJ ;
5314 PLINT temp4 ;
5315 int res4 = SWIG_TMPOBJ ;
5316 PLINT temp5 ;
5317 int res5 = SWIG_TMPOBJ ;
5318 PLFLT temp6 ;
5319 int res6 = SWIG_TMPOBJ ;
5320 double val7 ;
5321 int ecode7 = 0 ;
5322 PyObject * obj0 = 0 ;
5323
5324 arg1 = &temp1;
5325 arg2 = &temp2;
5326 arg3 = &temp3;
5327 arg4 = &temp4;
5328 arg5 = &temp5;
5329 arg6 = &temp6;
5330 if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5331 ecode7 = SWIG_AsVal_double(obj0, &val7);
5332 if (!SWIG_IsOK(ecode7)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5334 }
5335 arg7 = (PLFLT)(val7);
5336 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5337 resultobj = SWIG_Py_Void();
5338 if (SWIG_IsTmpObj(res1)) {
5339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5340 } else {
5341 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5343 }
5344 if (SWIG_IsTmpObj(res2)) {
5345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5346 } else {
5347 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5349 }
5350 if (SWIG_IsTmpObj(res3)) {
5351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5352 } else {
5353 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5355 }
5356 if (SWIG_IsTmpObj(res4)) {
5357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5358 } else {
5359 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5361 }
5362 if (SWIG_IsTmpObj(res5)) {
5363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5364 } else {
5365 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5367 }
5368 if (SWIG_IsTmpObj(res6)) {
5369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5370 } else {
5371 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5373 }
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382
5383 if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5384 plbop();
5385 resultobj = SWIG_Py_Void();
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 char *arg1 = (char *) 0 ;
5395 PLFLT arg2 ;
5396 PLINT arg3 ;
5397 char *arg4 = (char *) 0 ;
5398 PLFLT arg5 ;
5399 PLINT arg6 ;
5400 int res1 ;
5401 char *buf1 = 0 ;
5402 int alloc1 = 0 ;
5403 double val2 ;
5404 int ecode2 = 0 ;
5405 int val3 ;
5406 int ecode3 = 0 ;
5407 int res4 ;
5408 char *buf4 = 0 ;
5409 int alloc4 = 0 ;
5410 double val5 ;
5411 int ecode5 = 0 ;
5412 int val6 ;
5413 int ecode6 = 0 ;
5414 PyObject * obj0 = 0 ;
5415 PyObject * obj1 = 0 ;
5416 PyObject * obj2 = 0 ;
5417 PyObject * obj3 = 0 ;
5418 PyObject * obj4 = 0 ;
5419 PyObject * obj5 = 0 ;
5420
5421 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5422 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5423 if (!SWIG_IsOK(res1)) {
5424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5425 }
5426 arg1 = (char *)(buf1);
5427 ecode2 = SWIG_AsVal_double(obj1, &val2);
5428 if (!SWIG_IsOK(ecode2)) {
5429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5430 }
5431 arg2 = (PLFLT)(val2);
5432 ecode3 = SWIG_AsVal_int(obj2, &val3);
5433 if (!SWIG_IsOK(ecode3)) {
5434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5435 }
5436 arg3 = (PLINT)(val3);
5437 res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5438 if (!SWIG_IsOK(res4)) {
5439 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5440 }
5441 arg4 = (char *)(buf4);
5442 ecode5 = SWIG_AsVal_double(obj4, &val5);
5443 if (!SWIG_IsOK(ecode5)) {
5444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5445 }
5446 arg5 = (PLFLT)(val5);
5447 ecode6 = SWIG_AsVal_int(obj5, &val6);
5448 if (!SWIG_IsOK(ecode6)) {
5449 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5450 }
5451 arg6 = (PLINT)(val6);
5452 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5453 resultobj = SWIG_Py_Void();
5454 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5455 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5456 return resultobj;
5457 fail:
5458 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5459 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5460 return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465 PyObject *resultobj = 0;
5466 char *arg1 = (char *) 0 ;
5467 char *arg2 = (char *) 0 ;
5468 PLFLT arg3 ;
5469 PLINT arg4 ;
5470 char *arg5 = (char *) 0 ;
5471 char *arg6 = (char *) 0 ;
5472 PLFLT arg7 ;
5473 PLINT arg8 ;
5474 char *arg9 = (char *) 0 ;
5475 char *arg10 = (char *) 0 ;
5476 PLFLT arg11 ;
5477 PLINT arg12 ;
5478 int res1 ;
5479 char *buf1 = 0 ;
5480 int alloc1 = 0 ;
5481 int res2 ;
5482 char *buf2 = 0 ;
5483 int alloc2 = 0 ;
5484 double val3 ;
5485 int ecode3 = 0 ;
5486 int val4 ;
5487 int ecode4 = 0 ;
5488 int res5 ;
5489 char *buf5 = 0 ;
5490 int alloc5 = 0 ;
5491 int res6 ;
5492 char *buf6 = 0 ;
5493 int alloc6 = 0 ;
5494 double val7 ;
5495 int ecode7 = 0 ;
5496 int val8 ;
5497 int ecode8 = 0 ;
5498 int res9 ;
5499 char *buf9 = 0 ;
5500 int alloc9 = 0 ;
5501 int res10 ;
5502 char *buf10 = 0 ;
5503 int alloc10 = 0 ;
5504 double val11 ;
5505 int ecode11 = 0 ;
5506 int val12 ;
5507 int ecode12 = 0 ;
5508 PyObject * obj0 = 0 ;
5509 PyObject * obj1 = 0 ;
5510 PyObject * obj2 = 0 ;
5511 PyObject * obj3 = 0 ;
5512 PyObject * obj4 = 0 ;
5513 PyObject * obj5 = 0 ;
5514 PyObject * obj6 = 0 ;
5515 PyObject * obj7 = 0 ;
5516 PyObject * obj8 = 0 ;
5517 PyObject * obj9 = 0 ;
5518 PyObject * obj10 = 0 ;
5519 PyObject * obj11 = 0 ;
5520
5521 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5522 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5523 if (!SWIG_IsOK(res1)) {
5524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5525 }
5526 arg1 = (char *)(buf1);
5527 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5528 if (!SWIG_IsOK(res2)) {
5529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5530 }
5531 arg2 = (char *)(buf2);
5532 ecode3 = SWIG_AsVal_double(obj2, &val3);
5533 if (!SWIG_IsOK(ecode3)) {
5534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5535 }
5536 arg3 = (PLFLT)(val3);
5537 ecode4 = SWIG_AsVal_int(obj3, &val4);
5538 if (!SWIG_IsOK(ecode4)) {
5539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5540 }
5541 arg4 = (PLINT)(val4);
5542 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5543 if (!SWIG_IsOK(res5)) {
5544 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5545 }
5546 arg5 = (char *)(buf5);
5547 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5548 if (!SWIG_IsOK(res6)) {
5549 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5550 }
5551 arg6 = (char *)(buf6);
5552 ecode7 = SWIG_AsVal_double(obj6, &val7);
5553 if (!SWIG_IsOK(ecode7)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5555 }
5556 arg7 = (PLFLT)(val7);
5557 ecode8 = SWIG_AsVal_int(obj7, &val8);
5558 if (!SWIG_IsOK(ecode8)) {
5559 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5560 }
5561 arg8 = (PLINT)(val8);
5562 res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5563 if (!SWIG_IsOK(res9)) {
5564 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5565 }
5566 arg9 = (char *)(buf9);
5567 res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5568 if (!SWIG_IsOK(res10)) {
5569 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5570 }
5571 arg10 = (char *)(buf10);
5572 ecode11 = SWIG_AsVal_double(obj10, &val11);
5573 if (!SWIG_IsOK(ecode11)) {
5574 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5575 }
5576 arg11 = (PLFLT)(val11);
5577 ecode12 = SWIG_AsVal_int(obj11, &val12);
5578 if (!SWIG_IsOK(ecode12)) {
5579 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5580 }
5581 arg12 = (PLINT)(val12);
5582 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);
5583 resultobj = SWIG_Py_Void();
5584 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5585 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5586 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5587 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5588 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5589 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5590 return resultobj;
5591 fail:
5592 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5593 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5594 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5595 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5596 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5597 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5598 return NULL;
5599 }
5600
5601
5602 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5603 PyObject *resultobj = 0;
5604 PLFLT arg1 ;
5605 PLFLT arg2 ;
5606 PLFLT *arg3 = (PLFLT *) 0 ;
5607 PLFLT *arg4 = (PLFLT *) 0 ;
5608 PLINT *arg5 = (PLINT *) 0 ;
5609 double val1 ;
5610 int ecode1 = 0 ;
5611 double val2 ;
5612 int ecode2 = 0 ;
5613 PLFLT temp3 ;
5614 int res3 = SWIG_TMPOBJ ;
5615 PLFLT temp4 ;
5616 int res4 = SWIG_TMPOBJ ;
5617 PLINT temp5 ;
5618 int res5 = SWIG_TMPOBJ ;
5619 PyObject * obj0 = 0 ;
5620 PyObject * obj1 = 0 ;
5621
5622 arg3 = &temp3;
5623 arg4 = &temp4;
5624 arg5 = &temp5;
5625 if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5626 ecode1 = SWIG_AsVal_double(obj0, &val1);
5627 if (!SWIG_IsOK(ecode1)) {
5628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5629 }
5630 arg1 = (PLFLT)(val1);
5631 ecode2 = SWIG_AsVal_double(obj1, &val2);
5632 if (!SWIG_IsOK(ecode2)) {
5633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5634 }
5635 arg2 = (PLFLT)(val2);
5636 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5637 resultobj = SWIG_Py_Void();
5638 if (SWIG_IsTmpObj(res3)) {
5639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5640 } else {
5641 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5643 }
5644 if (SWIG_IsTmpObj(res4)) {
5645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5646 } else {
5647 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5649 }
5650 if (SWIG_IsTmpObj(res5)) {
5651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5652 } else {
5653 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5655 }
5656 return resultobj;
5657 fail:
5658 return NULL;
5659 }
5660
5661
5662 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5663 PyObject *resultobj = 0;
5664
5665 if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5666 plclear();
5667 resultobj = SWIG_Py_Void();
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675 PyObject *resultobj = 0;
5676 PLINT arg1 ;
5677 int val1 ;
5678 int ecode1 = 0 ;
5679 PyObject * obj0 = 0 ;
5680
5681 if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5682 ecode1 = SWIG_AsVal_int(obj0, &val1);
5683 if (!SWIG_IsOK(ecode1)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5685 }
5686 arg1 = (PLINT)(val1);
5687 plcol0(arg1);
5688 resultobj = SWIG_Py_Void();
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 PyObject *resultobj = 0;
5697 PLFLT arg1 ;
5698 double val1 ;
5699 int ecode1 = 0 ;
5700 PyObject * obj0 = 0 ;
5701
5702 if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5703 ecode1 = SWIG_AsVal_double(obj0, &val1);
5704 if (!SWIG_IsOK(ecode1)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5706 }
5707 arg1 = (PLFLT)(val1);
5708 plcol1(arg1);
5709 resultobj = SWIG_Py_Void();
5710 return resultobj;
5711 fail:
5712 return NULL;
5713 }
5714
5715
5716 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5717 PyObject *resultobj = 0;
5718 PLFLT arg1 ;
5719 PLFLT arg2 ;
5720 PLFLT arg3 ;
5721 PLINT arg4 ;
5722 PLBOOL arg5 ;
5723 PLINT arg6 ;
5724 PLINT arg7 ;
5725 PLINT arg8 ;
5726 PLINT arg9 ;
5727 PLINT arg10 ;
5728 PLFLT arg11 ;
5729 double val1 ;
5730 int ecode1 = 0 ;
5731 double val2 ;
5732 int ecode2 = 0 ;
5733 double val3 ;
5734 int ecode3 = 0 ;
5735 int val4 ;
5736 int ecode4 = 0 ;
5737 int val5 ;
5738 int ecode5 = 0 ;
5739 int val6 ;
5740 int ecode6 = 0 ;
5741 int val7 ;
5742 int ecode7 = 0 ;
5743 int val8 ;
5744 int ecode8 = 0 ;
5745 int val9 ;
5746 int ecode9 = 0 ;
5747 int val10 ;
5748 int ecode10 = 0 ;
5749 double val11 ;
5750 int ecode11 = 0 ;
5751 PyObject * obj0 = 0 ;
5752 PyObject * obj1 = 0 ;
5753 PyObject * obj2 = 0 ;
5754 PyObject * obj3 = 0 ;
5755 PyObject * obj4 = 0 ;
5756 PyObject * obj5 = 0 ;
5757 PyObject * obj6 = 0 ;
5758 PyObject * obj7 = 0 ;
5759 PyObject * obj8 = 0 ;
5760 PyObject * obj9 = 0 ;
5761 PyObject * obj10 = 0 ;
5762
5763 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5764 ecode1 = SWIG_AsVal_double(obj0, &val1);
5765 if (!SWIG_IsOK(ecode1)) {
5766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5767 }
5768 arg1 = (PLFLT)(val1);
5769 ecode2 = SWIG_AsVal_double(obj1, &val2);
5770 if (!SWIG_IsOK(ecode2)) {
5771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5772 }
5773 arg2 = (PLFLT)(val2);
5774 ecode3 = SWIG_AsVal_double(obj2, &val3);
5775 if (!SWIG_IsOK(ecode3)) {
5776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5777 }
5778 arg3 = (PLFLT)(val3);
5779 ecode4 = SWIG_AsVal_int(obj3, &val4);
5780 if (!SWIG_IsOK(ecode4)) {
5781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5782 }
5783 arg4 = (PLINT)(val4);
5784 ecode5 = SWIG_AsVal_int(obj4, &val5);
5785 if (!SWIG_IsOK(ecode5)) {
5786 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5787 }
5788 arg5 = (PLBOOL)(val5);
5789 ecode6 = SWIG_AsVal_int(obj5, &val6);
5790 if (!SWIG_IsOK(ecode6)) {
5791 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5792 }
5793 arg6 = (PLINT)(val6);
5794 ecode7 = SWIG_AsVal_int(obj6, &val7);
5795 if (!SWIG_IsOK(ecode7)) {
5796 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5797 }
5798 arg7 = (PLINT)(val7);
5799 ecode8 = SWIG_AsVal_int(obj7, &val8);
5800 if (!SWIG_IsOK(ecode8)) {
5801 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5802 }
5803 arg8 = (PLINT)(val8);
5804 ecode9 = SWIG_AsVal_int(obj8, &val9);
5805 if (!SWIG_IsOK(ecode9)) {
5806 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5807 }
5808 arg9 = (PLINT)(val9);
5809 ecode10 = SWIG_AsVal_int(obj9, &val10);
5810 if (!SWIG_IsOK(ecode10)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5812 }
5813 arg10 = (PLINT)(val10);
5814 ecode11 = SWIG_AsVal_double(obj10, &val11);
5815 if (!SWIG_IsOK(ecode11)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5817 }
5818 arg11 = (PLFLT)(val11);
5819 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5820 resultobj = SWIG_Py_Void();
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5828 PyObject *resultobj = 0;
5829 PLFLT **arg1 = (PLFLT **) 0 ;
5830 PLINT arg2 ;
5831 PLINT arg3 ;
5832 PLINT arg4 ;
5833 PLINT arg5 ;
5834 PLINT arg6 ;
5835 PLINT arg7 ;
5836 PLFLT *arg8 = (PLFLT *) 0 ;
5837 PLINT arg9 ;
5838 pltr_func arg10 = (pltr_func) 0 ;
5839 PLPointer arg11 = (PLPointer) 0 ;
5840 PyArrayObject *tmp1 = NULL ;
5841 int val4 ;
5842 int ecode4 = 0 ;
5843 int val5 ;
5844 int ecode5 = 0 ;
5845 int val6 ;
5846 int ecode6 = 0 ;
5847 int val7 ;
5848 int ecode7 = 0 ;
5849 PyArrayObject *tmp8 = NULL ;
5850 PyObject * obj0 = 0 ;
5851 PyObject * obj1 = 0 ;
5852 PyObject * obj2 = 0 ;
5853 PyObject * obj3 = 0 ;
5854 PyObject * obj4 = 0 ;
5855 PyObject * obj5 = 0 ;
5856 PyObject * obj6 = 0 ;
5857 PyObject * obj7 = 0 ;
5858
5859 {
5860 python_pltr = 0;
5861 arg10 = NULL;
5862 }
5863 {
5864 arg11 = NULL;
5865 }
5866 if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5867 {
5868 int i, size;
5869 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5870 if ( tmp1 == NULL )
5871 return NULL;
5872 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5873 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5874 size = arg3;
5875 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5876 for ( i = 0; i < arg2; i++ )
5877 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5878 }
5879 ecode4 = SWIG_AsVal_int(obj1, &val4);
5880 if (!SWIG_IsOK(ecode4)) {
5881 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5882 }
5883 arg4 = (PLINT)(val4);
5884 ecode5 = SWIG_AsVal_int(obj2, &val5);
5885 if (!SWIG_IsOK(ecode5)) {
5886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5887 }
5888 arg5 = (PLINT)(val5);
5889 ecode6 = SWIG_AsVal_int(obj3, &val6);
5890 if (!SWIG_IsOK(ecode6)) {
5891 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5892 }
5893 arg6 = (PLINT)(val6);
5894 ecode7 = SWIG_AsVal_int(obj4, &val7);
5895 if (!SWIG_IsOK(ecode7)) {
5896 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5897 }
5898 arg7 = (PLINT)(val7);
5899 {
5900 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5901 if ( tmp8 == NULL )
5902 return NULL;
5903 arg9 = PyArray_DIMS( tmp8 )[0];
5904 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5905 }
5906 if (obj6) {
5907 {
5908 // it must be a callable or None
5909 if ( obj6 == Py_None )
5910 {
5911 arg10 = NULL;
5912 }
5913 else
5914 {
5915 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5916 {
5917 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5918 return NULL;
5919 }
5920 arg10 = marshal_pltr( obj6 );
5921 }
5922 }
5923 }
5924 if (obj7) {
5925 {
5926 if ( obj7 == Py_None )
5927 arg11 = NULL;
5928 else
5929 {
5930 arg11 = marshal_PLPointer( obj7, 0 );
5931 }
5932 }
5933 }
5934 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5935 resultobj = SWIG_Py_Void();
5936 {
5937 Py_CLEAR( tmp1 );
5938 free( arg1 );
5939 }
5940 {
5941 Py_CLEAR( tmp8 );
5942 }
5943 {
5944 cleanup_pltr();
5945 }
5946 {
5947 cleanup_PLPointer();
5948 }
5949 return resultobj;
5950 fail:
5951 {
5952 Py_CLEAR( tmp1 );
5953 free( arg1 );
5954 }
5955 {
5956 Py_CLEAR( tmp8 );
5957 }
5958 {
5959 cleanup_pltr();
5960 }
5961 {
5962 cleanup_PLPointer();
5963 }
5964 return NULL;
5965 }
5966
5967
5968 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5969 PyObject *resultobj = 0;
5970 PLINT arg1 ;
5971 PLINT arg2 ;
5972 PLINT arg3 ;
5973 PLINT arg4 ;
5974 PLINT arg5 ;
5975 PLFLT arg6 ;
5976 PLFLT *arg7 = (PLFLT *) 0 ;
5977 int val1 ;
5978 int ecode1 = 0 ;
5979 int val2 ;
5980 int ecode2 = 0 ;
5981 int val3 ;
5982 int ecode3 = 0 ;
5983 int val4 ;
5984 int ecode4 = 0 ;
5985 int val5 ;
5986 int ecode5 = 0 ;
5987 double val6 ;
5988 int ecode6 = 0 ;
5989 PLFLT temp7 ;
5990 int res7 = SWIG_TMPOBJ ;
5991 PyObject * obj0 = 0 ;
5992 PyObject * obj1 = 0 ;
5993 PyObject * obj2 = 0 ;
5994 PyObject * obj3 = 0 ;
5995 PyObject * obj4 = 0 ;
5996 PyObject * obj5 = 0 ;
5997
5998 arg7 = &temp7;
5999 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6000 ecode1 = SWIG_AsVal_int(obj0, &val1);
6001 if (!SWIG_IsOK(ecode1)) {
6002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6003 }
6004 arg1 = (PLINT)(val1);
6005 ecode2 = SWIG_AsVal_int(obj1, &val2);
6006 if (!SWIG_IsOK(ecode2)) {
6007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6008 }
6009 arg2 = (PLINT)(val2);
6010 ecode3 = SWIG_AsVal_int(obj2, &val3);
6011 if (!SWIG_IsOK(ecode3)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6013 }
6014 arg3 = (PLINT)(val3);
6015 ecode4 = SWIG_AsVal_int(obj3, &val4);
6016 if (!SWIG_IsOK(ecode4)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6018 }
6019 arg4 = (PLINT)(val4);
6020 ecode5 = SWIG_AsVal_int(obj4, &val5);
6021 if (!SWIG_IsOK(ecode5)) {
6022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6023 }
6024 arg5 = (PLINT)(val5);
6025 ecode6 = SWIG_AsVal_double(obj5, &val6);
6026 if (!SWIG_IsOK(ecode6)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6028 }
6029 arg6 = (PLFLT)(val6);
6030 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6031 resultobj = SWIG_Py_Void();
6032 if (SWIG_IsTmpObj(res7)) {
6033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6034 } else {
6035 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6037 }
6038 return resultobj;
6039 fail:
6040 return NULL;
6041 }
6042
6043
6044 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6045 PyObject *resultobj = 0;
6046 PLINT arg1 ;
6047 PLBOOL arg2 ;
6048 int val1 ;
6049 int ecode1 = 0 ;
6050 int val2 ;
6051 int ecode2 = 0 ;
6052 PyObject * obj0 = 0 ;
6053 PyObject * obj1 = 0 ;
6054
6055 if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
6056 ecode1 = SWIG_AsVal_int(obj0, &val1);
6057 if (!SWIG_IsOK(ecode1)) {
6058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6059 }
6060 arg1 = (PLINT)(val1);
6061 ecode2 = SWIG_AsVal_int(obj1, &val2);
6062 if (!SWIG_IsOK(ecode2)) {
6063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6064 }
6065 arg2 = (PLBOOL)(val2);
6066 plcpstrm(arg1,arg2);
6067 resultobj = SWIG_Py_Void();
6068 return resultobj;
6069 fail:
6070 return NULL;
6071 }
6072
6073
6074 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6075 PyObject *resultobj = 0;
6076
6077 if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
6078 plend();
6079 resultobj = SWIG_Py_Void();
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6087 PyObject *resultobj = 0;
6088
6089 if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
6090 plend1();
6091 resultobj = SWIG_Py_Void();
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6099 PyObject *resultobj = 0;
6100 PLFLT arg1 ;
6101 PLFLT arg2 ;
6102 PLFLT arg3 ;
6103 PLFLT arg4 ;
6104 PLINT arg5 ;
6105 PLINT arg6 ;
6106 double val1 ;
6107 int ecode1 = 0 ;
6108 double val2 ;
6109 int ecode2 = 0 ;
6110 double val3 ;
6111 int ecode3 = 0 ;
6112 double val4 ;
6113 int ecode4 = 0 ;
6114 int val5 ;
6115 int ecode5 = 0 ;
6116 int val6 ;
6117 int ecode6 = 0 ;
6118 PyObject * obj0 = 0 ;
6119 PyObject * obj1 = 0 ;
6120 PyObject * obj2 = 0 ;
6121 PyObject * obj3 = 0 ;
6122 PyObject * obj4 = 0 ;
6123 PyObject * obj5 = 0 ;
6124
6125 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6126 ecode1 = SWIG_AsVal_double(obj0, &val1);
6127 if (!SWIG_IsOK(ecode1)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6129 }
6130 arg1 = (PLFLT)(val1);
6131 ecode2 = SWIG_AsVal_double(obj1, &val2);
6132 if (!SWIG_IsOK(ecode2)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6134 }
6135 arg2 = (PLFLT)(val2);
6136 ecode3 = SWIG_AsVal_double(obj2, &val3);
6137 if (!SWIG_IsOK(ecode3)) {
6138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6139 }
6140 arg3 = (PLFLT)(val3);
6141 ecode4 = SWIG_AsVal_double(obj3, &val4);
6142 if (!SWIG_IsOK(ecode4)) {
6143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6144 }
6145 arg4 = (PLFLT)(val4);
6146 ecode5 = SWIG_AsVal_int(obj4, &val5);
6147 if (!SWIG_IsOK(ecode5)) {
6148 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6149 }
6150 arg5 = (PLINT)(val5);
6151 ecode6 = SWIG_AsVal_int(obj5, &val6);
6152 if (!SWIG_IsOK(ecode6)) {
6153 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6154 }
6155 arg6 = (PLINT)(val6);
6156 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6157 resultobj = SWIG_Py_Void();
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6165 PyObject *resultobj = 0;
6166 PLFLT arg1 ;
6167 PLFLT arg2 ;
6168 PLFLT arg3 ;
6169 PLFLT arg4 ;
6170 PLINT arg5 ;
6171 PLINT arg6 ;
6172 double val1 ;
6173 int ecode1 = 0 ;
6174 double val2 ;
6175 int ecode2 = 0 ;
6176 double val3 ;
6177 int ecode3 = 0 ;
6178 double val4 ;
6179 int ecode4 = 0 ;
6180 int val5 ;
6181 int ecode5 = 0 ;
6182 int val6 ;
6183 int ecode6 = 0 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 PyObject * obj2 = 0 ;
6187 PyObject * obj3 = 0 ;
6188 PyObject * obj4 = 0 ;
6189 PyObject * obj5 = 0 ;
6190
6191 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6192 ecode1 = SWIG_AsVal_double(obj0, &val1);
6193 if (!SWIG_IsOK(ecode1)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6195 }
6196 arg1 = (PLFLT)(val1);
6197 ecode2 = SWIG_AsVal_double(obj1, &val2);
6198 if (!SWIG_IsOK(ecode2)) {
6199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6200 }
6201 arg2 = (PLFLT)(val2);
6202 ecode3 = SWIG_AsVal_double(obj2, &val3);
6203 if (!SWIG_IsOK(ecode3)) {
6204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6205 }
6206 arg3 = (PLFLT)(val3);
6207 ecode4 = SWIG_AsVal_double(obj3, &val4);
6208 if (!SWIG_IsOK(ecode4)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6210 }
6211 arg4 = (PLFLT)(val4);
6212 ecode5 = SWIG_AsVal_int(obj4, &val5);
6213 if (!SWIG_IsOK(ecode5)) {
6214 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6215 }
6216 arg5 = (PLINT)(val5);
6217 ecode6 = SWIG_AsVal_int(obj5, &val6);
6218 if (!SWIG_IsOK(ecode6)) {
6219 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6220 }
6221 arg6 = (PLINT)(val6);
6222 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6223 resultobj = SWIG_Py_Void();
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6231 PyObject *resultobj = 0;
6232
6233 if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6234 pleop();
6235 resultobj = SWIG_Py_Void();
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6243 PyObject *resultobj = 0;
6244 PLINT arg1 ;
6245 PLFLT *arg2 = (PLFLT *) 0 ;
6246 PLFLT *arg3 = (PLFLT *) 0 ;
6247 PLFLT *arg4 = (PLFLT *) 0 ;
6248 PyArrayObject *tmp1 = NULL ;
6249 PyArrayObject *tmp3 = NULL ;
6250 PyArrayObject *tmp4 = NULL ;
6251 PyObject * obj0 = 0 ;
6252 PyObject * obj1 = 0 ;
6253 PyObject * obj2 = 0 ;
6254
6255 if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6256 {
6257 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6258 if ( tmp1 == NULL )
6259 return NULL;
6260 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6261 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6262 }
6263 {
6264 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6265 if ( tmp3 == NULL )
6266 return NULL;
6267 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6268 {
6269 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6270 return NULL;
6271 }
6272 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6273 }
6274 {
6275 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6276 if ( tmp4 == NULL )
6277 return NULL;
6278 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6279 {
6280 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6281 return NULL;
6282 }
6283 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6284 }
6285 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6286 resultobj = SWIG_Py_Void();
6287 {
6288 Py_CLEAR( tmp1 );
6289 }
6290 {
6291 Py_CLEAR( tmp3 );
6292 }
6293 {
6294 Py_CLEAR( tmp4 );
6295 }
6296 return resultobj;
6297 fail:
6298 {
6299 Py_CLEAR( tmp1 );
6300 }
6301 {
6302 Py_CLEAR( tmp3 );
6303 }
6304 {
6305 Py_CLEAR( tmp4 );
6306 }
6307 return NULL;
6308 }
6309
6310
6311 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6312 PyObject *resultobj = 0;
6313 PLINT arg1 ;
6314 PLFLT *arg2 = (PLFLT *) 0 ;
6315 PLFLT *arg3 = (PLFLT *) 0 ;
6316 PLFLT *arg4 = (PLFLT *) 0 ;
6317 PyArrayObject *tmp1 = NULL ;
6318 PyArrayObject *tmp3 = NULL ;
6319 PyArrayObject *tmp4 = NULL ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 PyObject * obj2 = 0 ;
6323
6324 if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6325 {
6326 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6327 if ( tmp1 == NULL )
6328 return NULL;
6329 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6330 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6331 }
6332 {
6333 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6334 if ( tmp3 == NULL )
6335 return NULL;
6336 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6337 {
6338 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6339 return NULL;
6340 }
6341 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6342 }
6343 {
6344 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6345 if ( tmp4 == NULL )
6346 return NULL;
6347 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6348 {
6349 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6350 return NULL;
6351 }
6352 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6353 }
6354 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6355 resultobj = SWIG_Py_Void();
6356 {
6357 Py_CLEAR( tmp1 );
6358 }
6359 {
6360 Py_CLEAR( tmp3 );
6361 }
6362 {
6363 Py_CLEAR( tmp4 );
6364 }
6365 return resultobj;
6366 fail:
6367 {
6368 Py_CLEAR( tmp1 );
6369 }
6370 {
6371 Py_CLEAR( tmp3 );
6372 }
6373 {
6374 Py_CLEAR( tmp4 );
6375 }
6376 return NULL;
6377 }
6378
6379
6380 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6381 PyObject *resultobj = 0;
6382
6383 if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6384 plfamadv();
6385 resultobj = SWIG_Py_Void();
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6393 PyObject *resultobj = 0;
6394 PLINT arg1 ;
6395 PLFLT *arg2 = (PLFLT *) 0 ;
6396 PLFLT *arg3 = (PLFLT *) 0 ;
6397 PyArrayObject *tmp1 = NULL ;
6398 PyArrayObject *tmp3 = NULL ;
6399 PyObject * obj0 = 0 ;
6400 PyObject * obj1 = 0 ;
6401
6402 if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6403 {
6404 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6405 if ( tmp1 == NULL )
6406 return NULL;
6407 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6408 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6409 }
6410 {
6411 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6412 if ( tmp3 == NULL )
6413 return NULL;
6414 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6415 {
6416 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6417 return NULL;
6418 }
6419 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6420 }
6421 plfill(arg1,(double const *)arg2,(double const *)arg3);
6422 resultobj = SWIG_Py_Void();
6423 {
6424 Py_CLEAR( tmp1 );
6425 }
6426 {
6427 Py_CLEAR( tmp3 );
6428 }
6429 return resultobj;
6430 fail:
6431 {
6432 Py_CLEAR( tmp1 );
6433 }
6434 {
6435 Py_CLEAR( tmp3 );
6436 }
6437 return NULL;
6438 }
6439
6440
6441 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6442 PyObject *resultobj = 0;
6443 PLINT arg1 ;
6444 PLFLT *arg2 = (PLFLT *) 0 ;
6445 PLFLT *arg3 = (PLFLT *) 0 ;
6446 PLFLT *arg4 = (PLFLT *) 0 ;
6447 PyArrayObject *tmp1 = NULL ;
6448 PyArrayObject *tmp3 = NULL ;
6449 PyArrayObject *tmp4 = NULL ;
6450 PyObject * obj0 = 0 ;
6451 PyObject * obj1 = 0 ;
6452 PyObject * obj2 = 0 ;
6453
6454 if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6455 {
6456 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6457 if ( tmp1 == NULL )
6458 return NULL;
6459 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6460 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6461 }
6462 {
6463 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6464 if ( tmp3 == NULL )
6465 return NULL;
6466 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6467 {
6468 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6469 return NULL;
6470 }
6471 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6472 }
6473 {
6474 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6475 if ( tmp4 == NULL )
6476 return NULL;
6477 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6478 {
6479 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6480 return NULL;
6481 }
6482 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6483 }
6484 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6485 resultobj = SWIG_Py_Void();
6486 {
6487 Py_CLEAR( tmp1 );
6488 }
6489 {
6490 Py_CLEAR( tmp3 );
6491 }
6492 {
6493 Py_CLEAR( tmp4 );
6494 }
6495 return resultobj;
6496 fail:
6497 {
6498 Py_CLEAR( tmp1 );
6499 }
6500 {
6501 Py_CLEAR( tmp3 );
6502 }
6503 {
6504 Py_CLEAR( tmp4 );
6505 }
6506 return NULL;
6507 }
6508
6509
6510 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6511 PyObject *resultobj = 0;
6512 PLINT arg1 ;
6513 PLFLT *arg2 = (PLFLT *) 0 ;
6514 PLFLT *arg3 = (PLFLT *) 0 ;
6515 PLFLT arg4 ;
6516 PyArrayObject *tmp1 = NULL ;
6517 PyArrayObject *tmp3 = NULL ;
6518 double val4 ;
6519 int ecode4 = 0 ;
6520 PyObject * obj0 = 0 ;
6521 PyObject * obj1 = 0 ;
6522 PyObject * obj2 = 0 ;
6523
6524 if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6525 {
6526 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6527 if ( tmp1 == NULL )
6528 return NULL;
6529 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6530 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6531 }
6532 {
6533 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6534 if ( tmp3 == NULL )
6535 return NULL;
6536 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6537 {
6538 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6539 return NULL;
6540 }
6541 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6542 }
6543 ecode4 = SWIG_AsVal_double(obj2, &val4);
6544 if (!SWIG_IsOK(ecode4)) {
6545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6546 }
6547 arg4 = (PLFLT)(val4);
6548 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6549 resultobj = SWIG_Py_Void();
6550 {
6551 Py_CLEAR( tmp1 );
6552 }
6553 {
6554 Py_CLEAR( tmp3 );
6555 }
6556 return resultobj;
6557 fail:
6558 {
6559 Py_CLEAR( tmp1 );
6560 }
6561 {
6562 Py_CLEAR( tmp3 );
6563 }
6564 return NULL;
6565 }
6566
6567
6568 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6569 PyObject *resultobj = 0;
6570
6571 if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6572 plflush();
6573 resultobj = SWIG_Py_Void();
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6581 PyObject *resultobj = 0;
6582 PLINT arg1 ;
6583 int val1 ;
6584 int ecode1 = 0 ;
6585 PyObject * obj0 = 0 ;
6586
6587 if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6588 ecode1 = SWIG_AsVal_int(obj0, &val1);
6589 if (!SWIG_IsOK(ecode1)) {
6590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6591 }
6592 arg1 = (PLINT)(val1);
6593 plfont(arg1);
6594 resultobj = SWIG_Py_Void();
6595 return resultobj;
6596 fail:
6597 return NULL;
6598 }
6599
6600
6601 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6602 PyObject *resultobj = 0;
6603 PLINT arg1 ;
6604 int val1 ;
6605 int ecode1 = 0 ;
6606 PyObject * obj0 = 0 ;
6607
6608 if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6609 ecode1 = SWIG_AsVal_int(obj0, &val1);
6610 if (!SWIG_IsOK(ecode1)) {
6611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6612 }
6613 arg1 = (PLINT)(val1);
6614 plfontld(arg1);
6615 resultobj = SWIG_Py_Void();
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 PLFLT *arg1 = (PLFLT *) 0 ;
6625 PLFLT *arg2 = (PLFLT *) 0 ;
6626 PLFLT temp1 ;
6627 int res1 = SWIG_TMPOBJ ;
6628 PLFLT temp2 ;
6629 int res2 = SWIG_TMPOBJ ;
6630
6631 arg1 = &temp1;
6632 arg2 = &temp2;
6633 if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6634 plgchr(arg1,arg2);
6635 resultobj = SWIG_Py_Void();
6636 if (SWIG_IsTmpObj(res1)) {
6637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6638 } else {
6639 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6641 }
6642 if (SWIG_IsTmpObj(res2)) {
6643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6644 } else {
6645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6647 }
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6655 PyObject *resultobj = 0;
6656 PLINT arg1 ;
6657 PLINT *arg2 = (PLINT *) 0 ;
6658 PLINT *arg3 = (PLINT *) 0 ;
6659 PLINT *arg4 = (PLINT *) 0 ;
6660 int val1 ;
6661 int ecode1 = 0 ;
6662 PLINT temp2 ;
6663 int res2 = SWIG_TMPOBJ ;
6664 PLINT temp3 ;
6665 int res3 = SWIG_TMPOBJ ;
6666 PLINT temp4 ;
6667 int res4 = SWIG_TMPOBJ ;
6668 PyObject * obj0 = 0 ;
6669
6670 arg2 = &temp2;
6671 arg3 = &temp3;
6672 arg4 = &temp4;
6673 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6674 ecode1 = SWIG_AsVal_int(obj0, &val1);
6675 if (!SWIG_IsOK(ecode1)) {
6676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6677 }
6678 arg1 = (PLINT)(val1);
6679 plgcol0(arg1,arg2,arg3,arg4);
6680 resultobj = SWIG_Py_Void();
6681 if (SWIG_IsTmpObj(res2)) {
6682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6683 } else {
6684 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6686 }
6687 if (SWIG_IsTmpObj(res3)) {
6688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6689 } else {
6690 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6692 }
6693 if (SWIG_IsTmpObj(res4)) {
6694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6695 } else {
6696 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6706 PyObject *resultobj = 0;
6707 PLINT arg1 ;
6708 PLINT *arg2 = (PLINT *) 0 ;
6709 PLINT *arg3 = (PLINT *) 0 ;
6710 PLINT *arg4 = (PLINT *) 0 ;
6711 PLFLT *arg5 = (PLFLT *) 0 ;
6712 int val1 ;
6713 int ecode1 = 0 ;
6714 PLINT temp2 ;
6715 int res2 = SWIG_TMPOBJ ;
6716 PLINT temp3 ;
6717 int res3 = SWIG_TMPOBJ ;
6718 PLINT temp4 ;
6719 int res4 = SWIG_TMPOBJ ;
6720 PLFLT temp5 ;
6721 int res5 = SWIG_TMPOBJ ;
6722 PyObject * obj0 = 0 ;
6723
6724 arg2 = &temp2;
6725 arg3 = &temp3;
6726 arg4 = &temp4;
6727 arg5 = &temp5;
6728 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6729 ecode1 = SWIG_AsVal_int(obj0, &val1);
6730 if (!SWIG_IsOK(ecode1)) {
6731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6732 }
6733 arg1 = (PLINT)(val1);
6734 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6735 resultobj = SWIG_Py_Void();
6736 if (SWIG_IsTmpObj(res2)) {
6737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6738 } else {
6739 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6741 }
6742 if (SWIG_IsTmpObj(res3)) {
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6744 } else {
6745 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6747 }
6748 if (SWIG_IsTmpObj(res4)) {
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6750 } else {
6751 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6753 }
6754 if (SWIG_IsTmpObj(res5)) {
6755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6756 } else {
6757 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6759 }
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 PLINT *arg1 = (PLINT *) 0 ;
6769 PLINT *arg2 = (PLINT *) 0 ;
6770 PLINT *arg3 = (PLINT *) 0 ;
6771 PLINT temp1 ;
6772 int res1 = SWIG_TMPOBJ ;
6773 PLINT temp2 ;
6774 int res2 = SWIG_TMPOBJ ;
6775 PLINT temp3 ;
6776 int res3 = SWIG_TMPOBJ ;
6777
6778 arg1 = &temp1;
6779 arg2 = &temp2;
6780 arg3 = &temp3;
6781 if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6782 plgcolbg(arg1,arg2,arg3);
6783 resultobj = SWIG_Py_Void();
6784 if (SWIG_IsTmpObj(res1)) {
6785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6786 } else {
6787 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6789 }
6790 if (SWIG_IsTmpObj(res2)) {
6791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6792 } else {
6793 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6795 }
6796 if (SWIG_IsTmpObj(res3)) {
6797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6798 } else {
6799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6801 }
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6809 PyObject *resultobj = 0;
6810 PLINT *arg1 = (PLINT *) 0 ;
6811 PLINT *arg2 = (PLINT *) 0 ;
6812 PLINT *arg3 = (PLINT *) 0 ;
6813 PLFLT *arg4 = (PLFLT *) 0 ;
6814 PLINT temp1 ;
6815 int res1 = SWIG_TMPOBJ ;
6816 PLINT temp2 ;
6817 int res2 = SWIG_TMPOBJ ;
6818 PLINT temp3 ;
6819 int res3 = SWIG_TMPOBJ ;
6820 PLFLT temp4 ;
6821 int res4 = SWIG_TMPOBJ ;
6822
6823 arg1 = &temp1;
6824 arg2 = &temp2;
6825 arg3 = &temp3;
6826 arg4 = &temp4;
6827 if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6828 plgcolbga(arg1,arg2,arg3,arg4);
6829 resultobj = SWIG_Py_Void();
6830 if (SWIG_IsTmpObj(res1)) {
6831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6832 } else {
6833 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6835 }
6836 if (SWIG_IsTmpObj(res2)) {
6837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6838 } else {
6839 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6841 }
6842 if (SWIG_IsTmpObj(res3)) {
6843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6844 } else {
6845 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6847 }
6848 if (SWIG_IsTmpObj(res4)) {
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6850 } else {
6851 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6853 }
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 PLINT *arg1 = (PLINT *) 0 ;
6863 PLINT temp1 ;
6864 int res1 = SWIG_TMPOBJ ;
6865
6866 arg1 = &temp1;
6867 if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6868 plgcompression(arg1);
6869 resultobj = SWIG_Py_Void();
6870 if (SWIG_IsTmpObj(res1)) {
6871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6872 } else {
6873 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6875 }
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 char *arg1 = (char *) 0 ;
6885 char buff1[1000] ;
6886
6887 {
6888 arg1 = buff1;
6889 }
6890 if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6891 plgdev(arg1);
6892 resultobj = SWIG_Py_Void();
6893 {
6894 PyObject *o = PyString_FromString( arg1 );
6895 resultobj = t_output_helper( resultobj, o );
6896 }
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 PLFLT *arg1 = (PLFLT *) 0 ;
6906 PLFLT *arg2 = (PLFLT *) 0 ;
6907 PLFLT *arg3 = (PLFLT *) 0 ;
6908 PLFLT *arg4 = (PLFLT *) 0 ;
6909 PLFLT temp1 ;
6910 int res1 = SWIG_TMPOBJ ;
6911 PLFLT temp2 ;
6912 int res2 = SWIG_TMPOBJ ;
6913 PLFLT temp3 ;
6914 int res3 = SWIG_TMPOBJ ;
6915 PLFLT temp4 ;
6916 int res4 = SWIG_TMPOBJ ;
6917
6918 arg1 = &temp1;
6919 arg2 = &temp2;
6920 arg3 = &temp3;
6921 arg4 = &temp4;
6922 if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6923 plgdidev(arg1,arg2,arg3,arg4);
6924 resultobj = SWIG_Py_Void();
6925 if (SWIG_IsTmpObj(res1)) {
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6927 } else {
6928 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6930 }
6931 if (SWIG_IsTmpObj(res2)) {
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6933 } else {
6934 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6936 }
6937 if (SWIG_IsTmpObj(res3)) {
6938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6939 } else {
6940 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6942 }
6943 if (SWIG_IsTmpObj(res4)) {
6944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6945 } else {
6946 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6956 PyObject *resultobj = 0;
6957 PLFLT *arg1 = (PLFLT *) 0 ;
6958 PLFLT temp1 ;
6959 int res1 = SWIG_TMPOBJ ;
6960
6961 arg1 = &temp1;
6962 if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6963 plgdiori(arg1);
6964 resultobj = SWIG_Py_Void();
6965 if (SWIG_IsTmpObj(res1)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6970 }
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6978 PyObject *resultobj = 0;
6979 PLFLT *arg1 = (PLFLT *) 0 ;
6980 PLFLT *arg2 = (PLFLT *) 0 ;
6981 PLFLT *arg3 = (PLFLT *) 0 ;
6982 PLFLT *arg4 = (PLFLT *) 0 ;
6983 PLFLT temp1 ;
6984 int res1 = SWIG_TMPOBJ ;
6985 PLFLT temp2 ;
6986 int res2 = SWIG_TMPOBJ ;
6987 PLFLT temp3 ;
6988 int res3 = SWIG_TMPOBJ ;
6989 PLFLT temp4 ;
6990 int res4 = SWIG_TMPOBJ ;
6991
6992 arg1 = &temp1;
6993 arg2 = &temp2;
6994 arg3 = &temp3;
6995 arg4 = &temp4;
6996 if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6997 plgdiplt(arg1,arg2,arg3,arg4);
6998 resultobj = SWIG_Py_Void();
6999 if (SWIG_IsTmpObj(res1)) {
7000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7001 } else {
7002 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7004 }
7005 if (SWIG_IsTmpObj(res2)) {
7006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7007 } else {
7008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7010 }
7011 if (SWIG_IsTmpObj(res3)) {
7012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7013 } else {
7014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7016 }
7017 if (SWIG_IsTmpObj(res4)) {
7018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7019 } else {
7020 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7022 }
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7030 PyObject *resultobj = 0;
7031 PLINT *arg1 = (PLINT *) 0 ;
7032 PLINT *arg2 = (PLINT *) 0 ;
7033 PLINT *arg3 = (PLINT *) 0 ;
7034 PLINT temp1 ;
7035 int res1 = SWIG_TMPOBJ ;
7036 PLINT temp2 ;
7037 int res2 = SWIG_TMPOBJ ;
7038 PLINT temp3 ;
7039 int res3 = SWIG_TMPOBJ ;
7040
7041 arg1 = &temp1;
7042 arg2 = &temp2;
7043 arg3 = &temp3;
7044 if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
7045 plgfam(arg1,arg2,arg3);
7046 resultobj = SWIG_Py_Void();
7047 if (SWIG_IsTmpObj(res1)) {
7048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7049 } else {
7050 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7052 }
7053 if (SWIG_IsTmpObj(res2)) {
7054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7055 } else {
7056 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7058 }
7059 if (SWIG_IsTmpObj(res3)) {
7060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7061 } else {
7062 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7063 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7064 }
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7072 PyObject *resultobj = 0;
7073 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7074 PLUNICODE temp1 ;
7075 int res1 = SWIG_TMPOBJ ;
7076
7077 arg1 = &temp1;
7078 if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
7079 plgfci(arg1);
7080 resultobj = SWIG_Py_Void();
7081 if (SWIG_IsTmpObj(res1)) {
7082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7083 } else {
7084 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7086 }
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7094 PyObject *resultobj = 0;
7095 char *arg1 = (char *) 0 ;
7096 char buff1[1000] ;
7097
7098 {
7099 arg1 = buff1;
7100 }
7101 if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
7102 plgfnam(arg1);
7103 resultobj = SWIG_Py_Void();
7104 {
7105 PyObject *o = PyString_FromString( arg1 );
7106 resultobj = t_output_helper( resultobj, o );
7107 }
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7115 PyObject *resultobj = 0;
7116 PLINT *arg1 = (PLINT *) 0 ;
7117 PLINT *arg2 = (PLINT *) 0 ;
7118 PLINT *arg3 = (PLINT *) 0 ;
7119 PLINT temp1 ;
7120 int res1 = SWIG_TMPOBJ ;
7121 PLINT temp2 ;
7122 int res2 = SWIG_TMPOBJ ;
7123 PLINT temp3 ;
7124 int res3 = SWIG_TMPOBJ ;
7125
7126 arg1 = &temp1;
7127 arg2 = &temp2;
7128 arg3 = &temp3;
7129 if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
7130 plgfont(arg1,arg2,arg3);
7131 resultobj = SWIG_Py_Void();
7132 if (SWIG_IsTmpObj(res1)) {
7133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7134 } else {
7135 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7137 }
7138 if (SWIG_IsTmpObj(res2)) {
7139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7140 } else {
7141 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7143 }
7144 if (SWIG_IsTmpObj(res3)) {
7145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7146 } else {
7147 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7157 PyObject *resultobj = 0;
7158 PLINT *arg1 = (PLINT *) 0 ;
7159 PLINT temp1 ;
7160 int res1 = SWIG_TMPOBJ ;
7161
7162 arg1 = &temp1;
7163 if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7164 plglevel(arg1);
7165 resultobj = SWIG_Py_Void();
7166 if (SWIG_IsTmpObj(res1)) {
7167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7168 } else {
7169 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7171 }
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7179 PyObject *resultobj = 0;
7180 PLFLT *arg1 = (PLFLT *) 0 ;
7181 PLFLT *arg2 = (PLFLT *) 0 ;
7182 PLINT *arg3 = (PLINT *) 0 ;
7183 PLINT *arg4 = (PLINT *) 0 ;
7184 PLINT *arg5 = (PLINT *) 0 ;
7185 PLINT *arg6 = (PLINT *) 0 ;
7186 PLFLT temp1 ;
7187 int res1 = SWIG_TMPOBJ ;
7188 PLFLT temp2 ;
7189 int res2 = SWIG_TMPOBJ ;
7190 PLINT temp3 ;
7191 int res3 = SWIG_TMPOBJ ;
7192 PLINT temp4 ;
7193 int res4 = SWIG_TMPOBJ ;
7194 PLINT temp5 ;
7195 int res5 = SWIG_TMPOBJ ;
7196 PLINT temp6 ;
7197 int res6 = SWIG_TMPOBJ ;
7198
7199 arg1 = &temp1;
7200 arg2 = &temp2;
7201 arg3 = &temp3;
7202 arg4 = &temp4;
7203 arg5 = &temp5;
7204 arg6 = &temp6;
7205 if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7206 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7207 resultobj = SWIG_Py_Void();
7208 if (SWIG_IsTmpObj(res1)) {
7209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7210 } else {
7211 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7213 }
7214 if (SWIG_IsTmpObj(res2)) {
7215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7216 } else {
7217 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7219 }
7220 if (SWIG_IsTmpObj(res3)) {
7221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7222 } else {
7223 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7225 }
7226 if (SWIG_IsTmpObj(res4)) {
7227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7228 } else {
7229 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7231 }
7232 if (SWIG_IsTmpObj(res5)) {
7233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7234 } else {
7235 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7237 }
7238 if (SWIG_IsTmpObj(res6)) {
7239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7240 } else {
7241 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7243 }
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 PyObject *resultobj = 0;
7252
7253 if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7254 plgra();
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7263 PyObject *resultobj = 0;
7264 PLFLT *arg1 = (PLFLT *) 0 ;
7265 PLFLT *arg2 = (PLFLT *) 0 ;
7266 PLFLT *arg3 = (PLFLT *) 0 ;
7267 PLINT arg4 ;
7268 PLFLT *arg5 = (PLFLT *) 0 ;
7269 PLINT arg6 ;
7270 PLFLT *arg7 = (PLFLT *) 0 ;
7271 PLINT arg8 ;
7272 PLFLT **arg9 = (PLFLT **) 0 ;
7273 PLINT arg10 ;
7274 PLFLT arg11 ;
7275 PyArrayObject *tmp1 = NULL ;
7276 PyArrayObject *tmp2 = NULL ;
7277 PyArrayObject *tmp3 = NULL ;
7278 PyArrayObject *tmp5 = NULL ;
7279 PyArrayObject *tmp7 = NULL ;
7280 PyObject *array7 = NULL ;
7281 int val10 ;
7282 int ecode10 = 0 ;
7283 double val11 ;
7284 int ecode11 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 PyObject * obj2 = 0 ;
7288 PyObject * obj3 = 0 ;
7289 PyObject * obj4 = 0 ;
7290 PyObject * obj5 = 0 ;
7291 PyObject * obj6 = 0 ;
7292
7293 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7294 {
7295 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7296 if ( tmp1 == NULL )
7297 return NULL;
7298 Alen = PyArray_DIMS( tmp1 )[0];
7299 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7300 }
7301 {
7302 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7303 if ( tmp2 == NULL )
7304 return NULL;
7305 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7306 {
7307 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7308 return NULL;
7309 }
7310 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7311 }
7312 {
7313 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7314 if ( tmp3 == NULL )
7315 return NULL;
7316 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7317 {
7318 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7319 return NULL;
7320 }
7321 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7322 arg4 = PyArray_DIMS( tmp3 )[0];
7323 }
7324 {
7325 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7326 if ( tmp5 == NULL )
7327 return NULL;
7328 Xlen = PyArray_DIMS( tmp5 )[0];
7329 arg6 = Xlen;
7330 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7331 }
7332 {
7333 int i, size;
7334 npy_intp dims[2];
7335 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7336 if ( tmp7 == NULL )
7337 return NULL;
7338 Ylen = PyArray_DIMS( tmp7 )[0];
7339 arg8 = Ylen;
7340 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7341 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7342 // list and this ArrayY.
7343 dims[0] = Xlen;
7344 dims[1] = Ylen;
7345 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7346 if ( !array7 )
7347 return NULL;
7348 size = Ylen;
7349 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7350 for ( i = 0; i < Xlen; i++ )
7351 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7352 }
7353 ecode10 = SWIG_AsVal_int(obj5, &val10);
7354 if (!SWIG_IsOK(ecode10)) {
7355 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7356 }
7357 arg10 = (PLINT)(val10);
7358 ecode11 = SWIG_AsVal_double(obj6, &val11);
7359 if (!SWIG_IsOK(ecode11)) {
7360 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7361 }
7362 arg11 = (PLFLT)(val11);
7363 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7364 resultobj = SWIG_Py_Void();
7365 {
7366 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7367 }
7368 {
7369 Py_CLEAR( tmp1 );
7370 }
7371 {
7372 Py_CLEAR( tmp2 );
7373 }
7374 {
7375 Py_CLEAR( tmp3 );
7376 }
7377 {
7378 Py_CLEAR( tmp5 );
7379 }
7380 {
7381 Py_CLEAR( tmp7 );
7382 free( arg9 );
7383 }
7384 return resultobj;
7385 fail:
7386 {
7387 Py_CLEAR( tmp1 );
7388 }
7389 {
7390 Py_CLEAR( tmp2 );
7391 }
7392 {
7393 Py_CLEAR( tmp3 );
7394 }
7395 {
7396 Py_CLEAR( tmp5 );
7397 }
7398 {
7399 Py_CLEAR( tmp7 );
7400 free( arg9 );
7401 }
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 PLFLT *arg1 = (PLFLT *) 0 ;
7409 PLFLT *arg2 = (PLFLT *) 0 ;
7410 PLFLT *arg3 = (PLFLT *) 0 ;
7411 PLFLT *arg4 = (PLFLT *) 0 ;
7412 PLFLT temp1 ;
7413 int res1 = SWIG_TMPOBJ ;
7414 PLFLT temp2 ;
7415 int res2 = SWIG_TMPOBJ ;
7416 PLFLT temp3 ;
7417 int res3 = SWIG_TMPOBJ ;
7418 PLFLT temp4 ;
7419 int res4 = SWIG_TMPOBJ ;
7420
7421 arg1 = &temp1;
7422 arg2 = &temp2;
7423 arg3 = &temp3;
7424 arg4 = &temp4;
7425 if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7426 plgspa(arg1,arg2,arg3,arg4);
7427 resultobj = SWIG_Py_Void();
7428 if (SWIG_IsTmpObj(res1)) {
7429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7430 } else {
7431 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7433 }
7434 if (SWIG_IsTmpObj(res2)) {
7435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7436 } else {
7437 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7439 }
7440 if (SWIG_IsTmpObj(res3)) {
7441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7442 } else {
7443 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7445 }
7446 if (SWIG_IsTmpObj(res4)) {
7447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7448 } else {
7449 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7451 }
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7459 PyObject *resultobj = 0;
7460 PLINT *arg1 = (PLINT *) 0 ;
7461 PLINT temp1 ;
7462 int res1 = SWIG_TMPOBJ ;
7463
7464 arg1 = &temp1;
7465 if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7466 plgstrm(arg1);
7467 resultobj = SWIG_Py_Void();
7468 if (SWIG_IsTmpObj(res1)) {
7469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7470 } else {
7471 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7473 }
7474 return resultobj;
7475 fail:
7476 return NULL;
7477 }
7478
7479
7480 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7481 PyObject *resultobj = 0;
7482 char *arg1 = (char *) 0 ;
7483 char buff1[1000] ;
7484
7485 {
7486 arg1 = buff1;
7487 }
7488 if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7489 plgver(arg1);
7490 resultobj = SWIG_Py_Void();
7491 {
7492 PyObject *o = PyString_FromString( arg1 );
7493 resultobj = t_output_helper( resultobj, o );
7494 }
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7502 PyObject *resultobj = 0;
7503 PLFLT *arg1 = (PLFLT *) 0 ;
7504 PLFLT *arg2 = (PLFLT *) 0 ;
7505 PLFLT *arg3 = (PLFLT *) 0 ;
7506 PLFLT *arg4 = (PLFLT *) 0 ;
7507 PLFLT temp1 ;
7508 int res1 = SWIG_TMPOBJ ;
7509 PLFLT temp2 ;
7510 int res2 = SWIG_TMPOBJ ;
7511 PLFLT temp3 ;
7512 int res3 = SWIG_TMPOBJ ;
7513 PLFLT temp4 ;
7514 int res4 = SWIG_TMPOBJ ;
7515
7516 arg1 = &temp1;
7517 arg2 = &temp2;
7518 arg3 = &temp3;
7519 arg4 = &temp4;
7520 if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7521 plgvpd(arg1,arg2,arg3,arg4);
7522 resultobj = SWIG_Py_Void();
7523 if (SWIG_IsTmpObj(res1)) {
7524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7525 } else {
7526 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7528 }
7529 if (SWIG_IsTmpObj(res2)) {
7530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7531 } else {
7532 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7534 }
7535 if (SWIG_IsTmpObj(res3)) {
7536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7537 } else {
7538 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7540 }
7541 if (SWIG_IsTmpObj(res4)) {
7542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7543 } else {
7544 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7554 PyObject *resultobj = 0;
7555 PLFLT *arg1 = (PLFLT *) 0 ;
7556 PLFLT *arg2 = (PLFLT *) 0 ;
7557 PLFLT *arg3 = (PLFLT *) 0 ;
7558 PLFLT *arg4 = (PLFLT *) 0 ;
7559 PLFLT temp1 ;
7560 int res1 = SWIG_TMPOBJ ;
7561 PLFLT temp2 ;
7562 int res2 = SWIG_TMPOBJ ;
7563 PLFLT temp3 ;
7564 int res3 = SWIG_TMPOBJ ;
7565 PLFLT temp4 ;
7566 int res4 = SWIG_TMPOBJ ;
7567
7568 arg1 = &temp1;
7569 arg2 = &temp2;
7570 arg3 = &temp3;
7571 arg4 = &temp4;
7572 if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7573 plgvpw(arg1,arg2,arg3,arg4);
7574 resultobj = SWIG_Py_Void();
7575 if (SWIG_IsTmpObj(res1)) {
7576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7577 } else {
7578 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7580 }
7581 if (SWIG_IsTmpObj(res2)) {
7582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7583 } else {
7584 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7586 }
7587 if (SWIG_IsTmpObj(res3)) {
7588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7589 } else {
7590 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7592 }
7593 if (SWIG_IsTmpObj(res4)) {
7594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7595 } else {
7596 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7598 }
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7606 PyObject *resultobj = 0;
7607 PLINT *arg1 = (PLINT *) 0 ;
7608 PLINT *arg2 = (PLINT *) 0 ;
7609 PLINT temp1 ;
7610 int res1 = SWIG_TMPOBJ ;
7611 PLINT temp2 ;
7612 int res2 = SWIG_TMPOBJ ;
7613
7614 arg1 = &temp1;
7615 arg2 = &temp2;
7616 if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7617 plgxax(arg1,arg2);
7618 resultobj = SWIG_Py_Void();
7619 if (SWIG_IsTmpObj(res1)) {
7620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7621 } else {
7622 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7624 }
7625 if (SWIG_IsTmpObj(res2)) {
7626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7627 } else {
7628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7630 }
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7638 PyObject *resultobj = 0;
7639 PLINT *arg1 = (PLINT *) 0 ;
7640 PLINT *arg2 = (PLINT *) 0 ;
7641 PLINT temp1 ;
7642 int res1 = SWIG_TMPOBJ ;
7643 PLINT temp2 ;
7644 int res2 = SWIG_TMPOBJ ;
7645
7646 arg1 = &temp1;
7647 arg2 = &temp2;
7648 if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7649 plgyax(arg1,arg2);
7650 resultobj = SWIG_Py_Void();
7651 if (SWIG_IsTmpObj(res1)) {
7652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7653 } else {
7654 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7656 }
7657 if (SWIG_IsTmpObj(res2)) {
7658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7659 } else {
7660 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7662 }
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7670 PyObject *resultobj = 0;
7671 PLINT *arg1 = (PLINT *) 0 ;
7672 PLINT *arg2 = (PLINT *) 0 ;
7673 PLINT temp1 ;
7674 int res1 = SWIG_TMPOBJ ;
7675 PLINT temp2 ;
7676 int res2 = SWIG_TMPOBJ ;
7677
7678 arg1 = &temp1;
7679 arg2 = &temp2;
7680 if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7681 plgzax(arg1,arg2);
7682 resultobj = SWIG_Py_Void();
7683 if (SWIG_IsTmpObj(res1)) {
7684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7685 } else {
7686 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7688 }
7689 if (SWIG_IsTmpObj(res2)) {
7690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7691 } else {
7692 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7694 }
7695 return resultobj;
7696 fail:
7697 return NULL;
7698 }
7699
7700
7701 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7702 PyObject *resultobj = 0;
7703 PLINT arg1 ;
7704 PLFLT *arg2 = (PLFLT *) 0 ;
7705 PLFLT arg3 ;
7706 PLFLT arg4 ;
7707 PLINT arg5 ;
7708 PLINT arg6 ;
7709 PyArrayObject *tmp1 = NULL ;
7710 double val3 ;
7711 int ecode3 = 0 ;
7712 double val4 ;
7713 int ecode4 = 0 ;
7714 int val5 ;
7715 int ecode5 = 0 ;
7716 int val6 ;
7717 int ecode6 = 0 ;
7718 PyObject * obj0 = 0 ;
7719 PyObject * obj1 = 0 ;
7720 PyObject * obj2 = 0 ;
7721 PyObject * obj3 = 0 ;
7722 PyObject * obj4 = 0 ;
7723
7724 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7725 {
7726 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7727 if ( tmp1 == NULL )
7728 return NULL;
7729 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7730 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7731 }
7732 ecode3 = SWIG_AsVal_double(obj1, &val3);
7733 if (!SWIG_IsOK(ecode3)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7735 }
7736 arg3 = (PLFLT)(val3);
7737 ecode4 = SWIG_AsVal_double(obj2, &val4);
7738 if (!SWIG_IsOK(ecode4)) {
7739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7740 }
7741 arg4 = (PLFLT)(val4);
7742 ecode5 = SWIG_AsVal_int(obj3, &val5);
7743 if (!SWIG_IsOK(ecode5)) {
7744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7745 }
7746 arg5 = (PLINT)(val5);
7747 ecode6 = SWIG_AsVal_int(obj4, &val6);
7748 if (!SWIG_IsOK(ecode6)) {
7749 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7750 }
7751 arg6 = (PLINT)(val6);
7752 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7753 resultobj = SWIG_Py_Void();
7754 {
7755 Py_CLEAR( tmp1 );
7756 }
7757 return resultobj;
7758 fail:
7759 {
7760 Py_CLEAR( tmp1 );
7761 }
7762 return NULL;
7763 }
7764
7765
7766 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7767 PyObject *resultobj = 0;
7768 PLFLT arg1 ;
7769 PLFLT arg2 ;
7770 PLFLT arg3 ;
7771 PLFLT *arg4 = (PLFLT *) 0 ;
7772 PLFLT *arg5 = (PLFLT *) 0 ;
7773 PLFLT *arg6 = (PLFLT *) 0 ;
7774 double val1 ;
7775 int ecode1 = 0 ;
7776 double val2 ;
7777 int ecode2 = 0 ;
7778 double val3 ;
7779 int ecode3 = 0 ;
7780 PLFLT temp4 ;
7781 int res4 = SWIG_TMPOBJ ;
7782 PLFLT temp5 ;
7783 int res5 = SWIG_TMPOBJ ;
7784 PLFLT temp6 ;
7785 int res6 = SWIG_TMPOBJ ;
7786 PyObject * obj0 = 0 ;
7787 PyObject * obj1 = 0 ;
7788 PyObject * obj2 = 0 ;
7789
7790 arg4 = &temp4;
7791 arg5 = &temp5;
7792 arg6 = &temp6;
7793 if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7794 ecode1 = SWIG_AsVal_double(obj0, &val1);
7795 if (!SWIG_IsOK(ecode1)) {
7796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7797 }
7798 arg1 = (PLFLT)(val1);
7799 ecode2 = SWIG_AsVal_double(obj1, &val2);
7800 if (!SWIG_IsOK(ecode2)) {
7801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7802 }
7803 arg2 = (PLFLT)(val2);
7804 ecode3 = SWIG_AsVal_double(obj2, &val3);
7805 if (!SWIG_IsOK(ecode3)) {
7806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7807 }
7808 arg3 = (PLFLT)(val3);
7809 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7810 resultobj = SWIG_Py_Void();
7811 if (SWIG_IsTmpObj(res4)) {
7812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7813 } else {
7814 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7816 }
7817 if (SWIG_IsTmpObj(res5)) {
7818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7819 } else {
7820 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7822 }
7823 if (SWIG_IsTmpObj(res6)) {
7824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7825 } else {
7826 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7828 }
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7836 PyObject *resultobj = 0;
7837
7838 if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7839 plinit();
7840 resultobj = SWIG_Py_Void();
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849 PLFLT arg1 ;
7850 PLFLT arg2 ;
7851 PLFLT arg3 ;
7852 PLFLT arg4 ;
7853 double val1 ;
7854 int ecode1 = 0 ;
7855 double val2 ;
7856 int ecode2 = 0 ;
7857 double val3 ;
7858 int ecode3 = 0 ;
7859 double val4 ;
7860 int ecode4 = 0 ;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 PyObject * obj2 = 0 ;
7864 PyObject * obj3 = 0 ;
7865
7866 if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7867 ecode1 = SWIG_AsVal_double(obj0, &val1);
7868 if (!SWIG_IsOK(ecode1)) {
7869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7870 }
7871 arg1 = (PLFLT)(val1);
7872 ecode2 = SWIG_AsVal_double(obj1, &val2);
7873 if (!SWIG_IsOK(ecode2)) {
7874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7875 }
7876 arg2 = (PLFLT)(val2);
7877 ecode3 = SWIG_AsVal_double(obj2, &val3);
7878 if (!SWIG_IsOK(ecode3)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7880 }
7881 arg3 = (PLFLT)(val3);
7882 ecode4 = SWIG_AsVal_double(obj3, &val4);
7883 if (!SWIG_IsOK(ecode4)) {
7884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7885 }
7886 arg4 = (PLFLT)(val4);
7887 pljoin(arg1,arg2,arg3,arg4);
7888 resultobj = SWIG_Py_Void();
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7896 PyObject *resultobj = 0;
7897 char *arg1 = (char *) 0 ;
7898 char *arg2 = (char *) 0 ;
7899 char *arg3 = (char *) 0 ;
7900 int res1 ;
7901 char *buf1 = 0 ;
7902 int alloc1 = 0 ;
7903 int res2 ;
7904 char *buf2 = 0 ;
7905 int alloc2 = 0 ;
7906 int res3 ;
7907 char *buf3 = 0 ;
7908 int alloc3 = 0 ;
7909 PyObject * obj0 = 0 ;
7910 PyObject * obj1 = 0 ;
7911 PyObject * obj2 = 0 ;
7912
7913 if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7914 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7917 }
7918 arg1 = (char *)(buf1);
7919 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7920 if (!SWIG_IsOK(res2)) {
7921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7922 }
7923 arg2 = (char *)(buf2);
7924 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7925 if (!SWIG_IsOK(res3)) {
7926 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7927 }
7928 arg3 = (char *)(buf3);
7929 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7930 resultobj = SWIG_Py_Void();
7931 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7932 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7933 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7934 return resultobj;
7935 fail:
7936 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7937 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7938 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 PyObject *resultobj = 0;
7945 PLFLT *arg1 = (PLFLT *) 0 ;
7946 PLFLT *arg2 = (PLFLT *) 0 ;
7947 PLINT arg3 ;
7948 PLINT arg4 ;
7949 PLFLT arg5 ;
7950 PLFLT arg6 ;
7951 PLFLT arg7 ;
7952 PLINT arg8 ;
7953 PLINT arg9 ;
7954 PLINT arg10 ;
7955 PLINT arg11 ;
7956 PLINT arg12 ;
7957 PLINT arg13 ;
7958 PLINT *arg14 = (PLINT *) 0 ;
7959 PLFLT arg15 ;
7960 PLFLT arg16 ;
7961 PLFLT arg17 ;
7962 PLFLT arg18 ;
7963 PLINT *arg19 = (PLINT *) 0 ;
7964 char **arg20 = (char **) 0 ;
7965 PLINT *arg21 = (PLINT *) 0 ;
7966 PLINT *arg22 = (PLINT *) 0 ;
7967 PLFLT *arg23 = (PLFLT *) 0 ;
7968 PLFLT *arg24 = (PLFLT *) 0 ;
7969 PLINT *arg25 = (PLINT *) 0 ;
7970 PLINT *arg26 = (PLINT *) 0 ;
7971 PLFLT *arg27 = (PLFLT *) 0 ;
7972 PLINT *arg28 = (PLINT *) 0 ;
7973 PLFLT *arg29 = (PLFLT *) 0 ;
7974 PLINT *arg30 = (PLINT *) 0 ;
7975 char **arg31 = (char **) 0 ;
7976 PLFLT temp1 ;
7977 int res1 = SWIG_TMPOBJ ;
7978 PLFLT temp2 ;
7979 int res2 = SWIG_TMPOBJ ;
7980 int val3 ;
7981 int ecode3 = 0 ;
7982 int val4 ;
7983 int ecode4 = 0 ;
7984 double val5 ;
7985 int ecode5 = 0 ;
7986 double val6 ;
7987 int ecode6 = 0 ;
7988 double val7 ;
7989 int ecode7 = 0 ;
7990 int val8 ;
7991 int ecode8 = 0 ;
7992 int val9 ;
7993 int ecode9 = 0 ;
7994 int val10 ;
7995 int ecode10 = 0 ;
7996 int val11 ;
7997 int ecode11 = 0 ;
7998 int val12 ;
7999 int ecode12 = 0 ;
8000 PyArrayObject *tmp13 = NULL ;
8001 double val15 ;
8002 int ecode15 = 0 ;
8003 double val16 ;
8004 int ecode16 = 0 ;
8005 double val17 ;
8006 int ecode17 = 0 ;
8007 double val18 ;
8008 int ecode18 = 0 ;
8009 PyArrayObject *tmp19 = NULL ;
8010 PyArrayObject *tmp20 = NULL ;
8011 PyArrayObject *tmp21 = NULL ;
8012 PyArrayObject *tmp22 = NULL ;
8013 PyArrayObject *tmp23 = NULL ;
8014 PyArrayObject *tmp24 = NULL ;
8015 PyArrayObject *tmp25 = NULL ;
8016 PyArrayObject *tmp26 = NULL ;
8017 PyArrayObject *tmp27 = NULL ;
8018 PyArrayObject *tmp28 = NULL ;
8019 PyArrayObject *tmp29 = NULL ;
8020 PyArrayObject *tmp30 = NULL ;
8021 PyArrayObject *tmp31 = NULL ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 PyObject * obj2 = 0 ;
8025 PyObject * obj3 = 0 ;
8026 PyObject * obj4 = 0 ;
8027 PyObject * obj5 = 0 ;
8028 PyObject * obj6 = 0 ;
8029 PyObject * obj7 = 0 ;
8030 PyObject * obj8 = 0 ;
8031 PyObject * obj9 = 0 ;
8032 PyObject * obj10 = 0 ;
8033 PyObject * obj11 = 0 ;
8034 PyObject * obj12 = 0 ;
8035 PyObject * obj13 = 0 ;
8036 PyObject * obj14 = 0 ;
8037 PyObject * obj15 = 0 ;
8038 PyObject * obj16 = 0 ;
8039 PyObject * obj17 = 0 ;
8040 PyObject * obj18 = 0 ;
8041 PyObject * obj19 = 0 ;
8042 PyObject * obj20 = 0 ;
8043 PyObject * obj21 = 0 ;
8044 PyObject * obj22 = 0 ;
8045 PyObject * obj23 = 0 ;
8046 PyObject * obj24 = 0 ;
8047 PyObject * obj25 = 0 ;
8048 PyObject * obj26 = 0 ;
8049 PyObject * obj27 = 0 ;
8050
8051 arg1 = &temp1;
8052 arg2 = &temp2;
8053 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
8054 ecode3 = SWIG_AsVal_int(obj0, &val3);
8055 if (!SWIG_IsOK(ecode3)) {
8056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8057 }
8058 arg3 = (PLINT)(val3);
8059 ecode4 = SWIG_AsVal_int(obj1, &val4);
8060 if (!SWIG_IsOK(ecode4)) {
8061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8062 }
8063 arg4 = (PLINT)(val4);
8064 ecode5 = SWIG_AsVal_double(obj2, &val5);
8065 if (!SWIG_IsOK(ecode5)) {
8066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8067 }
8068 arg5 = (PLFLT)(val5);
8069 ecode6 = SWIG_AsVal_double(obj3, &val6);
8070 if (!SWIG_IsOK(ecode6)) {
8071 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8072 }
8073 arg6 = (PLFLT)(val6);
8074 ecode7 = SWIG_AsVal_double(obj4, &val7);
8075 if (!SWIG_IsOK(ecode7)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8077 }
8078 arg7 = (PLFLT)(val7);
8079 ecode8 = SWIG_AsVal_int(obj5, &val8);
8080 if (!SWIG_IsOK(ecode8)) {
8081 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8082 }
8083 arg8 = (PLINT)(val8);
8084 ecode9 = SWIG_AsVal_int(obj6, &val9);
8085 if (!SWIG_IsOK(ecode9)) {
8086 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8087 }
8088 arg9 = (PLINT)(val9);
8089 ecode10 = SWIG_AsVal_int(obj7, &val10);
8090 if (!SWIG_IsOK(ecode10)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8092 }
8093 arg10 = (PLINT)(val10);
8094 ecode11 = SWIG_AsVal_int(obj8, &val11);
8095 if (!SWIG_IsOK(ecode11)) {
8096 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8097 }
8098 arg11 = (PLINT)(val11);
8099 ecode12 = SWIG_AsVal_int(obj9, &val12);
8100 if (!SWIG_IsOK(ecode12)) {
8101 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8102 }
8103 arg12 = (PLINT)(val12);
8104 {
8105 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
8106 if ( tmp13 == NULL )
8107 return NULL;
8108 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8109 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8110 }
8111 ecode15 = SWIG_AsVal_double(obj11, &val15);
8112 if (!SWIG_IsOK(ecode15)) {
8113 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8114 }
8115 arg15 = (PLFLT)(val15);
8116 ecode16 = SWIG_AsVal_double(obj12, &val16);
8117 if (!SWIG_IsOK(ecode16)) {
8118 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8119 }
8120 arg16 = (PLFLT)(val16);
8121 ecode17 = SWIG_AsVal_double(obj13, &val17);
8122 if (!SWIG_IsOK(ecode17)) {
8123 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8124 }
8125 arg17 = (PLFLT)(val17);
8126 ecode18 = SWIG_AsVal_double(obj14, &val18);
8127 if (!SWIG_IsOK(ecode18)) {
8128 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8129 }
8130 arg18 = (PLFLT)(val18);
8131 {
8132 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
8133 if ( tmp19 == NULL )
8134 return NULL;
8135 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8136 {
8137 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8138 return NULL;
8139 }
8140 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8141 }
8142 {
8143 int i;
8144 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
8145 if ( tmp20 == NULL )
8146 return NULL;
8147 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8148 {
8149 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8150 return NULL;
8151 }
8152 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8153 for ( i = 0; i < Alen; i++ )
8154 {
8155 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8156 if ( arg20[i] == NULL )
8157 {
8158 free( arg20 );
8159 return NULL;
8160 }
8161 }
8162 }
8163 {
8164 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8165 if ( tmp21 == NULL )
8166 return NULL;
8167 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8168 {
8169 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8170 return NULL;
8171 }
8172 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8173 }
8174 {
8175 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8176 if ( tmp22 == NULL )
8177 return NULL;
8178 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8179 {
8180 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8181 return NULL;
8182 }
8183 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8184 }
8185 {
8186 if ( obj19 != Py_None )
8187 {
8188 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8189 if ( tmp23 == NULL )
8190 return NULL;
8191 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8192 {
8193 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8194 return NULL;
8195 }
8196 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8197 }
8198 else
8199 {
8200 arg23 = NULL;
8201 }
8202 }
8203 {
8204 if ( obj20 != Py_None )
8205 {
8206 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8207 if ( tmp24 == NULL )
8208 return NULL;
8209 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8210 {
8211 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8212 return NULL;
8213 }
8214 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8215 }
8216 else
8217 {
8218 arg24 = NULL;
8219 }
8220 }
8221 {
8222 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8223 if ( tmp25 == NULL )
8224 return NULL;
8225 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8226 {
8227 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8228 return NULL;
8229 }
8230 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8231 }
8232 {
8233 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8234 if ( tmp26 == NULL )
8235 return NULL;
8236 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8237 {
8238 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8239 return NULL;
8240 }
8241 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8242 }
8243 {
8244 if ( obj23 != Py_None )
8245 {
8246 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8247 if ( tmp27 == NULL )
8248 return NULL;
8249 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8250 {
8251 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8252 return NULL;
8253 }
8254 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8255 }
8256 else
8257 {
8258 arg27 = NULL;
8259 }
8260 }
8261 {
8262 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8263 if ( tmp28 == NULL )
8264 return NULL;
8265 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8266 {
8267 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8268 return NULL;
8269 }
8270 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8271 }
8272 {
8273 if ( obj25 != Py_None )
8274 {
8275 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8276 if ( tmp29 == NULL )
8277 return NULL;
8278 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8279 {
8280 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8281 return NULL;
8282 }
8283 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8284 }
8285 else
8286 {
8287 arg29 = NULL;
8288 }
8289 }
8290 {
8291 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8292 if ( tmp30 == NULL )
8293 return NULL;
8294 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8295 {
8296 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8297 return NULL;
8298 }
8299 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8300 }
8301 {
8302 int i;
8303 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8304 if ( tmp31 == NULL )
8305 return NULL;
8306 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8307 {
8308 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8309 return NULL;
8310 }
8311 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8312 for ( i = 0; i < Alen; i++ )
8313 {
8314 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8315 if ( arg31[i] == NULL )
8316 {
8317 free( arg31 );
8318 return NULL;
8319 }
8320 }
8321 }
8322 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);
8323 resultobj = SWIG_Py_Void();
8324 if (SWIG_IsTmpObj(res1)) {
8325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8326 } else {
8327 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8329 }
8330 if (SWIG_IsTmpObj(res2)) {
8331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8332 } else {
8333 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8335 }
8336 {
8337 Py_CLEAR( tmp13 );
8338 }
8339 {
8340 Py_CLEAR( tmp19 );
8341 }
8342 {
8343 Py_CLEAR( tmp20 ); free( arg20 );
8344 }
8345 {
8346 Py_CLEAR( tmp21 );
8347 }
8348 {
8349 Py_CLEAR( tmp22 );
8350 }
8351 {
8352 Py_CLEAR( tmp23 );
8353 }
8354 {
8355 Py_CLEAR( tmp24 );
8356 }
8357 {
8358 Py_CLEAR( tmp25 );
8359 }
8360 {
8361 Py_CLEAR( tmp26 );
8362 }
8363 {
8364 Py_CLEAR( tmp27 );
8365 }
8366 {
8367 Py_CLEAR( tmp28 );
8368 }
8369 {
8370 Py_CLEAR( tmp29 );
8371 }
8372 {
8373 Py_CLEAR( tmp30 );
8374 }
8375 {
8376 Py_CLEAR( tmp31 ); free( arg31 );
8377 }
8378 return resultobj;
8379 fail:
8380 {
8381 Py_CLEAR( tmp13 );
8382 }
8383 {
8384 Py_CLEAR( tmp19 );
8385 }
8386 {
8387 Py_CLEAR( tmp20 ); free( arg20 );
8388 }
8389 {
8390 Py_CLEAR( tmp21 );
8391 }
8392 {
8393 Py_CLEAR( tmp22 );
8394 }
8395 {
8396 Py_CLEAR( tmp23 );
8397 }
8398 {
8399 Py_CLEAR( tmp24 );
8400 }
8401 {
8402 Py_CLEAR( tmp25 );
8403 }
8404 {
8405 Py_CLEAR( tmp26 );
8406 }
8407 {
8408 Py_CLEAR( tmp27 );
8409 }
8410 {
8411 Py_CLEAR( tmp28 );
8412 }
8413 {
8414 Py_CLEAR( tmp29 );
8415 }
8416 {
8417 Py_CLEAR( tmp30 );
8418 }
8419 {
8420 Py_CLEAR( tmp31 ); free( arg31 );
8421 }
8422 return NULL;
8423 }
8424
8425
8426 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8427 PyObject *resultobj = 0;
8428 PLFLT *arg1 = (PLFLT *) 0 ;
8429 PLFLT *arg2 = (PLFLT *) 0 ;
8430 PLINT arg3 ;
8431 PLINT arg4 ;
8432 PLFLT arg5 ;
8433 PLFLT arg6 ;
8434 PLFLT arg7 ;
8435 PLFLT arg8 ;
8436 PLINT arg9 ;
8437 PLINT arg10 ;
8438 PLINT arg11 ;
8439 PLFLT arg12 ;
8440 PLFLT arg13 ;
8441 PLINT arg14 ;
8442 PLFLT arg15 ;
8443 PLINT arg16 ;
8444 PLINT *arg17 = (PLINT *) 0 ;
8445 char **arg18 = (char **) 0 ;
8446 PLINT arg19 ;
8447 char **arg20 = (char **) 0 ;
8448 PLFLT *arg21 = (PLFLT *) 0 ;
8449 PLINT *arg22 = (PLINT *) 0 ;
8450 PLINT *arg23 = (PLINT *) 0 ;
8451 PLFLT **arg24 = (PLFLT **) 0 ;
8452 PLFLT temp1 ;
8453 int res1 = SWIG_TMPOBJ ;
8454 PLFLT temp2 ;
8455 int res2 = SWIG_TMPOBJ ;
8456 int val3 ;
8457 int ecode3 = 0 ;
8458 int val4 ;
8459 int ecode4 = 0 ;
8460 double val5 ;
8461 int ecode5 = 0 ;
8462 double val6 ;
8463 int ecode6 = 0 ;
8464 double val7 ;
8465 int ecode7 = 0 ;
8466 double val8 ;
8467 int ecode8 = 0 ;
8468 int val9 ;
8469 int ecode9 = 0 ;
8470 int val10 ;
8471 int ecode10 = 0 ;
8472 int val11 ;
8473 int ecode11 = 0 ;
8474 double val12 ;
8475 int ecode12 = 0 ;
8476 double val13 ;
8477 int ecode13 = 0 ;
8478 int val14 ;
8479 int ecode14 = 0 ;
8480 double val15 ;
8481 int ecode15 = 0 ;
8482 PyArrayObject *tmp16 = NULL ;
8483 PyArrayObject *tmp18 = NULL ;
8484 PyArrayObject *tmp19 = NULL ;
8485 PyArrayObject *tmp21 = NULL ;
8486 PyArrayObject *tmp22 = NULL ;
8487 PyArrayObject *tmp23 = NULL ;
8488 PyArrayObject *tmp24 = NULL ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 PyObject * obj2 = 0 ;
8492 PyObject * obj3 = 0 ;
8493 PyObject * obj4 = 0 ;
8494 PyObject * obj5 = 0 ;
8495 PyObject * obj6 = 0 ;
8496 PyObject * obj7 = 0 ;
8497 PyObject * obj8 = 0 ;
8498 PyObject * obj9 = 0 ;
8499 PyObject * obj10 = 0 ;
8500 PyObject * obj11 = 0 ;
8501 PyObject * obj12 = 0 ;
8502 PyObject * obj13 = 0 ;
8503 PyObject * obj14 = 0 ;
8504 PyObject * obj15 = 0 ;
8505 PyObject * obj16 = 0 ;
8506 PyObject * obj17 = 0 ;
8507 PyObject * obj18 = 0 ;
8508 PyObject * obj19 = 0 ;
8509
8510 arg1 = &temp1;
8511 arg2 = &temp2;
8512 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:plcolorbar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
8513 ecode3 = SWIG_AsVal_int(obj0, &val3);
8514 if (!SWIG_IsOK(ecode3)) {
8515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8516 }
8517 arg3 = (PLINT)(val3);
8518 ecode4 = SWIG_AsVal_int(obj1, &val4);
8519 if (!SWIG_IsOK(ecode4)) {
8520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8521 }
8522 arg4 = (PLINT)(val4);
8523 ecode5 = SWIG_AsVal_double(obj2, &val5);
8524 if (!SWIG_IsOK(ecode5)) {
8525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8526 }
8527 arg5 = (PLFLT)(val5);
8528 ecode6 = SWIG_AsVal_double(obj3, &val6);
8529 if (!SWIG_IsOK(ecode6)) {
8530 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8531 }
8532 arg6 = (PLFLT)(val6);
8533 ecode7 = SWIG_AsVal_double(obj4, &val7);
8534 if (!SWIG_IsOK(ecode7)) {
8535 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8536 }
8537 arg7 = (PLFLT)(val7);
8538 ecode8 = SWIG_AsVal_double(obj5, &val8);
8539 if (!SWIG_IsOK(ecode8)) {
8540 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8541 }
8542 arg8 = (PLFLT)(val8);
8543 ecode9 = SWIG_AsVal_int(obj6, &val9);
8544 if (!SWIG_IsOK(ecode9)) {
8545 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8546 }
8547 arg9 = (PLINT)(val9);
8548 ecode10 = SWIG_AsVal_int(obj7, &val10);
8549 if (!SWIG_IsOK(ecode10)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8551 }
8552 arg10 = (PLINT)(val10);
8553 ecode11 = SWIG_AsVal_int(obj8, &val11);
8554 if (!SWIG_IsOK(ecode11)) {
8555 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8556 }
8557 arg11 = (PLINT)(val11);
8558 ecode12 = SWIG_AsVal_double(obj9, &val12);
8559 if (!SWIG_IsOK(ecode12)) {
8560 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8561 }
8562 arg12 = (PLFLT)(val12);
8563 ecode13 = SWIG_AsVal_double(obj10, &val13);
8564 if (!SWIG_IsOK(ecode13)) {
8565 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8566 }
8567 arg13 = (PLFLT)(val13);
8568 ecode14 = SWIG_AsVal_int(obj11, &val14);
8569 if (!SWIG_IsOK(ecode14)) {
8570 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8571 }
8572 arg14 = (PLINT)(val14);
8573 ecode15 = SWIG_AsVal_double(obj12, &val15);
8574 if (!SWIG_IsOK(ecode15)) {
8575 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8576 }
8577 arg15 = (PLFLT)(val15);
8578 {
8579 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8580 if ( tmp16 == NULL )
8581 return NULL;
8582 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8583 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8584 }
8585 {
8586 int i;
8587 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8588 if ( tmp18 == NULL )
8589 return NULL;
8590 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8591 {
8592 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8593 return NULL;
8594 }
8595 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8596 for ( i = 0; i < Alen; i++ )
8597 {
8598 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8599 if ( arg18[i] == NULL )
8600 {
8601 free( arg18 );
8602 return NULL;
8603 }
8604 }
8605 }
8606 {
8607 int i;
8608 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8609 if ( tmp19 == NULL )
8610 return NULL;
8611 Alen = PyArray_DIMS( tmp19 )[0];
8612 arg19 = Alen;
8613 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8614 for ( i = 0; i < Alen; i++ )
8615 {
8616 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8617 if ( arg20[i] == NULL )
8618 {
8619 free( arg20 );
8620 return NULL;
8621 }
8622 }
8623 }
8624 {
8625 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8626 if ( tmp21 == NULL )
8627 return NULL;
8628 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8629 {
8630 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8631 return NULL;
8632 }
8633 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8634 }
8635 {
8636 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8637 if ( tmp22 == NULL )
8638 return NULL;
8639 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8640 {
8641 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8642 return NULL;
8643 }
8644 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8645 }
8646 {
8647 int i;
8648 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8649 if ( tmp23 == NULL )
8650 return NULL;
8651 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8652 {
8653 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8654 return NULL;
8655 }
8656 Xlen = PyArray_DIMS( tmp23 )[0];
8657 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8658 Ylen = -1;
8659 for ( i = 0; i < Xlen; i++ )
8660 if ( arg23[i] > Ylen )
8661 Ylen = arg23[i];
8662 }
8663 {
8664 int i, size;
8665 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8666 if ( tmp24 == NULL )
8667 return NULL;
8668 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8669 {
8670 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8671 return NULL;
8672 }
8673 size = Ylen;
8674 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8675 for ( i = 0; i < Xlen; i++ )
8676 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8677 }
8678 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);
8679 resultobj = SWIG_Py_Void();
8680 if (SWIG_IsTmpObj(res1)) {
8681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8682 } else {
8683 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8685 }
8686 if (SWIG_IsTmpObj(res2)) {
8687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8688 } else {
8689 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8691 }
8692 {
8693 Py_CLEAR( tmp16 );
8694 }
8695 {
8696 Py_CLEAR( tmp18 ); free( arg18 );
8697 }
8698 {
8699 Py_CLEAR( tmp19 ); free( arg20 );
8700 }
8701 {
8702 Py_CLEAR( tmp21 );
8703 }
8704 {
8705 Py_CLEAR( tmp22 );
8706 }
8707 {
8708 Py_CLEAR( tmp23 );
8709 }
8710 {
8711 Py_CLEAR( tmp24 );
8712 free( arg24 );
8713 }
8714 return resultobj;
8715 fail:
8716 {
8717 Py_CLEAR( tmp16 );
8718 }
8719 {
8720 Py_CLEAR( tmp18 ); free( arg18 );
8721 }
8722 {
8723 Py_CLEAR( tmp19 ); free( arg20 );
8724 }
8725 {
8726 Py_CLEAR( tmp21 );
8727 }
8728 {
8729 Py_CLEAR( tmp22 );
8730 }
8731 {
8732 Py_CLEAR( tmp23 );
8733 }
8734 {
8735 Py_CLEAR( tmp24 );
8736 free( arg24 );
8737 }
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 PLFLT arg1 ;
8745 PLFLT arg2 ;
8746 PLFLT arg3 ;
8747 double val1 ;
8748 int ecode1 = 0 ;
8749 double val2 ;
8750 int ecode2 = 0 ;
8751 double val3 ;
8752 int ecode3 = 0 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 PyObject * obj2 = 0 ;
8756
8757 if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8758 ecode1 = SWIG_AsVal_double(obj0, &val1);
8759 if (!SWIG_IsOK(ecode1)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8761 }
8762 arg1 = (PLFLT)(val1);
8763 ecode2 = SWIG_AsVal_double(obj1, &val2);
8764 if (!SWIG_IsOK(ecode2)) {
8765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8766 }
8767 arg2 = (PLFLT)(val2);
8768 ecode3 = SWIG_AsVal_double(obj2, &val3);
8769 if (!SWIG_IsOK(ecode3)) {
8770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8771 }
8772 arg3 = (PLFLT)(val3);
8773 pllightsource(arg1,arg2,arg3);
8774 resultobj = SWIG_Py_Void();
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8782 PyObject *resultobj = 0;
8783 PLINT arg1 ;
8784 PLFLT *arg2 = (PLFLT *) 0 ;
8785 PLFLT *arg3 = (PLFLT *) 0 ;
8786 PyArrayObject *tmp1 = NULL ;
8787 PyArrayObject *tmp3 = NULL ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790
8791 if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8792 {
8793 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8794 if ( tmp1 == NULL )
8795 return NULL;
8796 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8797 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8798 }
8799 {
8800 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8801 if ( tmp3 == NULL )
8802 return NULL;
8803 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8804 {
8805 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8806 return NULL;
8807 }
8808 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8809 }
8810 plline(arg1,(double const *)arg2,(double const *)arg3);
8811 resultobj = SWIG_Py_Void();
8812 {
8813 Py_CLEAR( tmp1 );
8814 }
8815 {
8816 Py_CLEAR( tmp3 );
8817 }
8818 return resultobj;
8819 fail:
8820 {
8821 Py_CLEAR( tmp1 );
8822 }
8823 {
8824 Py_CLEAR( tmp3 );
8825 }
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 PLINT arg1 ;
8833 PLFLT *arg2 = (PLFLT *) 0 ;
8834 PLFLT *arg3 = (PLFLT *) 0 ;
8835 PLFLT *arg4 = (PLFLT *) 0 ;
8836 PyArrayObject *tmp1 = NULL ;
8837 PyArrayObject *tmp3 = NULL ;
8838 PyArrayObject *tmp4 = NULL ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 PyObject * obj2 = 0 ;
8842
8843 if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8844 {
8845 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8846 if ( tmp1 == NULL )
8847 return NULL;
8848 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8849 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8850 }
8851 {
8852 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8853 if ( tmp3 == NULL )
8854 return NULL;
8855 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8856 {
8857 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8858 return NULL;
8859 }
8860 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8861 }
8862 {
8863 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8864 if ( tmp4 == NULL )
8865 return NULL;
8866 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8867 {
8868 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8869 return NULL;
8870 }
8871 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8872 }
8873 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8874 resultobj = SWIG_Py_Void();
8875 {
8876 Py_CLEAR( tmp1 );
8877 }
8878 {
8879 Py_CLEAR( tmp3 );
8880 }
8881 {
8882 Py_CLEAR( tmp4 );
8883 }
8884 return resultobj;
8885 fail:
8886 {
8887 Py_CLEAR( tmp1 );
8888 }
8889 {
8890 Py_CLEAR( tmp3 );
8891 }
8892 {
8893 Py_CLEAR( tmp4 );
8894 }
8895 return NULL;
8896 }
8897
8898
8899 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 PyObject *resultobj = 0;
8901 PLINT arg1 ;
8902 int val1 ;
8903 int ecode1 = 0 ;
8904 PyObject * obj0 = 0 ;
8905
8906 if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8907 ecode1 = SWIG_AsVal_int(obj0, &val1);
8908 if (!SWIG_IsOK(ecode1)) {
8909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8910 }
8911 arg1 = (PLINT)(val1);
8912 pllsty(arg1);
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8921 PyObject *resultobj = 0;
8922 PLFLT *arg1 = (PLFLT *) 0 ;
8923 PLFLT *arg2 = (PLFLT *) 0 ;
8924 PLFLT **arg3 = (PLFLT **) 0 ;
8925 PLINT arg4 ;
8926 PLINT arg5 ;
8927 PLINT arg6 ;
8928 PyArrayObject *tmp1 = NULL ;
8929 PyArrayObject *tmp2 = NULL ;
8930 PyArrayObject *tmp3 = NULL ;
8931 int val6 ;
8932 int ecode6 = 0 ;
8933 PyObject * obj0 = 0 ;
8934 PyObject * obj1 = 0 ;
8935 PyObject * obj2 = 0 ;
8936 PyObject * obj3 = 0 ;
8937
8938 if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8939 {
8940 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8941 if ( tmp1 == NULL )
8942 return NULL;
8943 Xlen = PyArray_DIMS( tmp1 )[0];
8944 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8945 }
8946 {
8947 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8948 if ( tmp2 == NULL )
8949 return NULL;
8950 Ylen = PyArray_DIMS( tmp2 )[0];
8951 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8952 }
8953 {
8954 int i, size;
8955 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8956 if ( tmp3 == NULL )
8957 return NULL;
8958 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8959 {
8960 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8961 return NULL;
8962 }
8963 arg4 = PyArray_DIMS( tmp3 )[0];
8964 arg5 = PyArray_DIMS( tmp3 )[1];
8965 size = arg5;
8966 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8967 for ( i = 0; i < arg4; i++ )
8968 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8969 }
8970 ecode6 = SWIG_AsVal_int(obj3, &val6);
8971 if (!SWIG_IsOK(ecode6)) {
8972 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8973 }
8974 arg6 = (PLINT)(val6);
8975 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8976 resultobj = SWIG_Py_Void();
8977 {
8978 Py_CLEAR( tmp1 );
8979 }
8980 {
8981 Py_CLEAR( tmp2 );
8982 }
8983 {
8984 Py_CLEAR( tmp3 );
8985 free( arg3 );
8986 }
8987 return resultobj;
8988 fail:
8989 {
8990 Py_CLEAR( tmp1 );
8991 }
8992 {
8993 Py_CLEAR( tmp2 );
8994 }
8995 {
8996 Py_CLEAR( tmp3 );
8997 free( arg3 );
8998 }
8999 return NULL;
9000 }
9001
9002
9003 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9004 PyObject *resultobj = 0;
9005 PLFLT *arg1 = (PLFLT *) 0 ;
9006 PLFLT *arg2 = (PLFLT *) 0 ;
9007 PLFLT **arg3 = (PLFLT **) 0 ;
9008 PLINT arg4 ;
9009 PLINT arg5 ;
9010 PLINT arg6 ;
9011 PLFLT *arg7 = (PLFLT *) 0 ;
9012 PLINT arg8 ;
9013 PyArrayObject *tmp1 = NULL ;
9014 PyArrayObject *tmp2 = NULL ;
9015 PyArrayObject *tmp3 = NULL ;
9016 int val6 ;
9017 int ecode6 = 0 ;
9018 PyArrayObject *tmp7 = NULL ;
9019 PyObject * obj0 = 0 ;
9020 PyObject * obj1 = 0 ;
9021 PyObject * obj2 = 0 ;
9022 PyObject * obj3 = 0 ;
9023 PyObject * obj4 = 0 ;
9024
9025 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9026 {
9027 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9028 if ( tmp1 == NULL )
9029 return NULL;
9030 Xlen = PyArray_DIMS( tmp1 )[0];
9031 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9032 }
9033 {
9034 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9035 if ( tmp2 == NULL )
9036 return NULL;
9037 Ylen = PyArray_DIMS( tmp2 )[0];
9038 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9039 }
9040 {
9041 int i, size;
9042 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9043 if ( tmp3 == NULL )
9044 return NULL;
9045 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9046 {
9047 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9048 return NULL;
9049 }
9050 arg4 = PyArray_DIMS( tmp3 )[0];
9051 arg5 = PyArray_DIMS( tmp3 )[1];
9052 size = arg5;
9053 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9054 for ( i = 0; i < arg4; i++ )
9055 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9056 }
9057 ecode6 = SWIG_AsVal_int(obj3, &val6);
9058 if (!SWIG_IsOK(ecode6)) {
9059 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9060 }
9061 arg6 = (PLINT)(val6);
9062 {
9063 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9064 if ( tmp7 == NULL )
9065 return NULL;
9066 arg8 = PyArray_DIMS( tmp7 )[0];
9067 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9068 }
9069 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9070 resultobj = SWIG_Py_Void();
9071 {
9072 Py_CLEAR( tmp1 );
9073 }
9074 {
9075 Py_CLEAR( tmp2 );
9076 }
9077 {
9078 Py_CLEAR( tmp3 );
9079 free( arg3 );
9080 }
9081 {
9082 Py_CLEAR( tmp7 );
9083 }
9084 return resultobj;
9085 fail:
9086 {
9087 Py_CLEAR( tmp1 );
9088 }
9089 {
9090 Py_CLEAR( tmp2 );
9091 }
9092 {
9093 Py_CLEAR( tmp3 );
9094 free( arg3 );
9095 }
9096 {
9097 Py_CLEAR( tmp7 );
9098 }
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 PLINT *arg1 = (PLINT *) 0 ;
9106 PLINT temp1 ;
9107 int res1 = SWIG_TMPOBJ ;
9108
9109 arg1 = &temp1;
9110 if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
9111 plmkstrm(arg1);
9112 resultobj = SWIG_Py_Void();
9113 if (SWIG_IsTmpObj(res1)) {
9114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9115 } else {
9116 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9118 }
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9126 PyObject *resultobj = 0;
9127 char *arg1 = (char *) 0 ;
9128 PLFLT arg2 ;
9129 PLFLT arg3 ;
9130 PLFLT arg4 ;
9131 char *arg5 = (char *) 0 ;
9132 int res1 ;
9133 char *buf1 = 0 ;
9134 int alloc1 = 0 ;
9135 double val2 ;
9136 int ecode2 = 0 ;
9137 double val3 ;
9138 int ecode3 = 0 ;
9139 double val4 ;
9140 int ecode4 = 0 ;
9141 int res5 ;
9142 char *buf5 = 0 ;
9143 int alloc5 = 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 PyObject * obj2 = 0 ;
9147 PyObject * obj3 = 0 ;
9148 PyObject * obj4 = 0 ;
9149
9150 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9151 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9154 }
9155 arg1 = (char *)(buf1);
9156 ecode2 = SWIG_AsVal_double(obj1, &val2);
9157 if (!SWIG_IsOK(ecode2)) {
9158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9159 }
9160 arg2 = (PLFLT)(val2);
9161 ecode3 = SWIG_AsVal_double(obj2, &val3);
9162 if (!SWIG_IsOK(ecode3)) {
9163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9164 }
9165 arg3 = (PLFLT)(val3);
9166 ecode4 = SWIG_AsVal_double(obj3, &val4);
9167 if (!SWIG_IsOK(ecode4)) {
9168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9169 }
9170 arg4 = (PLFLT)(val4);
9171 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9172 if (!SWIG_IsOK(res5)) {
9173 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9174 }
9175 arg5 = (char *)(buf5);
9176 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9177 resultobj = SWIG_Py_Void();
9178 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9179 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9180 return resultobj;
9181 fail:
9182 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9183 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9189 PyObject *resultobj = 0;
9190 char *arg1 = (char *) 0 ;
9191 PLFLT arg2 ;
9192 PLFLT arg3 ;
9193 PLFLT arg4 ;
9194 char *arg5 = (char *) 0 ;
9195 int res1 ;
9196 char *buf1 = 0 ;
9197 int alloc1 = 0 ;
9198 double val2 ;
9199 int ecode2 = 0 ;
9200 double val3 ;
9201 int ecode3 = 0 ;
9202 double val4 ;
9203 int ecode4 = 0 ;
9204 int res5 ;
9205 char *buf5 = 0 ;
9206 int alloc5 = 0 ;
9207 PyObject * obj0 = 0 ;
9208 PyObject * obj1 = 0 ;
9209 PyObject * obj2 = 0 ;
9210 PyObject * obj3 = 0 ;
9211 PyObject * obj4 = 0 ;
9212
9213 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9214 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9215 if (!SWIG_IsOK(res1)) {
9216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9217 }
9218 arg1 = (char *)(buf1);
9219 ecode2 = SWIG_AsVal_double(obj1, &val2);
9220 if (!SWIG_IsOK(ecode2)) {
9221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9222 }
9223 arg2 = (PLFLT)(val2);
9224 ecode3 = SWIG_AsVal_double(obj2, &val3);
9225 if (!SWIG_IsOK(ecode3)) {
9226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9227 }
9228 arg3 = (PLFLT)(val3);
9229 ecode4 = SWIG_AsVal_double(obj3, &val4);
9230 if (!SWIG_IsOK(ecode4)) {
9231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9232 }
9233 arg4 = (PLFLT)(val4);
9234 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9235 if (!SWIG_IsOK(res5)) {
9236 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9237 }
9238 arg5 = (char *)(buf5);
9239 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9240 resultobj = SWIG_Py_Void();
9241 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9242 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9243 return resultobj;
9244 fail:
9245 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9246 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9247 return NULL;
9248 }
9249
9250
9251 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9252 PyObject *resultobj = 0;
9253 PLFLT *arg1 = (PLFLT *) 0 ;
9254 PLFLT *arg2 = (PLFLT *) 0 ;
9255 PLFLT **arg3 = (PLFLT **) 0 ;
9256 PLINT arg4 ;
9257 PLINT arg5 ;
9258 PLINT arg6 ;
9259 PLBOOL arg7 ;
9260 PyArrayObject *tmp1 = NULL ;
9261 PyArrayObject *tmp2 = NULL ;
9262 PyArrayObject *tmp3 = NULL ;
9263 int val6 ;
9264 int ecode6 = 0 ;
9265 int val7 ;
9266 int ecode7 = 0 ;
9267 PyObject * obj0 = 0 ;
9268 PyObject * obj1 = 0 ;
9269 PyObject * obj2 = 0 ;
9270 PyObject * obj3 = 0 ;
9271 PyObject * obj4 = 0 ;
9272
9273 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9274 {
9275 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9276 if ( tmp1 == NULL )
9277 return NULL;
9278 Xlen = PyArray_DIMS( tmp1 )[0];
9279 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9280 }
9281 {
9282 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9283 if ( tmp2 == NULL )
9284 return NULL;
9285 Ylen = PyArray_DIMS( tmp2 )[0];
9286 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9287 }
9288 {
9289 int i, size;
9290 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9291 if ( tmp3 == NULL )
9292 return NULL;
9293 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9294 {
9295 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9296 return NULL;
9297 }
9298 arg4 = PyArray_DIMS( tmp3 )[0];
9299 arg5 = PyArray_DIMS( tmp3 )[1];
9300 size = arg5;
9301 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9302 for ( i = 0; i < arg4; i++ )
9303 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9304 }
9305 ecode6 = SWIG_AsVal_int(obj3, &val6);
9306 if (!SWIG_IsOK(ecode6)) {
9307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9308 }
9309 arg6 = (PLINT)(val6);
9310 ecode7 = SWIG_AsVal_int(obj4, &val7);
9311 if (!SWIG_IsOK(ecode7)) {
9312 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9313 }
9314 arg7 = (PLBOOL)(val7);
9315 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9316 resultobj = SWIG_Py_Void();
9317 {
9318 Py_CLEAR( tmp1 );
9319 }
9320 {
9321 Py_CLEAR( tmp2 );
9322 }
9323 {
9324 Py_CLEAR( tmp3 );
9325 free( arg3 );
9326 }
9327 return resultobj;
9328 fail:
9329 {
9330 Py_CLEAR( tmp1 );
9331 }
9332 {
9333 Py_CLEAR( tmp2 );
9334 }
9335 {
9336 Py_CLEAR( tmp3 );
9337 free( arg3 );
9338 }
9339 return NULL;
9340 }
9341
9342
9343 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9344 PyObject *resultobj = 0;
9345 PLFLT *arg1 = (PLFLT *) 0 ;
9346 PLFLT *arg2 = (PLFLT *) 0 ;
9347 PLFLT **arg3 = (PLFLT **) 0 ;
9348 PLINT arg4 ;
9349 PLINT arg5 ;
9350 PLINT arg6 ;
9351 PLFLT *arg7 = (PLFLT *) 0 ;
9352 PLINT arg8 ;
9353 PyArrayObject *tmp1 = NULL ;
9354 PyArrayObject *tmp2 = NULL ;
9355 PyArrayObject *tmp3 = NULL ;
9356 int val6 ;
9357 int ecode6 = 0 ;
9358 PyArrayObject *tmp7 = NULL ;
9359 PyObject * obj0 = 0 ;
9360 PyObject * obj1 = 0 ;
9361 PyObject * obj2 = 0 ;
9362 PyObject * obj3 = 0 ;
9363 PyObject * obj4 = 0 ;
9364
9365 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9366 {
9367 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9368 if ( tmp1 == NULL )
9369 return NULL;
9370 Xlen = PyArray_DIMS( tmp1 )[0];
9371 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9372 }
9373 {
9374 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9375 if ( tmp2 == NULL )
9376 return NULL;
9377 Ylen = PyArray_DIMS( tmp2 )[0];
9378 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9379 }
9380 {
9381 int i, size;
9382 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9383 if ( tmp3 == NULL )
9384 return NULL;
9385 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9386 {
9387 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9388 return NULL;
9389 }
9390 arg4 = PyArray_DIMS( tmp3 )[0];
9391 arg5 = PyArray_DIMS( tmp3 )[1];
9392 size = arg5;
9393 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9394 for ( i = 0; i < arg4; i++ )
9395 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9396 }
9397 ecode6 = SWIG_AsVal_int(obj3, &val6);
9398 if (!SWIG_IsOK(ecode6)) {
9399 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9400 }
9401 arg6 = (PLINT)(val6);
9402 {
9403 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9404 if ( tmp7 == NULL )
9405 return NULL;
9406 arg8 = PyArray_DIMS( tmp7 )[0];
9407 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9408 }
9409 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9410 resultobj = SWIG_Py_Void();
9411 {
9412 Py_CLEAR( tmp1 );
9413 }
9414 {
9415 Py_CLEAR( tmp2 );
9416 }
9417 {
9418 Py_CLEAR( tmp3 );
9419 free( arg3 );
9420 }
9421 {
9422 Py_CLEAR( tmp7 );
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 Py_CLEAR( tmp1 );
9428 }
9429 {
9430 Py_CLEAR( tmp2 );
9431 }
9432 {
9433 Py_CLEAR( tmp3 );
9434 free( arg3 );
9435 }
9436 {
9437 Py_CLEAR( tmp7 );
9438 }
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 PyObject *resultobj = 0;
9445 PLFLT *arg1 = (PLFLT *) 0 ;
9446 PLFLT *arg2 = (PLFLT *) 0 ;
9447 PLFLT **arg3 = (PLFLT **) 0 ;
9448 PLINT arg4 ;
9449 PLINT arg5 ;
9450 PLINT arg6 ;
9451 PLFLT *arg7 = (PLFLT *) 0 ;
9452 PLINT arg8 ;
9453 PLINT arg9 ;
9454 PLINT arg10 ;
9455 PLINT *arg11 = (PLINT *) 0 ;
9456 PLINT *arg12 = (PLINT *) 0 ;
9457 PyArrayObject *tmp1 = NULL ;
9458 PyArrayObject *tmp2 = NULL ;
9459 PyArrayObject *tmp3 = NULL ;
9460 int val6 ;
9461 int ecode6 = 0 ;
9462 PyArrayObject *tmp7 = NULL ;
9463 int val9 ;
9464 int ecode9 = 0 ;
9465 PyArrayObject *tmp10 = NULL ;
9466 PyArrayObject *tmp12 = NULL ;
9467 PyObject * obj0 = 0 ;
9468 PyObject * obj1 = 0 ;
9469 PyObject * obj2 = 0 ;
9470 PyObject * obj3 = 0 ;
9471 PyObject * obj4 = 0 ;
9472 PyObject * obj5 = 0 ;
9473 PyObject * obj6 = 0 ;
9474 PyObject * obj7 = 0 ;
9475
9476 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9477 {
9478 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9479 if ( tmp1 == NULL )
9480 return NULL;
9481 Xlen = PyArray_DIMS( tmp1 )[0];
9482 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9483 }
9484 {
9485 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9486 if ( tmp2 == NULL )
9487 return NULL;
9488 Ylen = PyArray_DIMS( tmp2 )[0];
9489 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9490 }
9491 {
9492 int i, size;
9493 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9494 if ( tmp3 == NULL )
9495 return NULL;
9496 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9497 {
9498 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9499 return NULL;
9500 }
9501 arg4 = PyArray_DIMS( tmp3 )[0];
9502 arg5 = PyArray_DIMS( tmp3 )[1];
9503 size = arg5;
9504 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9505 for ( i = 0; i < arg4; i++ )
9506 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9507 }
9508 ecode6 = SWIG_AsVal_int(obj3, &val6);
9509 if (!SWIG_IsOK(ecode6)) {
9510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9511 }
9512 arg6 = (PLINT)(val6);
9513 {
9514 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9515 if ( tmp7 == NULL )
9516 return NULL;
9517 arg8 = PyArray_DIMS( tmp7 )[0];
9518 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9519 }
9520 ecode9 = SWIG_AsVal_int(obj5, &val9);
9521 if (!SWIG_IsOK(ecode9)) {
9522 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9523 }
9524 arg9 = (PLINT)(val9);
9525 {
9526 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9527 if ( tmp10 == NULL )
9528 return NULL;
9529 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9530 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9531 }
9532 {
9533 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9534 if ( tmp12 == NULL )
9535 return NULL;
9536 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9537 {
9538 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9539 return NULL;
9540 }
9541 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9542 }
9543 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);
9544 resultobj = SWIG_Py_Void();
9545 {
9546 Py_CLEAR( tmp1 );
9547 }
9548 {
9549 Py_CLEAR( tmp2 );
9550 }
9551 {
9552 Py_CLEAR( tmp3 );
9553 free( arg3 );
9554 }
9555 {
9556 Py_CLEAR( tmp7 );
9557 }
9558 {
9559 Py_CLEAR( tmp10 );
9560 }
9561 {
9562 Py_CLEAR( tmp12 );
9563 }
9564 return resultobj;
9565 fail:
9566 {
9567 Py_CLEAR( tmp1 );
9568 }
9569 {
9570 Py_CLEAR( tmp2 );
9571 }
9572 {
9573 Py_CLEAR( tmp3 );
9574 free( arg3 );
9575 }
9576 {
9577 Py_CLEAR( tmp7 );
9578 }
9579 {
9580 Py_CLEAR( tmp10 );
9581 }
9582 {
9583 Py_CLEAR( tmp12 );
9584 }
9585 return NULL;
9586 }
9587
9588
9589 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9590 PyObject *resultobj = 0;
9591 PLFLT *arg1 = (PLFLT *) 0 ;
9592 PLFLT *arg2 = (PLFLT *) 0 ;
9593 PLFLT **arg3 = (PLFLT **) 0 ;
9594 PLINT arg4 ;
9595 PLINT arg5 ;
9596 PLINT arg6 ;
9597 PLFLT *arg7 = (PLFLT *) 0 ;
9598 PLINT arg8 ;
9599 PyArrayObject *tmp1 = NULL ;
9600 PyArrayObject *tmp2 = NULL ;
9601 PyArrayObject *tmp3 = NULL ;
9602 int val6 ;
9603 int ecode6 = 0 ;
9604 PyArrayObject *tmp7 = NULL ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 PyObject * obj2 = 0 ;
9608 PyObject * obj3 = 0 ;
9609 PyObject * obj4 = 0 ;
9610
9611 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9612 {
9613 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9614 if ( tmp1 == NULL )
9615 return NULL;
9616 Xlen = PyArray_DIMS( tmp1 )[0];
9617 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9618 }
9619 {
9620 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9621 if ( tmp2 == NULL )
9622 return NULL;
9623 Ylen = PyArray_DIMS( tmp2 )[0];
9624 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9625 }
9626 {
9627 int i, size;
9628 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9629 if ( tmp3 == NULL )
9630 return NULL;
9631 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9632 {
9633 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9634 return NULL;
9635 }
9636 arg4 = PyArray_DIMS( tmp3 )[0];
9637 arg5 = PyArray_DIMS( tmp3 )[1];
9638 size = arg5;
9639 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9640 for ( i = 0; i < arg4; i++ )
9641 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9642 }
9643 ecode6 = SWIG_AsVal_int(obj3, &val6);
9644 if (!SWIG_IsOK(ecode6)) {
9645 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9646 }
9647 arg6 = (PLINT)(val6);
9648 {
9649 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9650 if ( tmp7 == NULL )
9651 return NULL;
9652 arg8 = PyArray_DIMS( tmp7 )[0];
9653 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9654 }
9655 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9656 resultobj = SWIG_Py_Void();
9657 {
9658 Py_CLEAR( tmp1 );
9659 }
9660 {
9661 Py_CLEAR( tmp2 );
9662 }
9663 {
9664 Py_CLEAR( tmp3 );
9665 free( arg3 );
9666 }
9667 {
9668 Py_CLEAR( tmp7 );
9669 }
9670 return resultobj;
9671 fail:
9672 {
9673 Py_CLEAR( tmp1 );
9674 }
9675 {
9676 Py_CLEAR( tmp2 );
9677 }
9678 {
9679 Py_CLEAR( tmp3 );
9680 free( arg3 );
9681 }
9682 {
9683 Py_CLEAR( tmp7 );
9684 }
9685 return NULL;
9686 }
9687
9688
9689 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9690 PyObject *resultobj = 0;
9691 PLFLT *arg1 = (PLFLT *) 0 ;
9692 PLFLT *arg2 = (PLFLT *) 0 ;
9693 PLFLT **arg3 = (PLFLT **) 0 ;
9694 PLINT arg4 ;
9695 PLINT arg5 ;
9696 PLINT arg6 ;
9697 PLFLT *arg7 = (PLFLT *) 0 ;
9698 PLINT arg8 ;
9699 PLINT arg9 ;
9700 PLINT arg10 ;
9701 PLINT *arg11 = (PLINT *) 0 ;
9702 PLINT *arg12 = (PLINT *) 0 ;
9703 PyArrayObject *tmp1 = NULL ;
9704 PyArrayObject *tmp2 = NULL ;
9705 PyArrayObject *tmp3 = NULL ;
9706 int val6 ;
9707 int ecode6 = 0 ;
9708 PyArrayObject *tmp7 = NULL ;
9709 int val9 ;
9710 int ecode9 = 0 ;
9711 PyArrayObject *tmp10 = NULL ;
9712 PyArrayObject *tmp12 = NULL ;
9713 PyObject * obj0 = 0 ;
9714 PyObject * obj1 = 0 ;
9715 PyObject * obj2 = 0 ;
9716 PyObject * obj3 = 0 ;
9717 PyObject * obj4 = 0 ;
9718 PyObject * obj5 = 0 ;
9719 PyObject * obj6 = 0 ;
9720 PyObject * obj7 = 0 ;
9721
9722 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9723 {
9724 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9725 if ( tmp1 == NULL )
9726 return NULL;
9727 Xlen = PyArray_DIMS( tmp1 )[0];
9728 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9729 }
9730 {
9731 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9732 if ( tmp2 == NULL )
9733 return NULL;
9734 Ylen = PyArray_DIMS( tmp2 )[0];
9735 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9736 }
9737 {
9738 int i, size;
9739 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9740 if ( tmp3 == NULL )
9741 return NULL;
9742 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9743 {
9744 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9745 return NULL;
9746 }
9747 arg4 = PyArray_DIMS( tmp3 )[0];
9748 arg5 = PyArray_DIMS( tmp3 )[1];
9749 size = arg5;
9750 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9751 for ( i = 0; i < arg4; i++ )
9752 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9753 }
9754 ecode6 = SWIG_AsVal_int(obj3, &val6);
9755 if (!SWIG_IsOK(ecode6)) {
9756 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9757 }
9758 arg6 = (PLINT)(val6);
9759 {
9760 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9761 if ( tmp7 == NULL )
9762 return NULL;
9763 arg8 = PyArray_DIMS( tmp7 )[0];
9764 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9765 }
9766 ecode9 = SWIG_AsVal_int(obj5, &val9);
9767 if (!SWIG_IsOK(ecode9)) {
9768 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9769 }
9770 arg9 = (PLINT)(val9);
9771 {
9772 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9773 if ( tmp10 == NULL )
9774 return NULL;
9775 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9776 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9777 }
9778 {
9779 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9780 if ( tmp12 == NULL )
9781 return NULL;
9782 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9783 {
9784 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9785 return NULL;
9786 }
9787 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9788 }
9789 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);
9790 resultobj = SWIG_Py_Void();
9791 {
9792 Py_CLEAR( tmp1 );
9793 }
9794 {
9795 Py_CLEAR( tmp2 );
9796 }
9797 {
9798 Py_CLEAR( tmp3 );
9799 free( arg3 );
9800 }
9801 {
9802 Py_CLEAR( tmp7 );
9803 }
9804 {
9805 Py_CLEAR( tmp10 );
9806 }
9807 {
9808 Py_CLEAR( tmp12 );
9809 }
9810 return resultobj;
9811 fail:
9812 {
9813 Py_CLEAR( tmp1 );
9814 }
9815 {
9816 Py_CLEAR( tmp2 );
9817 }
9818 {
9819 Py_CLEAR( tmp3 );
9820 free( arg3 );
9821 }
9822 {
9823 Py_CLEAR( tmp7 );
9824 }
9825 {
9826 Py_CLEAR( tmp10 );
9827 }
9828 {
9829 Py_CLEAR( tmp12 );
9830 }
9831 return NULL;
9832 }
9833
9834
9835 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9836 PyObject *resultobj = 0;
9837 int *arg1 = (int *) 0 ;
9838 char **arg2 = (char **) 0 ;
9839 PLINT arg3 ;
9840 int tmp1 ;
9841 int val3 ;
9842 int ecode3 = 0 ;
9843 PyObject * obj0 = 0 ;
9844 PyObject * obj1 = 0 ;
9845 PLINT result;
9846
9847 if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9848 {
9849 int i;
9850 PyObject *unicode_string;
9851
9852 if ( !PyList_Check( obj0 ) )
9853 {
9854 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9855 return NULL;
9856 }
9857 tmp1 = PyList_Size( obj0 );
9858 arg1 = &tmp1;
9859 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9860 for ( i = 0; i < tmp1; i++ )
9861 {
9862 PyObject *s = PyList_GetItem( obj0, i );
9863 if ( PyString_Check( s ) )
9864 {
9865 arg2[i] = PyString_AsString( s );
9866 }
9867 else if ( PyUnicode_Check( s ) )
9868 {
9869 // unicode_string is never freed? memory leak here?
9870 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9871 arg2[i] = PyBytes_AS_STRING( unicode_string );
9872 }
9873 else
9874 {
9875 free( arg2 );
9876 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9877 return NULL;
9878 }
9879 }
9880 arg2[i] = 0;
9881 }
9882 ecode3 = SWIG_AsVal_int(obj1, &val3);
9883 if (!SWIG_IsOK(ecode3)) {
9884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9885 }
9886 arg3 = (PLINT)(val3);
9887 result = (PLINT)plparseopts(arg1,arg2,arg3);
9888 resultobj = SWIG_From_int((int)(result));
9889 {
9890 if ( arg2 )
9891 free( arg2 );
9892 }
9893 return resultobj;
9894 fail:
9895 {
9896 if ( arg2 )
9897 free( arg2 );
9898 }
9899 return NULL;
9900 }
9901
9902
9903 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9904 PyObject *resultobj = 0;
9905 PLINT arg1 ;
9906 PLINT *arg2 = (PLINT *) 0 ;
9907 PLINT *arg3 = (PLINT *) 0 ;
9908 PyArrayObject *tmp1 = NULL ;
9909 PyArrayObject *tmp3 = NULL ;
9910 PyObject * obj0 = 0 ;
9911 PyObject * obj1 = 0 ;
9912
9913 if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9914 {
9915 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9916 if ( tmp1 == NULL )
9917 return NULL;
9918 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9919 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9920 }
9921 {
9922 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9923 if ( tmp3 == NULL )
9924 return NULL;
9925 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9926 {
9927 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9928 return NULL;
9929 }
9930 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9931 }
9932 plpat(arg1,(int const *)arg2,(int const *)arg3);
9933 resultobj = SWIG_Py_Void();
9934 {
9935 Py_CLEAR( tmp1 );
9936 }
9937 {
9938 Py_CLEAR( tmp3 );
9939 }
9940 return resultobj;
9941 fail:
9942 {
9943 Py_CLEAR( tmp1 );
9944 }
9945 {
9946 Py_CLEAR( tmp3 );
9947 }
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 PyObject *resultobj = 0;
9954 PLINT arg1 ;
9955 PLFLT arg2 ;
9956 PLFLT arg3 ;
9957 PLFLT arg4 ;
9958 PLFLT arg5 ;
9959 int val1 ;
9960 int ecode1 = 0 ;
9961 double val2 ;
9962 int ecode2 = 0 ;
9963 double val3 ;
9964 int ecode3 = 0 ;
9965 double val4 ;
9966 int ecode4 = 0 ;
9967 double val5 ;
9968 int ecode5 = 0 ;
9969 PyObject * obj0 = 0 ;
9970 PyObject * obj1 = 0 ;
9971 PyObject * obj2 = 0 ;
9972 PyObject * obj3 = 0 ;
9973 PyObject * obj4 = 0 ;
9974
9975 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9976 ecode1 = SWIG_AsVal_int(obj0, &val1);
9977 if (!SWIG_IsOK(ecode1)) {
9978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9979 }
9980 arg1 = (PLINT)(val1);
9981 ecode2 = SWIG_AsVal_double(obj1, &val2);
9982 if (!SWIG_IsOK(ecode2)) {
9983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9984 }
9985 arg2 = (PLFLT)(val2);
9986 ecode3 = SWIG_AsVal_double(obj2, &val3);
9987 if (!SWIG_IsOK(ecode3)) {
9988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9989 }
9990 arg3 = (PLFLT)(val3);
9991 ecode4 = SWIG_AsVal_double(obj3, &val4);
9992 if (!SWIG_IsOK(ecode4)) {
9993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9994 }
9995 arg4 = (PLFLT)(val4);
9996 ecode5 = SWIG_AsVal_double(obj4, &val5);
9997 if (!SWIG_IsOK(ecode5)) {
9998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9999 }
10000 arg5 = (PLFLT)(val5);
10001 plpath(arg1,arg2,arg3,arg4,arg5);
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10010 PyObject *resultobj = 0;
10011 PLINT arg1 ;
10012 PLFLT *arg2 = (PLFLT *) 0 ;
10013 PLFLT *arg3 = (PLFLT *) 0 ;
10014 PLINT arg4 ;
10015 PyArrayObject *tmp1 = NULL ;
10016 PyArrayObject *tmp3 = NULL ;
10017 int val4 ;
10018 int ecode4 = 0 ;
10019 PyObject * obj0 = 0 ;
10020 PyObject * obj1 = 0 ;
10021 PyObject * obj2 = 0 ;
10022
10023 if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
10024 {
10025 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10026 if ( tmp1 == NULL )
10027 return NULL;
10028 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10029 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10030 }
10031 {
10032 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10033 if ( tmp3 == NULL )
10034 return NULL;
10035 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10036 {
10037 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10038 return NULL;
10039 }
10040 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10041 }
10042 ecode4 = SWIG_AsVal_int(obj2, &val4);
10043 if (!SWIG_IsOK(ecode4)) {
10044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10045 }
10046 arg4 = (PLINT)(val4);
10047 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10048 resultobj = SWIG_Py_Void();
10049 {
10050 Py_CLEAR( tmp1 );
10051 }
10052 {
10053 Py_CLEAR( tmp3 );
10054 }
10055 return resultobj;
10056 fail:
10057 {
10058 Py_CLEAR( tmp1 );
10059 }
10060 {
10061 Py_CLEAR( tmp3 );
10062 }
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10068 PyObject *resultobj = 0;
10069 PLINT arg1 ;
10070 PLFLT *arg2 = (PLFLT *) 0 ;
10071 PLFLT *arg3 = (PLFLT *) 0 ;
10072 PLFLT *arg4 = (PLFLT *) 0 ;
10073 PLINT arg5 ;
10074 PyArrayObject *tmp1 = NULL ;
10075 PyArrayObject *tmp3 = NULL ;
10076 PyArrayObject *tmp4 = NULL ;
10077 int val5 ;
10078 int ecode5 = 0 ;
10079 PyObject * obj0 = 0 ;
10080 PyObject * obj1 = 0 ;
10081 PyObject * obj2 = 0 ;
10082 PyObject * obj3 = 0 ;
10083
10084 if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10085 {
10086 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10087 if ( tmp1 == NULL )
10088 return NULL;
10089 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10090 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10091 }
10092 {
10093 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10094 if ( tmp3 == NULL )
10095 return NULL;
10096 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10097 {
10098 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10099 return NULL;
10100 }
10101 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10102 }
10103 {
10104 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10105 if ( tmp4 == NULL )
10106 return NULL;
10107 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10108 {
10109 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10110 return NULL;
10111 }
10112 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10113 }
10114 ecode5 = SWIG_AsVal_int(obj3, &val5);
10115 if (!SWIG_IsOK(ecode5)) {
10116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10117 }
10118 arg5 = (PLINT)(val5);
10119 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10120 resultobj = SWIG_Py_Void();
10121 {
10122 Py_CLEAR( tmp1 );
10123 }
10124 {
10125 Py_CLEAR( tmp3 );
10126 }
10127 {
10128 Py_CLEAR( tmp4 );
10129 }
10130 return resultobj;
10131 fail:
10132 {
10133 Py_CLEAR( tmp1 );
10134 }
10135 {
10136 Py_CLEAR( tmp3 );
10137 }
10138 {
10139 Py_CLEAR( tmp4 );
10140 }
10141 return NULL;
10142 }
10143
10144
10145 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10146 PyObject *resultobj = 0;
10147 PLINT arg1 ;
10148 PLFLT *arg2 = (PLFLT *) 0 ;
10149 PLFLT *arg3 = (PLFLT *) 0 ;
10150 PLFLT *arg4 = (PLFLT *) 0 ;
10151 PLBOOL *arg5 = (PLBOOL *) 0 ;
10152 PLBOOL arg6 ;
10153 PyArrayObject *tmp1 = NULL ;
10154 PyArrayObject *tmp3 = NULL ;
10155 PyArrayObject *tmp4 = NULL ;
10156 PyArrayObject *tmp5 = NULL ;
10157 int val6 ;
10158 int ecode6 = 0 ;
10159 PyObject * obj0 = 0 ;
10160 PyObject * obj1 = 0 ;
10161 PyObject * obj2 = 0 ;
10162 PyObject * obj3 = 0 ;
10163 PyObject * obj4 = 0 ;
10164
10165 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10166 {
10167 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10168 if ( tmp1 == NULL )
10169 return NULL;
10170 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10171 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10172 }
10173 {
10174 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10175 if ( tmp3 == NULL )
10176 return NULL;
10177 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10178 {
10179 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10180 return NULL;
10181 }
10182 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10183 }
10184 {
10185 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10186 if ( tmp4 == NULL )
10187 return NULL;
10188 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10189 {
10190 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10191 return NULL;
10192 }
10193 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10194 }
10195 {
10196 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10197 if ( tmp5 == NULL )
10198 return NULL;
10199 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10200 {
10201 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10202 return NULL;
10203 }
10204 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10205 }
10206 ecode6 = SWIG_AsVal_int(obj4, &val6);
10207 if (!SWIG_IsOK(ecode6)) {
10208 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10209 }
10210 arg6 = (PLBOOL)(val6);
10211 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10212 resultobj = SWIG_Py_Void();
10213 {
10214 Py_CLEAR( tmp1 );
10215 }
10216 {
10217 Py_CLEAR( tmp3 );
10218 }
10219 {
10220 Py_CLEAR( tmp4 );
10221 }
10222 {
10223 Py_CLEAR( tmp5 );
10224 }
10225 return resultobj;
10226 fail:
10227 {
10228 Py_CLEAR( tmp1 );
10229 }
10230 {
10231 Py_CLEAR( tmp3 );
10232 }
10233 {
10234 Py_CLEAR( tmp4 );
10235 }
10236 {
10237 Py_CLEAR( tmp5 );
10238 }
10239 return NULL;
10240 }
10241
10242
10243 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10244 PyObject *resultobj = 0;
10245 PLINT arg1 ;
10246 PLINT arg2 ;
10247 int val1 ;
10248 int ecode1 = 0 ;
10249 int val2 ;
10250 int ecode2 = 0 ;
10251 PyObject * obj0 = 0 ;
10252 PyObject * obj1 = 0 ;
10253
10254 if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10255 ecode1 = SWIG_AsVal_int(obj0, &val1);
10256 if (!SWIG_IsOK(ecode1)) {
10257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10258 }
10259 arg1 = (PLINT)(val1);
10260 ecode2 = SWIG_AsVal_int(obj1, &val2);
10261 if (!SWIG_IsOK(ecode2)) {
10262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10263 }
10264 arg2 = (PLINT)(val2);
10265 plprec(arg1,arg2);
10266 resultobj = SWIG_Py_Void();
10267 return resultobj;
10268 fail:
10269 return NULL;
10270 }
10271
10272
10273 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10274 PyObject *resultobj = 0;
10275 PLINT arg1 ;
10276 int val1 ;
10277 int ecode1 = 0 ;
10278 PyObject * obj0 = 0 ;
10279
10280 if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10281 ecode1 = SWIG_AsVal_int(obj0, &val1);
10282 if (!SWIG_IsOK(ecode1)) {
10283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10284 }
10285 arg1 = (PLINT)(val1);
10286 plpsty(arg1);
10287 resultobj = SWIG_Py_Void();
10288 return resultobj;
10289 fail:
10290 return NULL;
10291 }
10292
10293
10294 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 PLFLT arg1 ;
10297 PLFLT arg2 ;
10298 PLFLT arg3 ;
10299 PLFLT arg4 ;
10300 PLFLT arg5 ;
10301 char *arg6 = (char *) 0 ;
10302 double val1 ;
10303 int ecode1 = 0 ;
10304 double val2 ;
10305 int ecode2 = 0 ;
10306 double val3 ;
10307 int ecode3 = 0 ;
10308 double val4 ;
10309 int ecode4 = 0 ;
10310 double val5 ;
10311 int ecode5 = 0 ;
10312 int res6 ;
10313 char *buf6 = 0 ;
10314 int alloc6 = 0 ;
10315 PyObject * obj0 = 0 ;
10316 PyObject * obj1 = 0 ;
10317 PyObject * obj2 = 0 ;
10318 PyObject * obj3 = 0 ;
10319 PyObject * obj4 = 0 ;
10320 PyObject * obj5 = 0 ;
10321
10322 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10323 ecode1 = SWIG_AsVal_double(obj0, &val1);
10324 if (!SWIG_IsOK(ecode1)) {
10325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10326 }
10327 arg1 = (PLFLT)(val1);
10328 ecode2 = SWIG_AsVal_double(obj1, &val2);
10329 if (!SWIG_IsOK(ecode2)) {
10330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10331 }
10332 arg2 = (PLFLT)(val2);
10333 ecode3 = SWIG_AsVal_double(obj2, &val3);
10334 if (!SWIG_IsOK(ecode3)) {
10335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10336 }
10337 arg3 = (PLFLT)(val3);
10338 ecode4 = SWIG_AsVal_double(obj3, &val4);
10339 if (!SWIG_IsOK(ecode4)) {
10340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10341 }
10342 arg4 = (PLFLT)(val4);
10343 ecode5 = SWIG_AsVal_double(obj4, &val5);
10344 if (!SWIG_IsOK(ecode5)) {
10345 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10346 }
10347 arg5 = (PLFLT)(val5);
10348 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10349 if (!SWIG_IsOK(res6)) {
10350 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10351 }
10352 arg6 = (char *)(buf6);
10353 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10354 resultobj = SWIG_Py_Void();
10355 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10356 return resultobj;
10357 fail:
10358 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10359 return NULL;
10360 }
10361
10362
10363 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10364 PyObject *resultobj = 0;
10365 PLFLT arg1 ;
10366 PLFLT arg2 ;
10367 PLFLT arg3 ;
10368 PLFLT arg4 ;
10369 PLFLT arg5 ;
10370 PLFLT arg6 ;
10371 PLFLT arg7 ;
10372 PLFLT arg8 ;
10373 PLFLT arg9 ;
10374 PLFLT arg10 ;
10375 char *arg11 = (char *) 0 ;
10376 double val1 ;
10377 int ecode1 = 0 ;
10378 double val2 ;
10379 int ecode2 = 0 ;
10380 double val3 ;
10381 int ecode3 = 0 ;
10382 double val4 ;
10383 int ecode4 = 0 ;
10384 double val5 ;
10385 int ecode5 = 0 ;
10386 double val6 ;
10387 int ecode6 = 0 ;
10388 double val7 ;
10389 int ecode7 = 0 ;
10390 double val8 ;
10391 int ecode8 = 0 ;
10392 double val9 ;
10393 int ecode9 = 0 ;
10394 double val10 ;
10395 int ecode10 = 0 ;
10396 int res11 ;
10397 char *buf11 = 0 ;
10398 int alloc11 = 0 ;
10399 PyObject * obj0 = 0 ;
10400 PyObject * obj1 = 0 ;
10401 PyObject * obj2 = 0 ;
10402 PyObject * obj3 = 0 ;
10403 PyObject * obj4 = 0 ;
10404 PyObject * obj5 = 0 ;
10405 PyObject * obj6 = 0 ;
10406 PyObject * obj7 = 0 ;
10407 PyObject * obj8 = 0 ;
10408 PyObject * obj9 = 0 ;
10409 PyObject * obj10 = 0 ;
10410
10411 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10412 ecode1 = SWIG_AsVal_double(obj0, &val1);
10413 if (!SWIG_IsOK(ecode1)) {
10414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10415 }
10416 arg1 = (PLFLT)(val1);
10417 ecode2 = SWIG_AsVal_double(obj1, &val2);
10418 if (!SWIG_IsOK(ecode2)) {
10419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10420 }
10421 arg2 = (PLFLT)(val2);
10422 ecode3 = SWIG_AsVal_double(obj2, &val3);
10423 if (!SWIG_IsOK(ecode3)) {
10424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10425 }
10426 arg3 = (PLFLT)(val3);
10427 ecode4 = SWIG_AsVal_double(obj3, &val4);
10428 if (!SWIG_IsOK(ecode4)) {
10429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10430 }
10431 arg4 = (PLFLT)(val4);
10432 ecode5 = SWIG_AsVal_double(obj4, &val5);
10433 if (!SWIG_IsOK(ecode5)) {
10434 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10435 }
10436 arg5 = (PLFLT)(val5);
10437 ecode6 = SWIG_AsVal_double(obj5, &val6);
10438 if (!SWIG_IsOK(ecode6)) {
10439 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10440 }
10441 arg6 = (PLFLT)(val6);
10442 ecode7 = SWIG_AsVal_double(obj6, &val7);
10443 if (!SWIG_IsOK(ecode7)) {
10444 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10445 }
10446 arg7 = (PLFLT)(val7);
10447 ecode8 = SWIG_AsVal_double(obj7, &val8);
10448 if (!SWIG_IsOK(ecode8)) {
10449 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10450 }
10451 arg8 = (PLFLT)(val8);
10452 ecode9 = SWIG_AsVal_double(obj8, &val9);
10453 if (!SWIG_IsOK(ecode9)) {
10454 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10455 }
10456 arg9 = (PLFLT)(val9);
10457 ecode10 = SWIG_AsVal_double(obj9, &val10);
10458 if (!SWIG_IsOK(ecode10)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10460 }
10461 arg10 = (PLFLT)(val10);
10462 res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10463 if (!SWIG_IsOK(res11)) {
10464 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10465 }
10466 arg11 = (char *)(buf11);
10467 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10468 resultobj = SWIG_Py_Void();
10469 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10470 return resultobj;
10471 fail:
10472 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10473 return NULL;
10474 }
10475
10476
10477 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10478 PyObject *resultobj = 0;
10479 PLFLT result;
10480
10481 if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10482 result = (PLFLT)plrandd();
10483 resultobj = SWIG_From_double((double)(result));
10484 return resultobj;
10485 fail:
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10491 PyObject *resultobj = 0;
10492
10493 if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10494 plreplot();
10495 resultobj = SWIG_Py_Void();
10496 return resultobj;
10497 fail:
10498 return NULL;
10499 }
10500
10501
10502 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10503 PyObject *resultobj = 0;
10504 PLFLT arg1 ;
10505 PLFLT arg2 ;
10506 PLFLT arg3 ;
10507 PLFLT *arg4 = (PLFLT *) 0 ;
10508 PLFLT *arg5 = (PLFLT *) 0 ;
10509 PLFLT *arg6 = (PLFLT *) 0 ;
10510 double val1 ;
10511 int ecode1 = 0 ;
10512 double val2 ;
10513 int ecode2 = 0 ;
10514 double val3 ;
10515 int ecode3 = 0 ;
10516 PLFLT temp4 ;
10517 int res4 = SWIG_TMPOBJ ;
10518 PLFLT temp5 ;
10519 int res5 = SWIG_TMPOBJ ;
10520 PLFLT temp6 ;
10521 int res6 = SWIG_TMPOBJ ;
10522 PyObject * obj0 = 0 ;
10523 PyObject * obj1 = 0 ;
10524 PyObject * obj2 = 0 ;
10525
10526 arg4 = &temp4;
10527 arg5 = &temp5;
10528 arg6 = &temp6;
10529 if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10530 ecode1 = SWIG_AsVal_double(obj0, &val1);
10531 if (!SWIG_IsOK(ecode1)) {
10532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10533 }
10534 arg1 = (PLFLT)(val1);
10535 ecode2 = SWIG_AsVal_double(obj1, &val2);
10536 if (!SWIG_IsOK(ecode2)) {
10537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10538 }
10539 arg2 = (PLFLT)(val2);
10540 ecode3 = SWIG_AsVal_double(obj2, &val3);
10541 if (!SWIG_IsOK(ecode3)) {
10542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10543 }
10544 arg3 = (PLFLT)(val3);
10545 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10546 resultobj = SWIG_Py_Void();
10547 if (SWIG_IsTmpObj(res4)) {
10548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10549 } else {
10550 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10552 }
10553 if (SWIG_IsTmpObj(res5)) {
10554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10555 } else {
10556 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10558 }
10559 if (SWIG_IsTmpObj(res6)) {
10560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10561 } else {
10562 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10564 }
10565 return resultobj;
10566 fail:
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10572 PyObject *resultobj = 0;
10573 PLFLT arg1 ;
10574 PLFLT arg2 ;
10575 double val1 ;
10576 int ecode1 = 0 ;
10577 double val2 ;
10578 int ecode2 = 0 ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581
10582 if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10583 ecode1 = SWIG_AsVal_double(obj0, &val1);
10584 if (!SWIG_IsOK(ecode1)) {
10585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10586 }
10587 arg1 = (PLFLT)(val1);
10588 ecode2 = SWIG_AsVal_double(obj1, &val2);
10589 if (!SWIG_IsOK(ecode2)) {
10590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10591 }
10592 arg2 = (PLFLT)(val2);
10593 plschr(arg1,arg2);
10594 resultobj = SWIG_Py_Void();
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602 PyObject *resultobj = 0;
10603 PLINT *arg1 = (PLINT *) 0 ;
10604 PLINT *arg2 = (PLINT *) 0 ;
10605 PLINT *arg3 = (PLINT *) 0 ;
10606 PLINT arg4 ;
10607 PyArrayObject *tmp1 = NULL ;
10608 PyArrayObject *tmp2 = NULL ;
10609 PyArrayObject *tmp3 = NULL ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 PyObject * obj2 = 0 ;
10613
10614 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10615 {
10616 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10617 if ( tmp1 == NULL )
10618 return NULL;
10619 Alen = PyArray_DIMS( tmp1 )[0];
10620 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10621 }
10622 {
10623 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10624 if ( tmp2 == NULL )
10625 return NULL;
10626 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10627 {
10628 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10629 return NULL;
10630 }
10631 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10632 }
10633 {
10634 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10635 if ( tmp3 == NULL )
10636 return NULL;
10637 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10638 {
10639 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10640 return NULL;
10641 }
10642 arg4 = PyArray_DIMS( tmp3 )[0];
10643 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10644 }
10645 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10646 resultobj = SWIG_Py_Void();
10647 {
10648 Py_CLEAR( tmp1 );
10649 }
10650 {
10651 Py_CLEAR( tmp2 );
10652 }
10653 {
10654 Py_CLEAR( tmp3 );
10655 }
10656 return resultobj;
10657 fail:
10658 {
10659 Py_CLEAR( tmp1 );
10660 }
10661 {
10662 Py_CLEAR( tmp2 );
10663 }
10664 {
10665 Py_CLEAR( tmp3 );
10666 }
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10672 PyObject *resultobj = 0;
10673 PLINT *arg1 = (PLINT *) 0 ;
10674 PLINT *arg2 = (PLINT *) 0 ;
10675 PLINT *arg3 = (PLINT *) 0 ;
10676 PLFLT *arg4 = (PLFLT *) 0 ;
10677 PLINT arg5 ;
10678 PyArrayObject *tmp1 = NULL ;
10679 PyArrayObject *tmp2 = NULL ;
10680 PyArrayObject *tmp3 = NULL ;
10681 PyArrayObject *tmp4 = NULL ;
10682 PyObject * obj0 = 0 ;
10683 PyObject * obj1 = 0 ;
10684 PyObject * obj2 = 0 ;
10685 PyObject * obj3 = 0 ;
10686
10687 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10688 {
10689 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10690 if ( tmp1 == NULL )
10691 return NULL;
10692 Alen = PyArray_DIMS( tmp1 )[0];
10693 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10694 }
10695 {
10696 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10697 if ( tmp2 == NULL )
10698 return NULL;
10699 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10700 {
10701 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10702 return NULL;
10703 }
10704 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10705 }
10706 {
10707 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10708 if ( tmp3 == NULL )
10709 return NULL;
10710 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10711 {
10712 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10713 return NULL;
10714 }
10715 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10716 }
10717 {
10718 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10719 if ( tmp4 == NULL )
10720 return NULL;
10721 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10722 {
10723 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10724 return NULL;
10725 }
10726 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10727 arg5 = PyArray_DIMS( tmp4 )[0];
10728 }
10729 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10730 resultobj = SWIG_Py_Void();
10731 {
10732 Py_CLEAR( tmp1 );
10733 }
10734 {
10735 Py_CLEAR( tmp2 );
10736 }
10737 {
10738 Py_CLEAR( tmp3 );
10739 }
10740 {
10741 Py_CLEAR( tmp4 );
10742 }
10743 return resultobj;
10744 fail:
10745 {
10746 Py_CLEAR( tmp1 );
10747 }
10748 {
10749 Py_CLEAR( tmp2 );
10750 }
10751 {
10752 Py_CLEAR( tmp3 );
10753 }
10754 {
10755 Py_CLEAR( tmp4 );
10756 }
10757 return NULL;
10758 }
10759
10760
10761 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10762 PyObject *resultobj = 0;
10763 PLINT arg1 ;
10764 int val1 ;
10765 int ecode1 = 0 ;
10766 PyObject * obj0 = 0 ;
10767
10768 if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10769 ecode1 = SWIG_AsVal_int(obj0, &val1);
10770 if (!SWIG_IsOK(ecode1)) {
10771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10772 }
10773 arg1 = (PLINT)(val1);
10774 plscmap0n(arg1);
10775 resultobj = SWIG_Py_Void();
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *resultobj = 0;
10784 PLINT *arg1 = (PLINT *) 0 ;
10785 PLINT *arg2 = (PLINT *) 0 ;
10786 PLINT *arg3 = (PLINT *) 0 ;
10787 PLINT arg4 ;
10788 PyArrayObject *tmp1 = NULL ;
10789 PyArrayObject *tmp2 = NULL ;
10790 PyArrayObject *tmp3 = NULL ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 PyObject * obj2 = 0 ;
10794
10795 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10796 {
10797 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10798 if ( tmp1 == NULL )
10799 return NULL;
10800 Alen = PyArray_DIMS( tmp1 )[0];
10801 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10802 }
10803 {
10804 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10805 if ( tmp2 == NULL )
10806 return NULL;
10807 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10808 {
10809 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10810 return NULL;
10811 }
10812 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10813 }
10814 {
10815 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10816 if ( tmp3 == NULL )
10817 return NULL;
10818 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10819 {
10820 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10821 return NULL;
10822 }
10823 arg4 = PyArray_DIMS( tmp3 )[0];
10824 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10825 }
10826 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10827 resultobj = SWIG_Py_Void();
10828 {
10829 Py_CLEAR( tmp1 );
10830 }
10831 {
10832 Py_CLEAR( tmp2 );
10833 }
10834 {
10835 Py_CLEAR( tmp3 );
10836 }
10837 return resultobj;
10838 fail:
10839 {
10840 Py_CLEAR( tmp1 );
10841 }
10842 {
10843 Py_CLEAR( tmp2 );
10844 }
10845 {
10846 Py_CLEAR( tmp3 );
10847 }
10848 return NULL;
10849 }
10850
10851
10852 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10853 PyObject *resultobj = 0;
10854 PLINT *arg1 = (PLINT *) 0 ;
10855 PLINT *arg2 = (PLINT *) 0 ;
10856 PLINT *arg3 = (PLINT *) 0 ;
10857 PLFLT *arg4 = (PLFLT *) 0 ;
10858 PLINT arg5 ;
10859 PyArrayObject *tmp1 = NULL ;
10860 PyArrayObject *tmp2 = NULL ;
10861 PyArrayObject *tmp3 = NULL ;
10862 PyArrayObject *tmp4 = NULL ;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 PyObject * obj2 = 0 ;
10866 PyObject * obj3 = 0 ;
10867
10868 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10869 {
10870 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10871 if ( tmp1 == NULL )
10872 return NULL;
10873 Alen = PyArray_DIMS( tmp1 )[0];
10874 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10875 }
10876 {
10877 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10878 if ( tmp2 == NULL )
10879 return NULL;
10880 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10881 {
10882 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10883 return NULL;
10884 }
10885 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10886 }
10887 {
10888 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10889 if ( tmp3 == NULL )
10890 return NULL;
10891 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10892 {
10893 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10894 return NULL;
10895 }
10896 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10897 }
10898 {
10899 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10900 if ( tmp4 == NULL )
10901 return NULL;
10902 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10903 {
10904 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10905 return NULL;
10906 }
10907 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10908 arg5 = PyArray_DIMS( tmp4 )[0];
10909 }
10910 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10911 resultobj = SWIG_Py_Void();
10912 {
10913 Py_CLEAR( tmp1 );
10914 }
10915 {
10916 Py_CLEAR( tmp2 );
10917 }
10918 {
10919 Py_CLEAR( tmp3 );
10920 }
10921 {
10922 Py_CLEAR( tmp4 );
10923 }
10924 return resultobj;
10925 fail:
10926 {
10927 Py_CLEAR( tmp1 );
10928 }
10929 {
10930 Py_CLEAR( tmp2 );
10931 }
10932 {
10933 Py_CLEAR( tmp3 );
10934 }
10935 {
10936 Py_CLEAR( tmp4 );
10937 }
10938 return NULL;
10939 }
10940
10941
10942 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10943 PyObject *resultobj = 0;
10944 PLBOOL arg1 ;
10945 PLINT arg2 ;
10946 PLFLT *arg3 = (PLFLT *) 0 ;
10947 PLFLT *arg4 = (PLFLT *) 0 ;
10948 PLFLT *arg5 = (PLFLT *) 0 ;
10949 PLFLT *arg6 = (PLFLT *) 0 ;
10950 PLBOOL *arg7 = (PLBOOL *) 0 ;
10951 int val1 ;
10952 int ecode1 = 0 ;
10953 PyArrayObject *tmp2 = NULL ;
10954 PyArrayObject *tmp4 = NULL ;
10955 PyArrayObject *tmp5 = NULL ;
10956 PyArrayObject *tmp6 = NULL ;
10957 PyArrayObject *tmp7 = NULL ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 PyObject * obj2 = 0 ;
10961 PyObject * obj3 = 0 ;
10962 PyObject * obj4 = 0 ;
10963 PyObject * obj5 = 0 ;
10964
10965 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10966 ecode1 = SWIG_AsVal_int(obj0, &val1);
10967 if (!SWIG_IsOK(ecode1)) {
10968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10969 }
10970 arg1 = (PLBOOL)(val1);
10971 {
10972 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10973 if ( tmp2 == NULL )
10974 return NULL;
10975 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10976 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10977 }
10978 {
10979 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10980 if ( tmp4 == NULL )
10981 return NULL;
10982 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10983 {
10984 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10985 return NULL;
10986 }
10987 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10988 }
10989 {
10990 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10991 if ( tmp5 == NULL )
10992 return NULL;
10993 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10994 {
10995 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10996 return NULL;
10997 }
10998 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10999 }
11000 {
11001 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
11002 if ( tmp6 == NULL )
11003 return NULL;
11004 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11005 {
11006 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11007 return NULL;
11008 }
11009 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11010 }
11011 {
11012 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
11013 if ( tmp7 == NULL )
11014 return NULL;
11015 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11016 {
11017 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11018 return NULL;
11019 }
11020 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11021 }
11022 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11023 resultobj = SWIG_Py_Void();
11024 {
11025 Py_CLEAR( tmp2 );
11026 }
11027 {
11028 Py_CLEAR( tmp4 );
11029 }
11030 {
11031 Py_CLEAR( tmp5 );
11032 }
11033 {
11034 Py_CLEAR( tmp6 );
11035 }
11036 {
11037 Py_CLEAR( tmp7 );
11038 }
11039 return resultobj;
11040 fail:
11041 {
11042 Py_CLEAR( tmp2 );
11043 }
11044 {
11045 Py_CLEAR( tmp4 );
11046 }
11047 {
11048 Py_CLEAR( tmp5 );
11049 }
11050 {
11051 Py_CLEAR( tmp6 );
11052 }
11053 {
11054 Py_CLEAR( tmp7 );
11055 }
11056 return NULL;
11057 }
11058
11059
11060 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11061 PyObject *resultobj = 0;
11062 PLBOOL arg1 ;
11063 PLINT arg2 ;
11064 PLFLT *arg3 = (PLFLT *) 0 ;
11065 PLFLT *arg4 = (PLFLT *) 0 ;
11066 PLFLT *arg5 = (PLFLT *) 0 ;
11067 PLFLT *arg6 = (PLFLT *) 0 ;
11068 PLFLT *arg7 = (PLFLT *) 0 ;
11069 PLBOOL *arg8 = (PLBOOL *) 0 ;
11070 int val1 ;
11071 int ecode1 = 0 ;
11072 PyArrayObject *tmp2 = NULL ;
11073 PyArrayObject *tmp4 = NULL ;
11074 PyArrayObject *tmp5 = NULL ;
11075 PyArrayObject *tmp6 = NULL ;
11076 PyArrayObject *tmp7 = NULL ;
11077 PyArrayObject *tmp8 = NULL ;
11078 PyObject * obj0 = 0 ;
11079 PyObject * obj1 = 0 ;
11080 PyObject * obj2 = 0 ;
11081 PyObject * obj3 = 0 ;
11082 PyObject * obj4 = 0 ;
11083 PyObject * obj5 = 0 ;
11084 PyObject * obj6 = 0 ;
11085
11086 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11087 ecode1 = SWIG_AsVal_int(obj0, &val1);
11088 if (!SWIG_IsOK(ecode1)) {
11089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11090 }
11091 arg1 = (PLBOOL)(val1);
11092 {
11093 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
11094 if ( tmp2 == NULL )
11095 return NULL;
11096 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11097 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11098 }
11099 {
11100 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
11101 if ( tmp4 == NULL )
11102 return NULL;
11103 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11104 {
11105 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11106 return NULL;
11107 }
11108 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11109 }
11110 {
11111 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
11112 if ( tmp5 == NULL )
11113 return NULL;
11114 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11115 {
11116 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11117 return NULL;
11118 }
11119 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11120 }
11121 {
11122 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
11123 if ( tmp6 == NULL )
11124 return NULL;
11125 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11126 {
11127 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11128 return NULL;
11129 }
11130 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11131 }
11132 {
11133 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11134 if ( tmp7 == NULL )
11135 return NULL;
11136 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11137 {
11138 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11139 return NULL;
11140 }
11141 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11142 }
11143 {
11144 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
11145 if ( tmp8 == NULL )
11146 return NULL;
11147 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11148 {
11149 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11150 return NULL;
11151 }
11152 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11153 }
11154 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11155 resultobj = SWIG_Py_Void();
11156 {
11157 Py_CLEAR( tmp2 );
11158 }
11159 {
11160 Py_CLEAR( tmp4 );
11161 }
11162 {
11163 Py_CLEAR( tmp5 );
11164 }
11165 {
11166 Py_CLEAR( tmp6 );
11167 }
11168 {
11169 Py_CLEAR( tmp7 );
11170 }
11171 {
11172 Py_CLEAR( tmp8 );
11173 }
11174 return resultobj;
11175 fail:
11176 {
11177 Py_CLEAR( tmp2 );
11178 }
11179 {
11180 Py_CLEAR( tmp4 );
11181 }
11182 {
11183 Py_CLEAR( tmp5 );
11184 }
11185 {
11186 Py_CLEAR( tmp6 );
11187 }
11188 {
11189 Py_CLEAR( tmp7 );
11190 }
11191 {
11192 Py_CLEAR( tmp8 );
11193 }
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200 PLINT arg1 ;
11201 int val1 ;
11202 int ecode1 = 0 ;
11203 PyObject * obj0 = 0 ;
11204
11205 if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11206 ecode1 = SWIG_AsVal_int(obj0, &val1);
11207 if (!SWIG_IsOK(ecode1)) {
11208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11209 }
11210 arg1 = (PLINT)(val1);
11211 plscmap1n(arg1);
11212 resultobj = SWIG_Py_Void();
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11220 PyObject *resultobj = 0;
11221 PLFLT arg1 ;
11222 PLFLT arg2 ;
11223 double val1 ;
11224 int ecode1 = 0 ;
11225 double val2 ;
11226 int ecode2 = 0 ;
11227 PyObject * obj0 = 0 ;
11228 PyObject * obj1 = 0 ;
11229
11230 if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11231 ecode1 = SWIG_AsVal_double(obj0, &val1);
11232 if (!SWIG_IsOK(ecode1)) {
11233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11234 }
11235 arg1 = (PLFLT)(val1);
11236 ecode2 = SWIG_AsVal_double(obj1, &val2);
11237 if (!SWIG_IsOK(ecode2)) {
11238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11239 }
11240 arg2 = (PLFLT)(val2);
11241 plscmap1_range(arg1,arg2);
11242 resultobj = SWIG_Py_Void();
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *resultobj = 0;
11251 PLFLT *arg1 = (PLFLT *) 0 ;
11252 PLFLT *arg2 = (PLFLT *) 0 ;
11253 PLFLT temp1 ;
11254 int res1 = SWIG_TMPOBJ ;
11255 PLFLT temp2 ;
11256 int res2 = SWIG_TMPOBJ ;
11257
11258 arg1 = &temp1;
11259 arg2 = &temp2;
11260 if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11261 plgcmap1_range(arg1,arg2);
11262 resultobj = SWIG_Py_Void();
11263 if (SWIG_IsTmpObj(res1)) {
11264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11265 } else {
11266 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11268 }
11269 if (SWIG_IsTmpObj(res2)) {
11270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11271 } else {
11272 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11274 }
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282 PyObject *resultobj = 0;
11283 PLINT arg1 ;
11284 PLINT arg2 ;
11285 PLINT arg3 ;
11286 PLINT arg4 ;
11287 int val1 ;
11288 int ecode1 = 0 ;
11289 int val2 ;
11290 int ecode2 = 0 ;
11291 int val3 ;
11292 int ecode3 = 0 ;
11293 int val4 ;
11294 int ecode4 = 0 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 PyObject * obj3 = 0 ;
11299
11300 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11301 ecode1 = SWIG_AsVal_int(obj0, &val1);
11302 if (!SWIG_IsOK(ecode1)) {
11303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11304 }
11305 arg1 = (PLINT)(val1);
11306 ecode2 = SWIG_AsVal_int(obj1, &val2);
11307 if (!SWIG_IsOK(ecode2)) {
11308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11309 }
11310 arg2 = (PLINT)(val2);
11311 ecode3 = SWIG_AsVal_int(obj2, &val3);
11312 if (!SWIG_IsOK(ecode3)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11314 }
11315 arg3 = (PLINT)(val3);
11316 ecode4 = SWIG_AsVal_int(obj3, &val4);
11317 if (!SWIG_IsOK(ecode4)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11319 }
11320 arg4 = (PLINT)(val4);
11321 plscol0(arg1,arg2,arg3,arg4);
11322 resultobj = SWIG_Py_Void();
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11330 PyObject *resultobj = 0;
11331 PLINT arg1 ;
11332 PLINT arg2 ;
11333 PLINT arg3 ;
11334 PLINT arg4 ;
11335 PLFLT arg5 ;
11336 int val1 ;
11337 int ecode1 = 0 ;
11338 int val2 ;
11339 int ecode2 = 0 ;
11340 int val3 ;
11341 int ecode3 = 0 ;
11342 int val4 ;
11343 int ecode4 = 0 ;
11344 double val5 ;
11345 int ecode5 = 0 ;
11346 PyObject * obj0 = 0 ;
11347 PyObject * obj1 = 0 ;
11348 PyObject * obj2 = 0 ;
11349 PyObject * obj3 = 0 ;
11350 PyObject * obj4 = 0 ;
11351
11352 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11353 ecode1 = SWIG_AsVal_int(obj0, &val1);
11354 if (!SWIG_IsOK(ecode1)) {
11355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11356 }
11357 arg1 = (PLINT)(val1);
11358 ecode2 = SWIG_AsVal_int(obj1, &val2);
11359 if (!SWIG_IsOK(ecode2)) {
11360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11361 }
11362 arg2 = (PLINT)(val2);
11363 ecode3 = SWIG_AsVal_int(obj2, &val3);
11364 if (!SWIG_IsOK(ecode3)) {
11365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11366 }
11367 arg3 = (PLINT)(val3);
11368 ecode4 = SWIG_AsVal_int(obj3, &val4);
11369 if (!SWIG_IsOK(ecode4)) {
11370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11371 }
11372 arg4 = (PLINT)(val4);
11373 ecode5 = SWIG_AsVal_double(obj4, &val5);
11374 if (!SWIG_IsOK(ecode5)) {
11375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11376 }
11377 arg5 = (PLFLT)(val5);
11378 plscol0a(arg1,arg2,arg3,arg4,arg5);
11379 resultobj = SWIG_Py_Void();
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11387 PyObject *resultobj = 0;
11388 PLINT arg1 ;
11389 PLINT arg2 ;
11390 PLINT arg3 ;
11391 int val1 ;
11392 int ecode1 = 0 ;
11393 int val2 ;
11394 int ecode2 = 0 ;
11395 int val3 ;
11396 int ecode3 = 0 ;
11397 PyObject * obj0 = 0 ;
11398 PyObject * obj1 = 0 ;
11399 PyObject * obj2 = 0 ;
11400
11401 if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11402 ecode1 = SWIG_AsVal_int(obj0, &val1);
11403 if (!SWIG_IsOK(ecode1)) {
11404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11405 }
11406 arg1 = (PLINT)(val1);
11407 ecode2 = SWIG_AsVal_int(obj1, &val2);
11408 if (!SWIG_IsOK(ecode2)) {
11409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11410 }
11411 arg2 = (PLINT)(val2);
11412 ecode3 = SWIG_AsVal_int(obj2, &val3);
11413 if (!SWIG_IsOK(ecode3)) {
11414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11415 }
11416 arg3 = (PLINT)(val3);
11417 plscolbg(arg1,arg2,arg3);
11418 resultobj = SWIG_Py_Void();
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11426 PyObject *resultobj = 0;
11427 PLINT arg1 ;
11428 PLINT arg2 ;
11429 PLINT arg3 ;
11430 PLFLT arg4 ;
11431 int val1 ;
11432 int ecode1 = 0 ;
11433 int val2 ;
11434 int ecode2 = 0 ;
11435 int val3 ;
11436 int ecode3 = 0 ;
11437 double val4 ;
11438 int ecode4 = 0 ;
11439 PyObject * obj0 = 0 ;
11440 PyObject * obj1 = 0 ;
11441 PyObject * obj2 = 0 ;
11442 PyObject * obj3 = 0 ;
11443
11444 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11445 ecode1 = SWIG_AsVal_int(obj0, &val1);
11446 if (!SWIG_IsOK(ecode1)) {
11447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11448 }
11449 arg1 = (PLINT)(val1);
11450 ecode2 = SWIG_AsVal_int(obj1, &val2);
11451 if (!SWIG_IsOK(ecode2)) {
11452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11453 }
11454 arg2 = (PLINT)(val2);
11455 ecode3 = SWIG_AsVal_int(obj2, &val3);
11456 if (!SWIG_IsOK(ecode3)) {
11457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11458 }
11459 arg3 = (PLINT)(val3);
11460 ecode4 = SWIG_AsVal_double(obj3, &val4);
11461 if (!SWIG_IsOK(ecode4)) {
11462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11463 }
11464 arg4 = (PLFLT)(val4);
11465 plscolbga(arg1,arg2,arg3,arg4);
11466 resultobj = SWIG_Py_Void();
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11474 PyObject *resultobj = 0;
11475 PLINT arg1 ;
11476 int val1 ;
11477 int ecode1 = 0 ;
11478 PyObject * obj0 = 0 ;
11479
11480 if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11481 ecode1 = SWIG_AsVal_int(obj0, &val1);
11482 if (!SWIG_IsOK(ecode1)) {
11483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11484 }
11485 arg1 = (PLINT)(val1);
11486 plscolor(arg1);
11487 resultobj = SWIG_Py_Void();
11488 return resultobj;
11489 fail:
11490 return NULL;
11491 }
11492
11493
11494 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11495 PyObject *resultobj = 0;
11496 PLINT arg1 ;
11497 int val1 ;
11498 int ecode1 = 0 ;
11499 PyObject * obj0 = 0 ;
11500
11501 if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11502 ecode1 = SWIG_AsVal_int(obj0, &val1);
11503 if (!SWIG_IsOK(ecode1)) {
11504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11505 }
11506 arg1 = (PLINT)(val1);
11507 plscompression(arg1);
11508 resultobj = SWIG_Py_Void();
11509 return resultobj;
11510 fail:
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11516 PyObject *resultobj = 0;
11517 char *arg1 = (char *) 0 ;
11518 int res1 ;
11519 char *buf1 = 0 ;
11520 int alloc1 = 0 ;
11521 PyObject * obj0 = 0 ;
11522
11523 if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11524 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11527 }
11528 arg1 = (char *)(buf1);
11529 plsdev((char const *)arg1);
11530 resultobj = SWIG_Py_Void();
11531 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11532 return resultobj;
11533 fail:
11534 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11535 return NULL;
11536 }
11537
11538
11539 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11540 PyObject *resultobj = 0;
11541 PLFLT arg1 ;
11542 PLFLT arg2 ;
11543 PLFLT arg3 ;
11544 PLFLT arg4 ;
11545 double val1 ;
11546 int ecode1 = 0 ;
11547 double val2 ;
11548 int ecode2 = 0 ;
11549 double val3 ;
11550 int ecode3 = 0 ;
11551 double val4 ;
11552 int ecode4 = 0 ;
11553 PyObject * obj0 = 0 ;
11554 PyObject * obj1 = 0 ;
11555 PyObject * obj2 = 0 ;
11556 PyObject * obj3 = 0 ;
11557
11558 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11559 ecode1 = SWIG_AsVal_double(obj0, &val1);
11560 if (!SWIG_IsOK(ecode1)) {
11561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11562 }
11563 arg1 = (PLFLT)(val1);
11564 ecode2 = SWIG_AsVal_double(obj1, &val2);
11565 if (!SWIG_IsOK(ecode2)) {
11566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11567 }
11568 arg2 = (PLFLT)(val2);
11569 ecode3 = SWIG_AsVal_double(obj2, &val3);
11570 if (!SWIG_IsOK(ecode3)) {
11571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11572 }
11573 arg3 = (PLFLT)(val3);
11574 ecode4 = SWIG_AsVal_double(obj3, &val4);
11575 if (!SWIG_IsOK(ecode4)) {
11576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11577 }
11578 arg4 = (PLFLT)(val4);
11579 plsdidev(arg1,arg2,arg3,arg4);
11580 resultobj = SWIG_Py_Void();
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *resultobj = 0;
11589 PLINT arg1 ;
11590 PLINT arg2 ;
11591 PLINT arg3 ;
11592 PLINT arg4 ;
11593 PLFLT arg5 ;
11594 PLFLT arg6 ;
11595 int val1 ;
11596 int ecode1 = 0 ;
11597 int val2 ;
11598 int ecode2 = 0 ;
11599 int val3 ;
11600 int ecode3 = 0 ;
11601 int val4 ;
11602 int ecode4 = 0 ;
11603 double val5 ;
11604 int ecode5 = 0 ;
11605 double val6 ;
11606 int ecode6 = 0 ;
11607 PyObject * obj0 = 0 ;
11608 PyObject * obj1 = 0 ;
11609 PyObject * obj2 = 0 ;
11610 PyObject * obj3 = 0 ;
11611 PyObject * obj4 = 0 ;
11612 PyObject * obj5 = 0 ;
11613
11614 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11615 ecode1 = SWIG_AsVal_int(obj0, &val1);
11616 if (!SWIG_IsOK(ecode1)) {
11617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11618 }
11619 arg1 = (PLINT)(val1);
11620 ecode2 = SWIG_AsVal_int(obj1, &val2);
11621 if (!SWIG_IsOK(ecode2)) {
11622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11623 }
11624 arg2 = (PLINT)(val2);
11625 ecode3 = SWIG_AsVal_int(obj2, &val3);
11626 if (!SWIG_IsOK(ecode3)) {
11627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11628 }
11629 arg3 = (PLINT)(val3);
11630 ecode4 = SWIG_AsVal_int(obj3, &val4);
11631 if (!SWIG_IsOK(ecode4)) {
11632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11633 }
11634 arg4 = (PLINT)(val4);
11635 ecode5 = SWIG_AsVal_double(obj4, &val5);
11636 if (!SWIG_IsOK(ecode5)) {
11637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11638 }
11639 arg5 = (PLFLT)(val5);
11640 ecode6 = SWIG_AsVal_double(obj5, &val6);
11641 if (!SWIG_IsOK(ecode6)) {
11642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11643 }
11644 arg6 = (PLFLT)(val6);
11645 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11646 resultobj = SWIG_Py_Void();
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654 PyObject *resultobj = 0;
11655 PLFLT arg1 ;
11656 double val1 ;
11657 int ecode1 = 0 ;
11658 PyObject * obj0 = 0 ;
11659
11660 if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11661 ecode1 = SWIG_AsVal_double(obj0, &val1);
11662 if (!SWIG_IsOK(ecode1)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11664 }
11665 arg1 = (PLFLT)(val1);
11666 plsdiori(arg1);
11667 resultobj = SWIG_Py_Void();
11668 return resultobj;
11669 fail:
11670 return NULL;
11671 }
11672
11673
11674 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11675 PyObject *resultobj = 0;
11676 PLFLT arg1 ;
11677 PLFLT arg2 ;
11678 PLFLT arg3 ;
11679 PLFLT arg4 ;
11680 double val1 ;
11681 int ecode1 = 0 ;
11682 double val2 ;
11683 int ecode2 = 0 ;
11684 double val3 ;
11685 int ecode3 = 0 ;
11686 double val4 ;
11687 int ecode4 = 0 ;
11688 PyObject * obj0 = 0 ;
11689 PyObject * obj1 = 0 ;
11690 PyObject * obj2 = 0 ;
11691 PyObject * obj3 = 0 ;
11692
11693 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11694 ecode1 = SWIG_AsVal_double(obj0, &val1);
11695 if (!SWIG_IsOK(ecode1)) {
11696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11697 }
11698 arg1 = (PLFLT)(val1);
11699 ecode2 = SWIG_AsVal_double(obj1, &val2);
11700 if (!SWIG_IsOK(ecode2)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11702 }
11703 arg2 = (PLFLT)(val2);
11704 ecode3 = SWIG_AsVal_double(obj2, &val3);
11705 if (!SWIG_IsOK(ecode3)) {
11706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11707 }
11708 arg3 = (PLFLT)(val3);
11709 ecode4 = SWIG_AsVal_double(obj3, &val4);
11710 if (!SWIG_IsOK(ecode4)) {
11711 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11712 }
11713 arg4 = (PLFLT)(val4);
11714 plsdiplt(arg1,arg2,arg3,arg4);
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 PLFLT arg1 ;
11725 PLFLT arg2 ;
11726 PLFLT arg3 ;
11727 PLFLT arg4 ;
11728 double val1 ;
11729 int ecode1 = 0 ;
11730 double val2 ;
11731 int ecode2 = 0 ;
11732 double val3 ;
11733 int ecode3 = 0 ;
11734 double val4 ;
11735 int ecode4 = 0 ;
11736 PyObject * obj0 = 0 ;
11737 PyObject * obj1 = 0 ;
11738 PyObject * obj2 = 0 ;
11739 PyObject * obj3 = 0 ;
11740
11741 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11742 ecode1 = SWIG_AsVal_double(obj0, &val1);
11743 if (!SWIG_IsOK(ecode1)) {
11744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11745 }
11746 arg1 = (PLFLT)(val1);
11747 ecode2 = SWIG_AsVal_double(obj1, &val2);
11748 if (!SWIG_IsOK(ecode2)) {
11749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11750 }
11751 arg2 = (PLFLT)(val2);
11752 ecode3 = SWIG_AsVal_double(obj2, &val3);
11753 if (!SWIG_IsOK(ecode3)) {
11754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11755 }
11756 arg3 = (PLFLT)(val3);
11757 ecode4 = SWIG_AsVal_double(obj3, &val4);
11758 if (!SWIG_IsOK(ecode4)) {
11759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11760 }
11761 arg4 = (PLFLT)(val4);
11762 plsdiplz(arg1,arg2,arg3,arg4);
11763 resultobj = SWIG_Py_Void();
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *resultobj = 0;
11772 unsigned int arg1 ;
11773 unsigned int val1 ;
11774 int ecode1 = 0 ;
11775 PyObject * obj0 = 0 ;
11776
11777 if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11778 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11779 if (!SWIG_IsOK(ecode1)) {
11780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11781 }
11782 arg1 = (unsigned int)(val1);
11783 plseed(arg1);
11784 resultobj = SWIG_Py_Void();
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 char arg1 ;
11794 char val1 ;
11795 int ecode1 = 0 ;
11796 PyObject * obj0 = 0 ;
11797
11798 if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11799 ecode1 = SWIG_AsVal_char(obj0, &val1);
11800 if (!SWIG_IsOK(ecode1)) {
11801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11802 }
11803 arg1 = (char)(val1);
11804 plsesc(arg1);
11805 resultobj = SWIG_Py_Void();
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11813 PyObject *resultobj = 0;
11814 char *arg1 = (char *) 0 ;
11815 char *arg2 = (char *) 0 ;
11816 int res1 ;
11817 char *buf1 = 0 ;
11818 int alloc1 = 0 ;
11819 int res2 ;
11820 char *buf2 = 0 ;
11821 int alloc2 = 0 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 PLINT result;
11825
11826 if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11827 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11828 if (!SWIG_IsOK(res1)) {
11829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11830 }
11831 arg1 = (char *)(buf1);
11832 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11833 if (!SWIG_IsOK(res2)) {
11834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11835 }
11836 arg2 = (char *)(buf2);
11837 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11838 resultobj = SWIG_From_int((int)(result));
11839 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11840 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11841 return resultobj;
11842 fail:
11843 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11844 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 PLINT arg1 ;
11852 PLINT arg2 ;
11853 PLINT arg3 ;
11854 int val1 ;
11855 int ecode1 = 0 ;
11856 int val2 ;
11857 int ecode2 = 0 ;
11858 int val3 ;
11859 int ecode3 = 0 ;
11860 PyObject * obj0 = 0 ;
11861 PyObject * obj1 = 0 ;
11862 PyObject * obj2 = 0 ;
11863
11864 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11865 ecode1 = SWIG_AsVal_int(obj0, &val1);
11866 if (!SWIG_IsOK(ecode1)) {
11867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11868 }
11869 arg1 = (PLINT)(val1);
11870 ecode2 = SWIG_AsVal_int(obj1, &val2);
11871 if (!SWIG_IsOK(ecode2)) {
11872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11873 }
11874 arg2 = (PLINT)(val2);
11875 ecode3 = SWIG_AsVal_int(obj2, &val3);
11876 if (!SWIG_IsOK(ecode3)) {
11877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11878 }
11879 arg3 = (PLINT)(val3);
11880 plsfam(arg1,arg2,arg3);
11881 resultobj = SWIG_Py_Void();
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889 PyObject *resultobj = 0;
11890 PLUNICODE arg1 ;
11891 unsigned int val1 ;
11892 int ecode1 = 0 ;
11893 PyObject * obj0 = 0 ;
11894
11895 if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11896 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11897 if (!SWIG_IsOK(ecode1)) {
11898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11899 }
11900 arg1 = (PLUNICODE)(val1);
11901 plsfci(arg1);
11902 resultobj = SWIG_Py_Void();
11903 return resultobj;
11904 fail:
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910 PyObject *resultobj = 0;
11911 char *arg1 = (char *) 0 ;
11912 int res1 ;
11913 char *buf1 = 0 ;
11914 int alloc1 = 0 ;
11915 PyObject * obj0 = 0 ;
11916
11917 if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11918 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11921 }
11922 arg1 = (char *)(buf1);
11923 plsfnam((char const *)arg1);
11924 resultobj = SWIG_Py_Void();
11925 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11926 return resultobj;
11927 fail:
11928 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11929 return NULL;
11930 }
11931
11932
11933 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11934 PyObject *resultobj = 0;
11935 PLINT arg1 ;
11936 PLINT arg2 ;
11937 PLINT arg3 ;
11938 int val1 ;
11939 int ecode1 = 0 ;
11940 int val2 ;
11941 int ecode2 = 0 ;
11942 int val3 ;
11943 int ecode3 = 0 ;
11944 PyObject * obj0 = 0 ;
11945 PyObject * obj1 = 0 ;
11946 PyObject * obj2 = 0 ;
11947
11948 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11949 ecode1 = SWIG_AsVal_int(obj0, &val1);
11950 if (!SWIG_IsOK(ecode1)) {
11951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11952 }
11953 arg1 = (PLINT)(val1);
11954 ecode2 = SWIG_AsVal_int(obj1, &val2);
11955 if (!SWIG_IsOK(ecode2)) {
11956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11957 }
11958 arg2 = (PLINT)(val2);
11959 ecode3 = SWIG_AsVal_int(obj2, &val3);
11960 if (!SWIG_IsOK(ecode3)) {
11961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11962 }
11963 arg3 = (PLINT)(val3);
11964 plsfont(arg1,arg2,arg3);
11965 resultobj = SWIG_Py_Void();
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11973 PyObject *resultobj = 0;
11974 PLFLT **arg1 = (PLFLT **) 0 ;
11975 PLINT arg2 ;
11976 PLINT arg3 ;
11977 defined_func arg4 = (defined_func) 0 ;
11978 PLFLT arg5 ;
11979 PLFLT arg6 ;
11980 PLFLT arg7 ;
11981 PLFLT arg8 ;
11982 PLFLT *arg9 = (PLFLT *) 0 ;
11983 PLINT arg10 ;
11984 PLFLT arg11 ;
11985 PLINT arg12 ;
11986 PLFLT arg13 ;
11987 fill_func arg14 = (fill_func) 0 ;
11988 PLBOOL arg15 ;
11989 pltr_func arg16 = (pltr_func) 0 ;
11990 PLPointer arg17 = (PLPointer) 0 ;
11991 PyArrayObject *tmp1 = NULL ;
11992 double val5 ;
11993 int ecode5 = 0 ;
11994 double val6 ;
11995 int ecode6 = 0 ;
11996 double val7 ;
11997 int ecode7 = 0 ;
11998 double val8 ;
11999 int ecode8 = 0 ;
12000 PyArrayObject *tmp9 = NULL ;
12001 double val11 ;
12002 int ecode11 = 0 ;
12003 int val12 ;
12004 int ecode12 = 0 ;
12005 double val13 ;
12006 int ecode13 = 0 ;
12007 int val15 ;
12008 int ecode15 = 0 ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 PyObject * obj2 = 0 ;
12012 PyObject * obj3 = 0 ;
12013 PyObject * obj4 = 0 ;
12014 PyObject * obj5 = 0 ;
12015 PyObject * obj6 = 0 ;
12016 PyObject * obj7 = 0 ;
12017 PyObject * obj8 = 0 ;
12018 PyObject * obj9 = 0 ;
12019 PyObject * obj10 = 0 ;
12020 PyObject * obj11 = 0 ;
12021
12022 {
12023 python_pltr = 0;
12024 arg16 = NULL;
12025 }
12026 {
12027 arg17 = NULL;
12028 }
12029 {
12030 arg4 = NULL;
12031 }
12032 {
12033 arg14 = plfill;
12034 }
12035 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
12036 {
12037 int i, size;
12038 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12039 if ( tmp1 == NULL )
12040 return NULL;
12041 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12042 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12043 size = arg3;
12044 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12045 for ( i = 0; i < arg2; i++ )
12046 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12047 }
12048 ecode5 = SWIG_AsVal_double(obj1, &val5);
12049 if (!SWIG_IsOK(ecode5)) {
12050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12051 }
12052 arg5 = (PLFLT)(val5);
12053 ecode6 = SWIG_AsVal_double(obj2, &val6);
12054 if (!SWIG_IsOK(ecode6)) {
12055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12056 }
12057 arg6 = (PLFLT)(val6);
12058 ecode7 = SWIG_AsVal_double(obj3, &val7);
12059 if (!SWIG_IsOK(ecode7)) {
12060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12061 }
12062 arg7 = (PLFLT)(val7);
12063 ecode8 = SWIG_AsVal_double(obj4, &val8);
12064 if (!SWIG_IsOK(ecode8)) {
12065 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12066 }
12067 arg8 = (PLFLT)(val8);
12068 {
12069 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
12070 if ( tmp9 == NULL )
12071 return NULL;
12072 arg10 = PyArray_DIMS( tmp9 )[0];
12073 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12074 }
12075 ecode11 = SWIG_AsVal_double(obj6, &val11);
12076 if (!SWIG_IsOK(ecode11)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12078 }
12079 arg11 = (PLFLT)(val11);
12080 ecode12 = SWIG_AsVal_int(obj7, &val12);
12081 if (!SWIG_IsOK(ecode12)) {
12082 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12083 }
12084 arg12 = (PLINT)(val12);
12085 ecode13 = SWIG_AsVal_double(obj8, &val13);
12086 if (!SWIG_IsOK(ecode13)) {
12087 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12088 }
12089 arg13 = (PLFLT)(val13);
12090 ecode15 = SWIG_AsVal_int(obj9, &val15);
12091 if (!SWIG_IsOK(ecode15)) {
12092 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12093 }
12094 arg15 = (PLBOOL)(val15);
12095 if (obj10) {
12096 {
12097 // it must be a callable or None
12098 if ( obj10 == Py_None )
12099 {
12100 arg16 = NULL;
12101 }
12102 else
12103 {
12104 if ( !PyCallable_Check( (PyObject *) obj10 ) )
12105 {
12106 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12107 return NULL;
12108 }
12109 arg16 = marshal_pltr( obj10 );
12110 }
12111 }
12112 }
12113 if (obj11) {
12114 {
12115 if ( obj11 == Py_None )
12116 arg17 = NULL;
12117 else
12118 {
12119 arg17 = marshal_PLPointer( obj11, 0 );
12120 }
12121 }
12122 }
12123 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12124 resultobj = SWIG_Py_Void();
12125 {
12126 Py_CLEAR( tmp1 );
12127 free( arg1 );
12128 }
12129 {
12130 Py_CLEAR( tmp9 );
12131 }
12132 {
12133 cleanup_pltr();
12134 }
12135 {
12136 cleanup_PLPointer();
12137 }
12138 return resultobj;
12139 fail:
12140 {
12141 Py_CLEAR( tmp1 );
12142 free( arg1 );
12143 }
12144 {
12145 Py_CLEAR( tmp9 );
12146 }
12147 {
12148 cleanup_pltr();
12149 }
12150 {
12151 cleanup_PLPointer();
12152 }
12153 return NULL;
12154 }
12155
12156
12157 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12158 PyObject *resultobj = 0;
12159 PLFLT **arg1 = (PLFLT **) 0 ;
12160 PLINT arg2 ;
12161 PLINT arg3 ;
12162 defined_func arg4 = (defined_func) 0 ;
12163 PLFLT arg5 ;
12164 PLFLT arg6 ;
12165 PLFLT arg7 ;
12166 PLFLT arg8 ;
12167 PLFLT arg9 ;
12168 PLFLT arg10 ;
12169 PLINT arg11 ;
12170 PLFLT arg12 ;
12171 PLFLT arg13 ;
12172 PLINT arg14 ;
12173 PLFLT arg15 ;
12174 PLINT arg16 ;
12175 PLFLT arg17 ;
12176 fill_func arg18 = (fill_func) 0 ;
12177 PLBOOL arg19 ;
12178 pltr_func arg20 = (pltr_func) 0 ;
12179 PLPointer arg21 = (PLPointer) 0 ;
12180 PyArrayObject *tmp1 = NULL ;
12181 double val5 ;
12182 int ecode5 = 0 ;
12183 double val6 ;
12184 int ecode6 = 0 ;
12185 double val7 ;
12186 int ecode7 = 0 ;
12187 double val8 ;
12188 int ecode8 = 0 ;
12189 double val9 ;
12190 int ecode9 = 0 ;
12191 double val10 ;
12192 int ecode10 = 0 ;
12193 int val11 ;
12194 int ecode11 = 0 ;
12195 double val12 ;
12196 int ecode12 = 0 ;
12197 double val13 ;
12198 int ecode13 = 0 ;
12199 int val14 ;
12200 int ecode14 = 0 ;
12201 double val15 ;
12202 int ecode15 = 0 ;
12203 int val16 ;
12204 int ecode16 = 0 ;
12205 double val17 ;
12206 int ecode17 = 0 ;
12207 int val19 ;
12208 int ecode19 = 0 ;
12209 PyObject * obj0 = 0 ;
12210 PyObject * obj1 = 0 ;
12211 PyObject * obj2 = 0 ;
12212 PyObject * obj3 = 0 ;
12213 PyObject * obj4 = 0 ;
12214 PyObject * obj5 = 0 ;
12215 PyObject * obj6 = 0 ;
12216 PyObject * obj7 = 0 ;
12217 PyObject * obj8 = 0 ;
12218 PyObject * obj9 = 0 ;
12219 PyObject * obj10 = 0 ;
12220 PyObject * obj11 = 0 ;
12221 PyObject * obj12 = 0 ;
12222 PyObject * obj13 = 0 ;
12223 PyObject * obj14 = 0 ;
12224 PyObject * obj15 = 0 ;
12225 PyObject * obj16 = 0 ;
12226
12227 {
12228 python_pltr = 0;
12229 arg20 = NULL;
12230 }
12231 {
12232 arg21 = NULL;
12233 }
12234 {
12235 arg4 = NULL;
12236 }
12237 {
12238 arg18 = plfill;
12239 }
12240 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
12241 {
12242 int i, size;
12243 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12244 if ( tmp1 == NULL )
12245 return NULL;
12246 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12247 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12248 size = arg3;
12249 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12250 for ( i = 0; i < arg2; i++ )
12251 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12252 }
12253 ecode5 = SWIG_AsVal_double(obj1, &val5);
12254 if (!SWIG_IsOK(ecode5)) {
12255 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12256 }
12257 arg5 = (PLFLT)(val5);
12258 ecode6 = SWIG_AsVal_double(obj2, &val6);
12259 if (!SWIG_IsOK(ecode6)) {
12260 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12261 }
12262 arg6 = (PLFLT)(val6);
12263 ecode7 = SWIG_AsVal_double(obj3, &val7);
12264 if (!SWIG_IsOK(ecode7)) {
12265 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12266 }
12267 arg7 = (PLFLT)(val7);
12268 ecode8 = SWIG_AsVal_double(obj4, &val8);
12269 if (!SWIG_IsOK(ecode8)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12271 }
12272 arg8 = (PLFLT)(val8);
12273 ecode9 = SWIG_AsVal_double(obj5, &val9);
12274 if (!SWIG_IsOK(ecode9)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12276 }
12277 arg9 = (PLFLT)(val9);
12278 ecode10 = SWIG_AsVal_double(obj6, &val10);
12279 if (!SWIG_IsOK(ecode10)) {
12280 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12281 }
12282 arg10 = (PLFLT)(val10);
12283 ecode11 = SWIG_AsVal_int(obj7, &val11);
12284 if (!SWIG_IsOK(ecode11)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12286 }
12287 arg11 = (PLINT)(val11);
12288 ecode12 = SWIG_AsVal_double(obj8, &val12);
12289 if (!SWIG_IsOK(ecode12)) {
12290 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12291 }
12292 arg12 = (PLFLT)(val12);
12293 ecode13 = SWIG_AsVal_double(obj9, &val13);
12294 if (!SWIG_IsOK(ecode13)) {
12295 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12296 }
12297 arg13 = (PLFLT)(val13);
12298 ecode14 = SWIG_AsVal_int(obj10, &val14);
12299 if (!SWIG_IsOK(ecode14)) {
12300 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12301 }
12302 arg14 = (PLINT)(val14);
12303 ecode15 = SWIG_AsVal_double(obj11, &val15);
12304 if (!SWIG_IsOK(ecode15)) {
12305 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12306 }
12307 arg15 = (PLFLT)(val15);
12308 ecode16 = SWIG_AsVal_int(obj12, &val16);
12309 if (!SWIG_IsOK(ecode16)) {
12310 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12311 }
12312 arg16 = (PLINT)(val16);
12313 ecode17 = SWIG_AsVal_double(obj13, &val17);
12314 if (!SWIG_IsOK(ecode17)) {
12315 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12316 }
12317 arg17 = (PLFLT)(val17);
12318 ecode19 = SWIG_AsVal_int(obj14, &val19);
12319 if (!SWIG_IsOK(ecode19)) {
12320 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12321 }
12322 arg19 = (PLBOOL)(val19);
12323 if (obj15) {
12324 {
12325 // it must be a callable or None
12326 if ( obj15 == Py_None )
12327 {
12328 arg20 = NULL;
12329 }
12330 else
12331 {
12332 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12333 {
12334 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12335 return NULL;
12336 }
12337 arg20 = marshal_pltr( obj15 );
12338 }
12339 }
12340 }
12341 if (obj16) {
12342 {
12343 if ( obj16 == Py_None )
12344 arg21 = NULL;
12345 else
12346 {
12347 arg21 = marshal_PLPointer( obj16, 0 );
12348 }
12349 }
12350 }
12351 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12352 resultobj = SWIG_Py_Void();
12353 {
12354 Py_CLEAR( tmp1 );
12355 free( arg1 );
12356 }
12357 {
12358 cleanup_pltr();
12359 }
12360 {
12361 cleanup_PLPointer();
12362 }
12363 return resultobj;
12364 fail:
12365 {
12366 Py_CLEAR( tmp1 );
12367 free( arg1 );
12368 }
12369 {
12370 cleanup_pltr();
12371 }
12372 {
12373 cleanup_PLPointer();
12374 }
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12380 PyObject *resultobj = 0;
12381 label_func arg1 = (label_func) 0 ;
12382 PLPointer arg2 = (PLPointer) 0 ;
12383 int res2 ;
12384 PyObject * obj0 = 0 ;
12385 PyObject * obj1 = 0 ;
12386
12387 if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12388 {
12389 // Release reference to previous function if applicable
12390 if ( python_label )
12391 {
12392 Py_CLEAR( python_label );
12393 python_label = 0;
12394 }
12395 // it must be a callable or None
12396 if ( obj0 == Py_None )
12397 {
12398 arg1 = NULL;
12399 }
12400 else
12401 {
12402 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12403 {
12404 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12405 return NULL;
12406 }
12407 // hold a reference to it
12408 Py_XINCREF( (PyObject *) obj0 );
12409 python_label = (PyObject *) obj0;
12410 // this function handles calling the python function
12411 arg1 = do_label_callback;
12412 }
12413 }
12414 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12415 if (!SWIG_IsOK(res2)) {
12416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12417 }
12418 plslabelfunc(arg1,arg2);
12419 resultobj = SWIG_Py_Void();
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12427 PyObject *resultobj = 0;
12428 PLFLT arg1 ;
12429 PLFLT arg2 ;
12430 double val1 ;
12431 int ecode1 = 0 ;
12432 double val2 ;
12433 int ecode2 = 0 ;
12434 PyObject * obj0 = 0 ;
12435 PyObject * obj1 = 0 ;
12436
12437 if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12438 ecode1 = SWIG_AsVal_double(obj0, &val1);
12439 if (!SWIG_IsOK(ecode1)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12441 }
12442 arg1 = (PLFLT)(val1);
12443 ecode2 = SWIG_AsVal_double(obj1, &val2);
12444 if (!SWIG_IsOK(ecode2)) {
12445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12446 }
12447 arg2 = (PLFLT)(val2);
12448 plsmaj(arg1,arg2);
12449 resultobj = SWIG_Py_Void();
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *resultobj = 0;
12458 PLINT arg1 ;
12459 PLINT arg2 ;
12460 void *arg3 = (void *) 0 ;
12461 int val1 ;
12462 int ecode1 = 0 ;
12463 int val2 ;
12464 int ecode2 = 0 ;
12465 int res3 ;
12466 Py_ssize_t size3 = 0 ;
12467 void *buf3 = 0 ;
12468 PyObject * obj0 = 0 ;
12469 PyObject * obj1 = 0 ;
12470 PyObject * obj2 = 0 ;
12471
12472 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12473 ecode1 = SWIG_AsVal_int(obj0, &val1);
12474 if (!SWIG_IsOK(ecode1)) {
12475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12476 }
12477 arg1 = (PLINT)(val1);
12478 ecode2 = SWIG_AsVal_int(obj1, &val2);
12479 if (!SWIG_IsOK(ecode2)) {
12480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12481 }
12482 arg2 = (PLINT)(val2);
12483 {
12484 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12485 if (res3<0) {
12486 PyErr_Clear();
12487 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12488 }
12489 arg3 = (void *) buf3;
12490 }
12491 plsmem(arg1,arg2,arg3);
12492 resultobj = SWIG_Py_Void();
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 PyObject *resultobj = 0;
12501 PLINT arg1 ;
12502 PLINT arg2 ;
12503 void *arg3 = (void *) 0 ;
12504 int val1 ;
12505 int ecode1 = 0 ;
12506 int val2 ;
12507 int ecode2 = 0 ;
12508 int res3 ;
12509 Py_ssize_t size3 = 0 ;
12510 void *buf3 = 0 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 PyObject * obj2 = 0 ;
12514
12515 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12516 ecode1 = SWIG_AsVal_int(obj0, &val1);
12517 if (!SWIG_IsOK(ecode1)) {
12518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12519 }
12520 arg1 = (PLINT)(val1);
12521 ecode2 = SWIG_AsVal_int(obj1, &val2);
12522 if (!SWIG_IsOK(ecode2)) {
12523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12524 }
12525 arg2 = (PLINT)(val2);
12526 {
12527 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12528 if (res3<0) {
12529 PyErr_Clear();
12530 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12531 }
12532 arg3 = (void *) buf3;
12533 }
12534 plsmema(arg1,arg2,arg3);
12535 resultobj = SWIG_Py_Void();
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 PyObject *resultobj = 0;
12544 PLFLT arg1 ;
12545 PLFLT arg2 ;
12546 double val1 ;
12547 int ecode1 = 0 ;
12548 double val2 ;
12549 int ecode2 = 0 ;
12550 PyObject * obj0 = 0 ;
12551 PyObject * obj1 = 0 ;
12552
12553 if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12554 ecode1 = SWIG_AsVal_double(obj0, &val1);
12555 if (!SWIG_IsOK(ecode1)) {
12556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12557 }
12558 arg1 = (PLFLT)(val1);
12559 ecode2 = SWIG_AsVal_double(obj1, &val2);
12560 if (!SWIG_IsOK(ecode2)) {
12561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12562 }
12563 arg2 = (PLFLT)(val2);
12564 plsmin(arg1,arg2);
12565 resultobj = SWIG_Py_Void();
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 PyObject *resultobj = 0;
12574 PLINT arg1 ;
12575 int val1 ;
12576 int ecode1 = 0 ;
12577 PyObject * obj0 = 0 ;
12578
12579 if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12580 ecode1 = SWIG_AsVal_int(obj0, &val1);
12581 if (!SWIG_IsOK(ecode1)) {
12582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12583 }
12584 arg1 = (PLINT)(val1);
12585 plsori(arg1);
12586 resultobj = SWIG_Py_Void();
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12594 PyObject *resultobj = 0;
12595 PLFLT arg1 ;
12596 PLFLT arg2 ;
12597 PLINT arg3 ;
12598 PLINT arg4 ;
12599 PLINT arg5 ;
12600 PLINT arg6 ;
12601 double val1 ;
12602 int ecode1 = 0 ;
12603 double val2 ;
12604 int ecode2 = 0 ;
12605 int val3 ;
12606 int ecode3 = 0 ;
12607 int val4 ;
12608 int ecode4 = 0 ;
12609 int val5 ;
12610 int ecode5 = 0 ;
12611 int val6 ;
12612 int ecode6 = 0 ;
12613 PyObject * obj0 = 0 ;
12614 PyObject * obj1 = 0 ;
12615 PyObject * obj2 = 0 ;
12616 PyObject * obj3 = 0 ;
12617 PyObject * obj4 = 0 ;
12618 PyObject * obj5 = 0 ;
12619
12620 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12621 ecode1 = SWIG_AsVal_double(obj0, &val1);
12622 if (!SWIG_IsOK(ecode1)) {
12623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12624 }
12625 arg1 = (PLFLT)(val1);
12626 ecode2 = SWIG_AsVal_double(obj1, &val2);
12627 if (!SWIG_IsOK(ecode2)) {
12628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12629 }
12630 arg2 = (PLFLT)(val2);
12631 ecode3 = SWIG_AsVal_int(obj2, &val3);
12632 if (!SWIG_IsOK(ecode3)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12634 }
12635 arg3 = (PLINT)(val3);
12636 ecode4 = SWIG_AsVal_int(obj3, &val4);
12637 if (!SWIG_IsOK(ecode4)) {
12638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12639 }
12640 arg4 = (PLINT)(val4);
12641 ecode5 = SWIG_AsVal_int(obj4, &val5);
12642 if (!SWIG_IsOK(ecode5)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12644 }
12645 arg5 = (PLINT)(val5);
12646 ecode6 = SWIG_AsVal_int(obj5, &val6);
12647 if (!SWIG_IsOK(ecode6)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12649 }
12650 arg6 = (PLINT)(val6);
12651 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12652 resultobj = SWIG_Py_Void();
12653 return resultobj;
12654 fail:
12655 return NULL;
12656 }
12657
12658
12659 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12660 PyObject *resultobj = 0;
12661 char *arg1 = (char *) 0 ;
12662 int res1 ;
12663 char *buf1 = 0 ;
12664 int alloc1 = 0 ;
12665 PyObject * obj0 = 0 ;
12666
12667 if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12668 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12669 if (!SWIG_IsOK(res1)) {
12670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12671 }
12672 arg1 = (char *)(buf1);
12673 plspal0((char const *)arg1);
12674 resultobj = SWIG_Py_Void();
12675 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12676 return resultobj;
12677 fail:
12678 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 char *arg1 = (char *) 0 ;
12686 PLBOOL arg2 ;
12687 int res1 ;
12688 char *buf1 = 0 ;
12689 int alloc1 = 0 ;
12690 int val2 ;
12691 int ecode2 = 0 ;
12692 PyObject * obj0 = 0 ;
12693 PyObject * obj1 = 0 ;
12694
12695 if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12696 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12697 if (!SWIG_IsOK(res1)) {
12698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12699 }
12700 arg1 = (char *)(buf1);
12701 ecode2 = SWIG_AsVal_int(obj1, &val2);
12702 if (!SWIG_IsOK(ecode2)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12704 }
12705 arg2 = (PLBOOL)(val2);
12706 plspal1((char const *)arg1,arg2);
12707 resultobj = SWIG_Py_Void();
12708 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12709 return resultobj;
12710 fail:
12711 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12712 return NULL;
12713 }
12714
12715
12716 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717 PyObject *resultobj = 0;
12718 PLBOOL arg1 ;
12719 int val1 ;
12720 int ecode1 = 0 ;
12721 PyObject * obj0 = 0 ;
12722
12723 if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12724 ecode1 = SWIG_AsVal_int(obj0, &val1);
12725 if (!SWIG_IsOK(ecode1)) {
12726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12727 }
12728 arg1 = (PLBOOL)(val1);
12729 plspause(arg1);
12730 resultobj = SWIG_Py_Void();
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 PLINT arg1 ;
12740 int val1 ;
12741 int ecode1 = 0 ;
12742 PyObject * obj0 = 0 ;
12743
12744 if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12745 ecode1 = SWIG_AsVal_int(obj0, &val1);
12746 if (!SWIG_IsOK(ecode1)) {
12747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12748 }
12749 arg1 = (PLINT)(val1);
12750 plsstrm(arg1);
12751 resultobj = SWIG_Py_Void();
12752 return resultobj;
12753 fail:
12754 return NULL;
12755 }
12756
12757
12758 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12759 PyObject *resultobj = 0;
12760 PLINT arg1 ;
12761 PLINT arg2 ;
12762 int val1 ;
12763 int ecode1 = 0 ;
12764 int val2 ;
12765 int ecode2 = 0 ;
12766 PyObject * obj0 = 0 ;
12767 PyObject * obj1 = 0 ;
12768
12769 if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12770 ecode1 = SWIG_AsVal_int(obj0, &val1);
12771 if (!SWIG_IsOK(ecode1)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12773 }
12774 arg1 = (PLINT)(val1);
12775 ecode2 = SWIG_AsVal_int(obj1, &val2);
12776 if (!SWIG_IsOK(ecode2)) {
12777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12778 }
12779 arg2 = (PLINT)(val2);
12780 plssub(arg1,arg2);
12781 resultobj = SWIG_Py_Void();
12782 return resultobj;
12783 fail:
12784 return NULL;
12785 }
12786
12787
12788 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12789 PyObject *resultobj = 0;
12790 PLFLT arg1 ;
12791 PLFLT arg2 ;
12792 double val1 ;
12793 int ecode1 = 0 ;
12794 double val2 ;
12795 int ecode2 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798
12799 if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12800 ecode1 = SWIG_AsVal_double(obj0, &val1);
12801 if (!SWIG_IsOK(ecode1)) {
12802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12803 }
12804 arg1 = (PLFLT)(val1);
12805 ecode2 = SWIG_AsVal_double(obj1, &val2);
12806 if (!SWIG_IsOK(ecode2)) {
12807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12808 }
12809 arg2 = (PLFLT)(val2);
12810 plssym(arg1,arg2);
12811 resultobj = SWIG_Py_Void();
12812 return resultobj;
12813 fail:
12814 return NULL;
12815 }
12816
12817
12818 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12819 PyObject *resultobj = 0;
12820 PLINT arg1 ;
12821 PLINT arg2 ;
12822 int val1 ;
12823 int ecode1 = 0 ;
12824 int val2 ;
12825 int ecode2 = 0 ;
12826 PyObject * obj0 = 0 ;
12827 PyObject * obj1 = 0 ;
12828
12829 if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12830 ecode1 = SWIG_AsVal_int(obj0, &val1);
12831 if (!SWIG_IsOK(ecode1)) {
12832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12833 }
12834 arg1 = (PLINT)(val1);
12835 ecode2 = SWIG_AsVal_int(obj1, &val2);
12836 if (!SWIG_IsOK(ecode2)) {
12837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12838 }
12839 arg2 = (PLINT)(val2);
12840 plstar(arg1,arg2);
12841 resultobj = SWIG_Py_Void();
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *resultobj = 0;
12850 char *arg1 = (char *) 0 ;
12851 PLINT arg2 ;
12852 PLINT arg3 ;
12853 int res1 ;
12854 char *buf1 = 0 ;
12855 int alloc1 = 0 ;
12856 int val2 ;
12857 int ecode2 = 0 ;
12858 int val3 ;
12859 int ecode3 = 0 ;
12860 PyObject * obj0 = 0 ;
12861 PyObject * obj1 = 0 ;
12862 PyObject * obj2 = 0 ;
12863
12864 if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12865 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12868 }
12869 arg1 = (char *)(buf1);
12870 ecode2 = SWIG_AsVal_int(obj1, &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12873 }
12874 arg2 = (PLINT)(val2);
12875 ecode3 = SWIG_AsVal_int(obj2, &val3);
12876 if (!SWIG_IsOK(ecode3)) {
12877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12878 }
12879 arg3 = (PLINT)(val3);
12880 plstart((char const *)arg1,arg2,arg3);
12881 resultobj = SWIG_Py_Void();
12882 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12883 return resultobj;
12884 fail:
12885 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 PyObject *resultobj = 0;
12892 ct_func arg1 = (ct_func) 0 ;
12893 PLPointer arg2 = (PLPointer) 0 ;
12894 int res2 ;
12895 PyObject * obj0 = 0 ;
12896 PyObject * obj1 = 0 ;
12897
12898 {
12899 python_ct = 0;
12900 arg1 = NULL;
12901 }
12902 if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12903 if (obj0) {
12904 {
12905 if ( python_ct )
12906 cleanup_ct();
12907 // it must be a callable or none
12908 if ( obj0 == Py_None )
12909 {
12910 arg1 = NULL;
12911 }
12912 else
12913 {
12914 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12915 {
12916 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12917 return NULL;
12918 }
12919 arg1 = marshal_ct( obj0 );
12920 }
12921 }
12922 }
12923 if (obj1) {
12924 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12925 if (!SWIG_IsOK(res2)) {
12926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12927 }
12928 }
12929 plstransform(arg1,arg2);
12930 resultobj = SWIG_Py_Void();
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 PLINT arg1 ;
12940 PLFLT *arg2 = (PLFLT *) 0 ;
12941 PLFLT *arg3 = (PLFLT *) 0 ;
12942 char *arg4 = (char *) 0 ;
12943 PyArrayObject *tmp1 = NULL ;
12944 PyArrayObject *tmp3 = NULL ;
12945 int res4 ;
12946 char *buf4 = 0 ;
12947 int alloc4 = 0 ;
12948 PyObject * obj0 = 0 ;
12949 PyObject * obj1 = 0 ;
12950 PyObject * obj2 = 0 ;
12951
12952 if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12953 {
12954 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12955 if ( tmp1 == NULL )
12956 return NULL;
12957 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12958 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12959 }
12960 {
12961 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12962 if ( tmp3 == NULL )
12963 return NULL;
12964 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12965 {
12966 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12967 return NULL;
12968 }
12969 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12970 }
12971 res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12972 if (!SWIG_IsOK(res4)) {
12973 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12974 }
12975 arg4 = (char *)(buf4);
12976 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12977 resultobj = SWIG_Py_Void();
12978 {
12979 Py_CLEAR( tmp1 );
12980 }
12981 {
12982 Py_CLEAR( tmp3 );
12983 }
12984 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12985 return resultobj;
12986 fail:
12987 {
12988 Py_CLEAR( tmp1 );
12989 }
12990 {
12991 Py_CLEAR( tmp3 );
12992 }
12993 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12994 return NULL;
12995 }
12996
12997
12998 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999 PyObject *resultobj = 0;
13000 PLINT arg1 ;
13001 PLFLT *arg2 = (PLFLT *) 0 ;
13002 PLFLT *arg3 = (PLFLT *) 0 ;
13003 PLFLT *arg4 = (PLFLT *) 0 ;
13004 char *arg5 = (char *) 0 ;
13005 PyArrayObject *tmp1 = NULL ;
13006 PyArrayObject *tmp3 = NULL ;
13007 PyArrayObject *tmp4 = NULL ;
13008 int res5 ;
13009 char *buf5 = 0 ;
13010 int alloc5 = 0 ;
13011 PyObject * obj0 = 0 ;
13012 PyObject * obj1 = 0 ;
13013 PyObject * obj2 = 0 ;
13014 PyObject * obj3 = 0 ;
13015
13016 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13017 {
13018 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13019 if ( tmp1 == NULL )
13020 return NULL;
13021 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13022 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13023 }
13024 {
13025 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13026 if ( tmp3 == NULL )
13027 return NULL;
13028 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13029 {
13030 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13031 return NULL;
13032 }
13033 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13034 }
13035 {
13036 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
13037 if ( tmp4 == NULL )
13038 return NULL;
13039 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13040 {
13041 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13042 return NULL;
13043 }
13044 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13045 }
13046 res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
13047 if (!SWIG_IsOK(res5)) {
13048 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13049 }
13050 arg5 = (char *)(buf5);
13051 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13052 resultobj = SWIG_Py_Void();
13053 {
13054 Py_CLEAR( tmp1 );
13055 }
13056 {
13057 Py_CLEAR( tmp3 );
13058 }
13059 {
13060 Py_CLEAR( tmp4 );
13061 }
13062 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13063 return resultobj;
13064 fail:
13065 {
13066 Py_CLEAR( tmp1 );
13067 }
13068 {
13069 Py_CLEAR( tmp3 );
13070 }
13071 {
13072 Py_CLEAR( tmp4 );
13073 }
13074 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 PyObject *resultobj = 0;
13081 PLINT arg1 ;
13082 PLINT arg2 ;
13083 PLFLT arg3 ;
13084 PLFLT arg4 ;
13085 int val1 ;
13086 int ecode1 = 0 ;
13087 int val2 ;
13088 int ecode2 = 0 ;
13089 double val3 ;
13090 int ecode3 = 0 ;
13091 double val4 ;
13092 int ecode4 = 0 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 PyObject * obj2 = 0 ;
13096 PyObject * obj3 = 0 ;
13097
13098 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13099 ecode1 = SWIG_AsVal_int(obj0, &val1);
13100 if (!SWIG_IsOK(ecode1)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13102 }
13103 arg1 = (PLINT)(val1);
13104 ecode2 = SWIG_AsVal_int(obj1, &val2);
13105 if (!SWIG_IsOK(ecode2)) {
13106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13107 }
13108 arg2 = (PLINT)(val2);
13109 ecode3 = SWIG_AsVal_double(obj2, &val3);
13110 if (!SWIG_IsOK(ecode3)) {
13111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13112 }
13113 arg3 = (PLFLT)(val3);
13114 ecode4 = SWIG_AsVal_double(obj3, &val4);
13115 if (!SWIG_IsOK(ecode4)) {
13116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13117 }
13118 arg4 = (PLFLT)(val4);
13119 plstripa(arg1,arg2,arg3,arg4);
13120 resultobj = SWIG_Py_Void();
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13128 PyObject *resultobj = 0;
13129 PLINT *arg1 = (PLINT *) 0 ;
13130 char *arg2 = (char *) 0 ;
13131 char *arg3 = (char *) 0 ;
13132 PLFLT arg4 ;
13133 PLFLT arg5 ;
13134 PLFLT arg6 ;
13135 PLFLT arg7 ;
13136 PLFLT arg8 ;
13137 PLFLT arg9 ;
13138 PLFLT arg10 ;
13139 PLBOOL arg11 ;
13140 PLBOOL arg12 ;
13141 PLINT arg13 ;
13142 PLINT arg14 ;
13143 PLINT *arg15 = (PLINT *) 0 ;
13144 PLINT *arg16 = (PLINT *) 0 ;
13145 char **arg17 ;
13146 char *arg18 = (char *) 0 ;
13147 char *arg19 = (char *) 0 ;
13148 char *arg20 = (char *) 0 ;
13149 PLINT temp1 ;
13150 int res1 = SWIG_TMPOBJ ;
13151 int res2 ;
13152 char *buf2 = 0 ;
13153 int alloc2 = 0 ;
13154 int res3 ;
13155 char *buf3 = 0 ;
13156 int alloc3 = 0 ;
13157 double val4 ;
13158 int ecode4 = 0 ;
13159 double val5 ;
13160 int ecode5 = 0 ;
13161 double val6 ;
13162 int ecode6 = 0 ;
13163 double val7 ;
13164 int ecode7 = 0 ;
13165 double val8 ;
13166 int ecode8 = 0 ;
13167 double val9 ;
13168 int ecode9 = 0 ;
13169 double val10 ;
13170 int ecode10 = 0 ;
13171 int val11 ;
13172 int ecode11 = 0 ;
13173 int val12 ;
13174 int ecode12 = 0 ;
13175 int val13 ;
13176 int ecode13 = 0 ;
13177 int val14 ;
13178 int ecode14 = 0 ;
13179 PyArrayObject *tmp15 = NULL ;
13180 PyArrayObject *tmp16 = NULL ;
13181 char **tmp17 = NULL ;
13182 int res18 ;
13183 char *buf18 = 0 ;
13184 int alloc18 = 0 ;
13185 int res19 ;
13186 char *buf19 = 0 ;
13187 int alloc19 = 0 ;
13188 int res20 ;
13189 char *buf20 = 0 ;
13190 int alloc20 = 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 PyObject * obj2 = 0 ;
13194 PyObject * obj3 = 0 ;
13195 PyObject * obj4 = 0 ;
13196 PyObject * obj5 = 0 ;
13197 PyObject * obj6 = 0 ;
13198 PyObject * obj7 = 0 ;
13199 PyObject * obj8 = 0 ;
13200 PyObject * obj9 = 0 ;
13201 PyObject * obj10 = 0 ;
13202 PyObject * obj11 = 0 ;
13203 PyObject * obj12 = 0 ;
13204 PyObject * obj13 = 0 ;
13205 PyObject * obj14 = 0 ;
13206 PyObject * obj15 = 0 ;
13207 PyObject * obj16 = 0 ;
13208 PyObject * obj17 = 0 ;
13209 PyObject * obj18 = 0 ;
13210
13211 arg1 = &temp1;
13212 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
13213 res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13214 if (!SWIG_IsOK(res2)) {
13215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13216 }
13217 arg2 = (char *)(buf2);
13218 res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13219 if (!SWIG_IsOK(res3)) {
13220 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13221 }
13222 arg3 = (char *)(buf3);
13223 ecode4 = SWIG_AsVal_double(obj2, &val4);
13224 if (!SWIG_IsOK(ecode4)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13226 }
13227 arg4 = (PLFLT)(val4);
13228 ecode5 = SWIG_AsVal_double(obj3, &val5);
13229 if (!SWIG_IsOK(ecode5)) {
13230 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13231 }
13232 arg5 = (PLFLT)(val5);
13233 ecode6 = SWIG_AsVal_double(obj4, &val6);
13234 if (!SWIG_IsOK(ecode6)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13236 }
13237 arg6 = (PLFLT)(val6);
13238 ecode7 = SWIG_AsVal_double(obj5, &val7);
13239 if (!SWIG_IsOK(ecode7)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13241 }
13242 arg7 = (PLFLT)(val7);
13243 ecode8 = SWIG_AsVal_double(obj6, &val8);
13244 if (!SWIG_IsOK(ecode8)) {
13245 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13246 }
13247 arg8 = (PLFLT)(val8);
13248 ecode9 = SWIG_AsVal_double(obj7, &val9);
13249 if (!SWIG_IsOK(ecode9)) {
13250 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13251 }
13252 arg9 = (PLFLT)(val9);
13253 ecode10 = SWIG_AsVal_double(obj8, &val10);
13254 if (!SWIG_IsOK(ecode10)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13256 }
13257 arg10 = (PLFLT)(val10);
13258 ecode11 = SWIG_AsVal_int(obj9, &val11);
13259 if (!SWIG_IsOK(ecode11)) {
13260 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13261 }
13262 arg11 = (PLBOOL)(val11);
13263 ecode12 = SWIG_AsVal_int(obj10, &val12);
13264 if (!SWIG_IsOK(ecode12)) {
13265 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13266 }
13267 arg12 = (PLBOOL)(val12);
13268 ecode13 = SWIG_AsVal_int(obj11, &val13);
13269 if (!SWIG_IsOK(ecode13)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13271 }
13272 arg13 = (PLINT)(val13);
13273 ecode14 = SWIG_AsVal_int(obj12, &val14);
13274 if (!SWIG_IsOK(ecode14)) {
13275 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13276 }
13277 arg14 = (PLINT)(val14);
13278 {
13279 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13280 if ( tmp15 == NULL )
13281 return NULL;
13282 Alen = PyArray_DIMS( tmp15 )[0];
13283 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13284 }
13285 {
13286 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13287 if ( tmp16 == NULL )
13288 return NULL;
13289 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13290 {
13291 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13292 return NULL;
13293 }
13294 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13295 }
13296 {
13297 int i;
13298 PyObject *elt, *unicode_string;
13299
13300 if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13301 {
13302 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13303 return NULL;
13304 }
13305 if ( Alen != 4 )
13306 {
13307 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13308 return NULL;
13309 }
13310 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13311 if ( tmp17 == NULL )
13312 return NULL;
13313 arg17 = tmp17;
13314 for ( i = 0; i < 4; i++ )
13315 {
13316 arg17[i] = NULL;
13317 elt = PySequence_Fast_GET_ITEM( obj15, i );
13318 if ( PyString_Check( elt ) )
13319 {
13320 arg17[i] = PyString_AsString( elt );
13321 }
13322 else if ( PyUnicode_Check( elt ) )
13323 {
13324 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13325 arg17[i] = PyBytes_AS_STRING( unicode_string );
13326 }
13327 if ( arg17[i] == NULL )
13328 {
13329 free( tmp17 );
13330 return NULL;
13331 }
13332 }
13333 }
13334 res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13335 if (!SWIG_IsOK(res18)) {
13336 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13337 }
13338 arg18 = (char *)(buf18);
13339 res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13340 if (!SWIG_IsOK(res19)) {
13341 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13342 }
13343 arg19 = (char *)(buf19);
13344 res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13345 if (!SWIG_IsOK(res20)) {
13346 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13347 }
13348 arg20 = (char *)(buf20);
13349 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);
13350 resultobj = SWIG_Py_Void();
13351 if (SWIG_IsTmpObj(res1)) {
13352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13353 } else {
13354 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13356 }
13357 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13358 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13359 {
13360 Py_CLEAR( tmp15 );
13361 }
13362 {
13363 Py_CLEAR( tmp16 );
13364 }
13365 {
13366 free( tmp17 );
13367 }
13368 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13369 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13370 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13371 return resultobj;
13372 fail:
13373 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13374 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13375 {
13376 Py_CLEAR( tmp15 );
13377 }
13378 {
13379 Py_CLEAR( tmp16 );
13380 }
13381 {
13382 free( tmp17 );
13383 }
13384 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13385 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13386 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 PLINT arg1 ;
13394 int val1 ;
13395 int ecode1 = 0 ;
13396 PyObject * obj0 = 0 ;
13397
13398 if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13399 ecode1 = SWIG_AsVal_int(obj0, &val1);
13400 if (!SWIG_IsOK(ecode1)) {
13401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13402 }
13403 arg1 = (PLINT)(val1);
13404 plstripd(arg1);
13405 resultobj = SWIG_Py_Void();
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413 PyObject *resultobj = 0;
13414 PLINT arg1 ;
13415 PLINT *arg2 = (PLINT *) 0 ;
13416 PLINT *arg3 = (PLINT *) 0 ;
13417 PyArrayObject *tmp1 = NULL ;
13418 PyArrayObject *tmp3 = NULL ;
13419 PyObject * obj0 = 0 ;
13420 PyObject * obj1 = 0 ;
13421
13422 if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13423 {
13424 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13425 if ( tmp1 == NULL )
13426 return NULL;
13427 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13428 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13429 }
13430 {
13431 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13432 if ( tmp3 == NULL )
13433 return NULL;
13434 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13435 {
13436 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13437 return NULL;
13438 }
13439 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13440 }
13441 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13442 resultobj = SWIG_Py_Void();
13443 {
13444 Py_CLEAR( tmp1 );
13445 }
13446 {
13447 Py_CLEAR( tmp3 );
13448 }
13449 return resultobj;
13450 fail:
13451 {
13452 Py_CLEAR( tmp1 );
13453 }
13454 {
13455 Py_CLEAR( tmp3 );
13456 }
13457 return NULL;
13458 }
13459
13460
13461 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13462 PyObject *resultobj = 0;
13463 PLFLT *arg1 = (PLFLT *) 0 ;
13464 PLFLT *arg2 = (PLFLT *) 0 ;
13465 PLINT arg3 ;
13466 PLBOOL arg4 ;
13467 PyArrayObject *tmp1 = NULL ;
13468 PyArrayObject *tmp2 = NULL ;
13469 int val4 ;
13470 int ecode4 = 0 ;
13471 PyObject * obj0 = 0 ;
13472 PyObject * obj1 = 0 ;
13473 PyObject * obj2 = 0 ;
13474
13475 if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13476 {
13477 if ( obj0 != Py_None )
13478 {
13479 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13480 if ( tmp1 == NULL )
13481 return NULL;
13482 Alen = PyArray_DIMS( tmp1 )[0];
13483 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13484 }
13485 else
13486 {
13487 arg1 = NULL;
13488 Alen = 0;
13489 }
13490 }
13491 {
13492 if ( obj1 != Py_None )
13493 {
13494 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13495 if ( tmp2 == NULL )
13496 return NULL;
13497 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13498 {
13499 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13500 return NULL;
13501 }
13502 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13503 arg3 = PyArray_DIMS( tmp2 )[0];
13504 }
13505 else
13506 {
13507 arg2 = NULL;
13508 arg3 = 0;
13509 }
13510 }
13511 ecode4 = SWIG_AsVal_int(obj2, &val4);
13512 if (!SWIG_IsOK(ecode4)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13514 }
13515 arg4 = (PLBOOL)(val4);
13516 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13517 resultobj = SWIG_Py_Void();
13518 {
13519 Py_CLEAR( tmp1 );
13520 }
13521 {
13522 Py_CLEAR( tmp2 );
13523 }
13524 return resultobj;
13525 fail:
13526 {
13527 Py_CLEAR( tmp1 );
13528 }
13529 {
13530 Py_CLEAR( tmp2 );
13531 }
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13537 PyObject *resultobj = 0;
13538 PLFLT arg1 ;
13539 PLFLT arg2 ;
13540 PLFLT arg3 ;
13541 PLFLT arg4 ;
13542 double val1 ;
13543 int ecode1 = 0 ;
13544 double val2 ;
13545 int ecode2 = 0 ;
13546 double val3 ;
13547 int ecode3 = 0 ;
13548 double val4 ;
13549 int ecode4 = 0 ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 PyObject * obj2 = 0 ;
13553 PyObject * obj3 = 0 ;
13554
13555 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13556 ecode1 = SWIG_AsVal_double(obj0, &val1);
13557 if (!SWIG_IsOK(ecode1)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13559 }
13560 arg1 = (PLFLT)(val1);
13561 ecode2 = SWIG_AsVal_double(obj1, &val2);
13562 if (!SWIG_IsOK(ecode2)) {
13563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13564 }
13565 arg2 = (PLFLT)(val2);
13566 ecode3 = SWIG_AsVal_double(obj2, &val3);
13567 if (!SWIG_IsOK(ecode3)) {
13568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13569 }
13570 arg3 = (PLFLT)(val3);
13571 ecode4 = SWIG_AsVal_double(obj3, &val4);
13572 if (!SWIG_IsOK(ecode4)) {
13573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13574 }
13575 arg4 = (PLFLT)(val4);
13576 plsvpa(arg1,arg2,arg3,arg4);
13577 resultobj = SWIG_Py_Void();
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13585 PyObject *resultobj = 0;
13586 PLINT arg1 ;
13587 PLINT arg2 ;
13588 int val1 ;
13589 int ecode1 = 0 ;
13590 int val2 ;
13591 int ecode2 = 0 ;
13592 PyObject * obj0 = 0 ;
13593 PyObject * obj1 = 0 ;
13594
13595 if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13596 ecode1 = SWIG_AsVal_int(obj0, &val1);
13597 if (!SWIG_IsOK(ecode1)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13599 }
13600 arg1 = (PLINT)(val1);
13601 ecode2 = SWIG_AsVal_int(obj1, &val2);
13602 if (!SWIG_IsOK(ecode2)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13604 }
13605 arg2 = (PLINT)(val2);
13606 plsxax(arg1,arg2);
13607 resultobj = SWIG_Py_Void();
13608 return resultobj;
13609 fail:
13610 return NULL;
13611 }
13612
13613
13614 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13615 PyObject *resultobj = 0;
13616 PLINT arg1 ;
13617 PLINT arg2 ;
13618 int val1 ;
13619 int ecode1 = 0 ;
13620 int val2 ;
13621 int ecode2 = 0 ;
13622 PyObject * obj0 = 0 ;
13623 PyObject * obj1 = 0 ;
13624
13625 if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13626 ecode1 = SWIG_AsVal_int(obj0, &val1);
13627 if (!SWIG_IsOK(ecode1)) {
13628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13629 }
13630 arg1 = (PLINT)(val1);
13631 ecode2 = SWIG_AsVal_int(obj1, &val2);
13632 if (!SWIG_IsOK(ecode2)) {
13633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13634 }
13635 arg2 = (PLINT)(val2);
13636 plsyax(arg1,arg2);
13637 resultobj = SWIG_Py_Void();
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13645 PyObject *resultobj = 0;
13646 PLINT arg1 ;
13647 PLFLT *arg2 = (PLFLT *) 0 ;
13648 PLFLT *arg3 = (PLFLT *) 0 ;
13649 PLINT arg4 ;
13650 PyArrayObject *tmp1 = NULL ;
13651 PyArrayObject *tmp3 = NULL ;
13652 int val4 ;
13653 int ecode4 = 0 ;
13654 PyObject * obj0 = 0 ;
13655 PyObject * obj1 = 0 ;
13656 PyObject * obj2 = 0 ;
13657
13658 if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13659 {
13660 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13661 if ( tmp1 == NULL )
13662 return NULL;
13663 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13664 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13665 }
13666 {
13667 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13668 if ( tmp3 == NULL )
13669 return NULL;
13670 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13671 {
13672 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13673 return NULL;
13674 }
13675 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13676 }
13677 ecode4 = SWIG_AsVal_int(obj2, &val4);
13678 if (!SWIG_IsOK(ecode4)) {
13679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13680 }
13681 arg4 = (PLINT)(val4);
13682 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13683 resultobj = SWIG_Py_Void();
13684 {
13685 Py_CLEAR( tmp1 );
13686 }
13687 {
13688 Py_CLEAR( tmp3 );
13689 }
13690 return resultobj;
13691 fail:
13692 {
13693 Py_CLEAR( tmp1 );
13694 }
13695 {
13696 Py_CLEAR( tmp3 );
13697 }
13698 return NULL;
13699 }
13700
13701
13702 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13703 PyObject *resultobj = 0;
13704 PLINT arg1 ;
13705 PLINT arg2 ;
13706 int val1 ;
13707 int ecode1 = 0 ;
13708 int val2 ;
13709 int ecode2 = 0 ;
13710 PyObject * obj0 = 0 ;
13711 PyObject * obj1 = 0 ;
13712
13713 if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13714 ecode1 = SWIG_AsVal_int(obj0, &val1);
13715 if (!SWIG_IsOK(ecode1)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13717 }
13718 arg1 = (PLINT)(val1);
13719 ecode2 = SWIG_AsVal_int(obj1, &val2);
13720 if (!SWIG_IsOK(ecode2)) {
13721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13722 }
13723 arg2 = (PLINT)(val2);
13724 plszax(arg1,arg2);
13725 resultobj = SWIG_Py_Void();
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13733 PyObject *resultobj = 0;
13734
13735 if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13736 pltext();
13737 resultobj = SWIG_Py_Void();
13738 return resultobj;
13739 fail:
13740 return NULL;
13741 }
13742
13743
13744 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13745 PyObject *resultobj = 0;
13746 char *arg1 = (char *) 0 ;
13747 int res1 ;
13748 char *buf1 = 0 ;
13749 int alloc1 = 0 ;
13750 PyObject * obj0 = 0 ;
13751
13752 if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13753 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13754 if (!SWIG_IsOK(res1)) {
13755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13756 }
13757 arg1 = (char *)(buf1);
13758 pltimefmt((char const *)arg1);
13759 resultobj = SWIG_Py_Void();
13760 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13761 return resultobj;
13762 fail:
13763 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13764 return NULL;
13765 }
13766
13767
13768 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13769 PyObject *resultobj = 0;
13770 PLFLT arg1 ;
13771 double val1 ;
13772 int ecode1 = 0 ;
13773 PyObject * obj0 = 0 ;
13774
13775 if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13776 ecode1 = SWIG_AsVal_double(obj0, &val1);
13777 if (!SWIG_IsOK(ecode1)) {
13778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13779 }
13780 arg1 = (PLFLT)(val1);
13781 plvasp(arg1);
13782 resultobj = SWIG_Py_Void();
13783 return resultobj;
13784 fail:
13785 return NULL;
13786 }
13787
13788
13789 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13790 PyObject *resultobj = 0;
13791 PLFLT **arg1 = (PLFLT **) 0 ;
13792 PLFLT **arg2 = (PLFLT **) 0 ;
13793 PLINT arg3 ;
13794 PLINT arg4 ;
13795 PLFLT arg5 ;
13796 pltr_func arg6 = (pltr_func) 0 ;
13797 PLPointer arg7 = (PLPointer) 0 ;
13798 PyArrayObject *tmp1 = NULL ;
13799 PyArrayObject *tmp2 = NULL ;
13800 double val5 ;
13801 int ecode5 = 0 ;
13802 PyObject * obj0 = 0 ;
13803 PyObject * obj1 = 0 ;
13804 PyObject * obj2 = 0 ;
13805 PyObject * obj3 = 0 ;
13806 PyObject * obj4 = 0 ;
13807
13808 {
13809 python_pltr = 0;
13810 arg6 = NULL;
13811 }
13812 {
13813 arg7 = NULL;
13814 }
13815 if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13816 {
13817 int i, size;
13818 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13819 if ( tmp1 == NULL )
13820 return NULL;
13821 Xlen = PyArray_DIMS( tmp1 )[0];
13822 Ylen = PyArray_DIMS( tmp1 )[1];
13823 size = Ylen;
13824 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13825 for ( i = 0; i < Xlen; i++ )
13826 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13827 }
13828 {
13829 int i, size;
13830 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13831 if ( tmp2 == NULL )
13832 return NULL;
13833 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13834 {
13835 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13836 return NULL;
13837 }
13838 arg3 = PyArray_DIMS( tmp2 )[0];
13839 arg4 = PyArray_DIMS( tmp2 )[1];
13840 size = arg4;
13841 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13842 for ( i = 0; i < arg3; i++ )
13843 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13844 }
13845 ecode5 = SWIG_AsVal_double(obj2, &val5);
13846 if (!SWIG_IsOK(ecode5)) {
13847 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13848 }
13849 arg5 = (PLFLT)(val5);
13850 if (obj3) {
13851 {
13852 // it must be a callable or None
13853 if ( obj3 == Py_None )
13854 {
13855 arg6 = NULL;
13856 }
13857 else
13858 {
13859 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13860 {
13861 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13862 return NULL;
13863 }
13864 arg6 = marshal_pltr( obj3 );
13865 }
13866 }
13867 }
13868 if (obj4) {
13869 {
13870 if ( obj4 == Py_None )
13871 arg7 = NULL;
13872 else
13873 {
13874 arg7 = marshal_PLPointer( obj4, 0 );
13875 }
13876 }
13877 }
13878 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13879 resultobj = SWIG_Py_Void();
13880 {
13881 Py_CLEAR( tmp1 );
13882 free( arg1 );
13883 }
13884 {
13885 Py_CLEAR( tmp2 );
13886 free( arg2 );
13887 }
13888 {
13889 cleanup_pltr();
13890 }
13891 {
13892 cleanup_PLPointer();
13893 }
13894 return resultobj;
13895 fail:
13896 {
13897 Py_CLEAR( tmp1 );
13898 free( arg1 );
13899 }
13900 {
13901 Py_CLEAR( tmp2 );
13902 free( arg2 );
13903 }
13904 {
13905 cleanup_pltr();
13906 }
13907 {
13908 cleanup_PLPointer();
13909 }
13910 return NULL;
13911 }
13912
13913
13914 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13915 PyObject *resultobj = 0;
13916 PLFLT arg1 ;
13917 PLFLT arg2 ;
13918 PLFLT arg3 ;
13919 PLFLT arg4 ;
13920 PLFLT arg5 ;
13921 double val1 ;
13922 int ecode1 = 0 ;
13923 double val2 ;
13924 int ecode2 = 0 ;
13925 double val3 ;
13926 int ecode3 = 0 ;
13927 double val4 ;
13928 int ecode4 = 0 ;
13929 double val5 ;
13930 int ecode5 = 0 ;
13931 PyObject * obj0 = 0 ;
13932 PyObject * obj1 = 0 ;
13933 PyObject * obj2 = 0 ;
13934 PyObject * obj3 = 0 ;
13935 PyObject * obj4 = 0 ;
13936
13937 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13938 ecode1 = SWIG_AsVal_double(obj0, &val1);
13939 if (!SWIG_IsOK(ecode1)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13941 }
13942 arg1 = (PLFLT)(val1);
13943 ecode2 = SWIG_AsVal_double(obj1, &val2);
13944 if (!SWIG_IsOK(ecode2)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13946 }
13947 arg2 = (PLFLT)(val2);
13948 ecode3 = SWIG_AsVal_double(obj2, &val3);
13949 if (!SWIG_IsOK(ecode3)) {
13950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13951 }
13952 arg3 = (PLFLT)(val3);
13953 ecode4 = SWIG_AsVal_double(obj3, &val4);
13954 if (!SWIG_IsOK(ecode4)) {
13955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13956 }
13957 arg4 = (PLFLT)(val4);
13958 ecode5 = SWIG_AsVal_double(obj4, &val5);
13959 if (!SWIG_IsOK(ecode5)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13961 }
13962 arg5 = (PLFLT)(val5);
13963 plvpas(arg1,arg2,arg3,arg4,arg5);
13964 resultobj = SWIG_Py_Void();
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13972 PyObject *resultobj = 0;
13973 PLFLT arg1 ;
13974 PLFLT arg2 ;
13975 PLFLT arg3 ;
13976 PLFLT arg4 ;
13977 double val1 ;
13978 int ecode1 = 0 ;
13979 double val2 ;
13980 int ecode2 = 0 ;
13981 double val3 ;
13982 int ecode3 = 0 ;
13983 double val4 ;
13984 int ecode4 = 0 ;
13985 PyObject * obj0 = 0 ;
13986 PyObject * obj1 = 0 ;
13987 PyObject * obj2 = 0 ;
13988 PyObject * obj3 = 0 ;
13989
13990 if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13991 ecode1 = SWIG_AsVal_double(obj0, &val1);
13992 if (!SWIG_IsOK(ecode1)) {
13993 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13994 }
13995 arg1 = (PLFLT)(val1);
13996 ecode2 = SWIG_AsVal_double(obj1, &val2);
13997 if (!SWIG_IsOK(ecode2)) {
13998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13999 }
14000 arg2 = (PLFLT)(val2);
14001 ecode3 = SWIG_AsVal_double(obj2, &val3);
14002 if (!SWIG_IsOK(ecode3)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14004 }
14005 arg3 = (PLFLT)(val3);
14006 ecode4 = SWIG_AsVal_double(obj3, &val4);
14007 if (!SWIG_IsOK(ecode4)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14009 }
14010 arg4 = (PLFLT)(val4);
14011 plvpor(arg1,arg2,arg3,arg4);
14012 resultobj = SWIG_Py_Void();
14013 return resultobj;
14014 fail:
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14020 PyObject *resultobj = 0;
14021
14022 if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
14023 plvsta();
14024 resultobj = SWIG_Py_Void();
14025 return resultobj;
14026 fail:
14027 return NULL;
14028 }
14029
14030
14031 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14032 PyObject *resultobj = 0;
14033 PLFLT arg1 ;
14034 PLFLT arg2 ;
14035 PLFLT arg3 ;
14036 PLFLT arg4 ;
14037 PLFLT arg5 ;
14038 PLFLT arg6 ;
14039 PLFLT arg7 ;
14040 PLFLT arg8 ;
14041 PLFLT arg9 ;
14042 PLFLT arg10 ;
14043 PLFLT arg11 ;
14044 double val1 ;
14045 int ecode1 = 0 ;
14046 double val2 ;
14047 int ecode2 = 0 ;
14048 double val3 ;
14049 int ecode3 = 0 ;
14050 double val4 ;
14051 int ecode4 = 0 ;
14052 double val5 ;
14053 int ecode5 = 0 ;
14054 double val6 ;
14055 int ecode6 = 0 ;
14056 double val7 ;
14057 int ecode7 = 0 ;
14058 double val8 ;
14059 int ecode8 = 0 ;
14060 double val9 ;
14061 int ecode9 = 0 ;
14062 double val10 ;
14063 int ecode10 = 0 ;
14064 double val11 ;
14065 int ecode11 = 0 ;
14066 PyObject * obj0 = 0 ;
14067 PyObject * obj1 = 0 ;
14068 PyObject * obj2 = 0 ;
14069 PyObject * obj3 = 0 ;
14070 PyObject * obj4 = 0 ;
14071 PyObject * obj5 = 0 ;
14072 PyObject * obj6 = 0 ;
14073 PyObject * obj7 = 0 ;
14074 PyObject * obj8 = 0 ;
14075 PyObject * obj9 = 0 ;
14076 PyObject * obj10 = 0 ;
14077
14078 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14079 ecode1 = SWIG_AsVal_double(obj0, &val1);
14080 if (!SWIG_IsOK(ecode1)) {
14081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14082 }
14083 arg1 = (PLFLT)(val1);
14084 ecode2 = SWIG_AsVal_double(obj1, &val2);
14085 if (!SWIG_IsOK(ecode2)) {
14086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14087 }
14088 arg2 = (PLFLT)(val2);
14089 ecode3 = SWIG_AsVal_double(obj2, &val3);
14090 if (!SWIG_IsOK(ecode3)) {
14091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14092 }
14093 arg3 = (PLFLT)(val3);
14094 ecode4 = SWIG_AsVal_double(obj3, &val4);
14095 if (!SWIG_IsOK(ecode4)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14097 }
14098 arg4 = (PLFLT)(val4);
14099 ecode5 = SWIG_AsVal_double(obj4, &val5);
14100 if (!SWIG_IsOK(ecode5)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14102 }
14103 arg5 = (PLFLT)(val5);
14104 ecode6 = SWIG_AsVal_double(obj5, &val6);
14105 if (!SWIG_IsOK(ecode6)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14107 }
14108 arg6 = (PLFLT)(val6);
14109 ecode7 = SWIG_AsVal_double(obj6, &val7);
14110 if (!SWIG_IsOK(ecode7)) {
14111 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14112 }
14113 arg7 = (PLFLT)(val7);
14114 ecode8 = SWIG_AsVal_double(obj7, &val8);
14115 if (!SWIG_IsOK(ecode8)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14117 }
14118 arg8 = (PLFLT)(val8);
14119 ecode9 = SWIG_AsVal_double(obj8, &val9);
14120 if (!SWIG_IsOK(ecode9)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14122 }
14123 arg9 = (PLFLT)(val9);
14124 ecode10 = SWIG_AsVal_double(obj9, &val10);
14125 if (!SWIG_IsOK(ecode10)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14127 }
14128 arg10 = (PLFLT)(val10);
14129 ecode11 = SWIG_AsVal_double(obj10, &val11);
14130 if (!SWIG_IsOK(ecode11)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14132 }
14133 arg11 = (PLFLT)(val11);
14134 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14135 resultobj = SWIG_Py_Void();
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143 PyObject *resultobj = 0;
14144 PLFLT arg1 ;
14145 double val1 ;
14146 int ecode1 = 0 ;
14147 PyObject * obj0 = 0 ;
14148
14149 if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
14150 ecode1 = SWIG_AsVal_double(obj0, &val1);
14151 if (!SWIG_IsOK(ecode1)) {
14152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14153 }
14154 arg1 = (PLFLT)(val1);
14155 plwidth(arg1);
14156 resultobj = SWIG_Py_Void();
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14164 PyObject *resultobj = 0;
14165 PLFLT arg1 ;
14166 PLFLT arg2 ;
14167 PLFLT arg3 ;
14168 PLFLT arg4 ;
14169 double val1 ;
14170 int ecode1 = 0 ;
14171 double val2 ;
14172 int ecode2 = 0 ;
14173 double val3 ;
14174 int ecode3 = 0 ;
14175 double val4 ;
14176 int ecode4 = 0 ;
14177 PyObject * obj0 = 0 ;
14178 PyObject * obj1 = 0 ;
14179 PyObject * obj2 = 0 ;
14180 PyObject * obj3 = 0 ;
14181
14182 if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14183 ecode1 = SWIG_AsVal_double(obj0, &val1);
14184 if (!SWIG_IsOK(ecode1)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14186 }
14187 arg1 = (PLFLT)(val1);
14188 ecode2 = SWIG_AsVal_double(obj1, &val2);
14189 if (!SWIG_IsOK(ecode2)) {
14190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14191 }
14192 arg2 = (PLFLT)(val2);
14193 ecode3 = SWIG_AsVal_double(obj2, &val3);
14194 if (!SWIG_IsOK(ecode3)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14196 }
14197 arg3 = (PLFLT)(val3);
14198 ecode4 = SWIG_AsVal_double(obj3, &val4);
14199 if (!SWIG_IsOK(ecode4)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14201 }
14202 arg4 = (PLFLT)(val4);
14203 plwind(arg1,arg2,arg3,arg4);
14204 resultobj = SWIG_Py_Void();
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14212 PyObject *resultobj = 0;
14213 PLBOOL arg1 ;
14214 PLBOOL *arg2 = (PLBOOL *) 0 ;
14215 int val1 ;
14216 int ecode1 = 0 ;
14217 PLBOOL temp2 ;
14218 int res2 = SWIG_TMPOBJ ;
14219 PyObject * obj0 = 0 ;
14220
14221 arg2 = &temp2;
14222 if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14223 ecode1 = SWIG_AsVal_int(obj0, &val1);
14224 if (!SWIG_IsOK(ecode1)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14226 }
14227 arg1 = (PLBOOL)(val1);
14228 plxormod(arg1,arg2);
14229 resultobj = SWIG_Py_Void();
14230 if (SWIG_IsTmpObj(res2)) {
14231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14232 } else {
14233 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 mapform_func arg1 = (mapform_func) 0 ;
14245 char *arg2 = (char *) 0 ;
14246 PLFLT arg3 ;
14247 PLFLT arg4 ;
14248 PLFLT arg5 ;
14249 PLFLT arg6 ;
14250 int res2 ;
14251 char *buf2 = 0 ;
14252 int alloc2 = 0 ;
14253 double val3 ;
14254 int ecode3 = 0 ;
14255 double val4 ;
14256 int ecode4 = 0 ;
14257 double val5 ;
14258 int ecode5 = 0 ;
14259 double val6 ;
14260 int ecode6 = 0 ;
14261 PyObject * obj0 = 0 ;
14262 PyObject * obj1 = 0 ;
14263 PyObject * obj2 = 0 ;
14264 PyObject * obj3 = 0 ;
14265 PyObject * obj4 = 0 ;
14266 PyObject * obj5 = 0 ;
14267
14268 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14269 {
14270 // it must be a callable or none
14271 if ( obj0 == Py_None )
14272 {
14273 arg1 = NULL;
14274 }
14275 else
14276 {
14277 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14278 {
14279 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14280 return NULL;
14281 }
14282 arg1 = marshal_mapform( obj0 );
14283 }
14284 }
14285 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14286 if (!SWIG_IsOK(res2)) {
14287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14288 }
14289 arg2 = (char *)(buf2);
14290 ecode3 = SWIG_AsVal_double(obj2, &val3);
14291 if (!SWIG_IsOK(ecode3)) {
14292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14293 }
14294 arg3 = (PLFLT)(val3);
14295 ecode4 = SWIG_AsVal_double(obj3, &val4);
14296 if (!SWIG_IsOK(ecode4)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14298 }
14299 arg4 = (PLFLT)(val4);
14300 ecode5 = SWIG_AsVal_double(obj4, &val5);
14301 if (!SWIG_IsOK(ecode5)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14303 }
14304 arg5 = (PLFLT)(val5);
14305 ecode6 = SWIG_AsVal_double(obj5, &val6);
14306 if (!SWIG_IsOK(ecode6)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14308 }
14309 arg6 = (PLFLT)(val6);
14310 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14311 resultobj = SWIG_Py_Void();
14312 {
14313 cleanup_mapform();
14314 }
14315 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14316 return resultobj;
14317 fail:
14318 {
14319 cleanup_mapform();
14320 }
14321 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 mapform_func arg1 = (mapform_func) 0 ;
14329 char *arg2 = (char *) 0 ;
14330 PLFLT arg3 ;
14331 PLFLT arg4 ;
14332 PLFLT arg5 ;
14333 PLFLT arg6 ;
14334 PLINT *arg7 = (PLINT *) 0 ;
14335 PLINT arg8 ;
14336 int res2 ;
14337 char *buf2 = 0 ;
14338 int alloc2 = 0 ;
14339 double val3 ;
14340 int ecode3 = 0 ;
14341 double val4 ;
14342 int ecode4 = 0 ;
14343 double val5 ;
14344 int ecode5 = 0 ;
14345 double val6 ;
14346 int ecode6 = 0 ;
14347 PyArrayObject *tmp7 = NULL ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 PyObject * obj2 = 0 ;
14351 PyObject * obj3 = 0 ;
14352 PyObject * obj4 = 0 ;
14353 PyObject * obj5 = 0 ;
14354 PyObject * obj6 = 0 ;
14355
14356 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14357 {
14358 // it must be a callable or none
14359 if ( obj0 == Py_None )
14360 {
14361 arg1 = NULL;
14362 }
14363 else
14364 {
14365 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14366 {
14367 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14368 return NULL;
14369 }
14370 arg1 = marshal_mapform( obj0 );
14371 }
14372 }
14373 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14374 if (!SWIG_IsOK(res2)) {
14375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14376 }
14377 arg2 = (char *)(buf2);
14378 ecode3 = SWIG_AsVal_double(obj2, &val3);
14379 if (!SWIG_IsOK(ecode3)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14381 }
14382 arg3 = (PLFLT)(val3);
14383 ecode4 = SWIG_AsVal_double(obj3, &val4);
14384 if (!SWIG_IsOK(ecode4)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14386 }
14387 arg4 = (PLFLT)(val4);
14388 ecode5 = SWIG_AsVal_double(obj4, &val5);
14389 if (!SWIG_IsOK(ecode5)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14391 }
14392 arg5 = (PLFLT)(val5);
14393 ecode6 = SWIG_AsVal_double(obj5, &val6);
14394 if (!SWIG_IsOK(ecode6)) {
14395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14396 }
14397 arg6 = (PLFLT)(val6);
14398 {
14399 if ( obj6 != Py_None )
14400 {
14401 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14402 if ( tmp7 == NULL )
14403 return NULL;
14404 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14405 arg8 = PyArray_DIMS( tmp7 )[0];
14406 }
14407 else
14408 {
14409 arg7 = NULL;
14410 arg8 = 0;
14411 }
14412 }
14413 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14414 resultobj = SWIG_Py_Void();
14415 {
14416 cleanup_mapform();
14417 }
14418 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14419 {
14420 Py_CLEAR( tmp7 );
14421 }
14422 return resultobj;
14423 fail:
14424 {
14425 cleanup_mapform();
14426 }
14427 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14428 {
14429 Py_CLEAR( tmp7 );
14430 }
14431 return NULL;
14432 }
14433
14434
14435 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14436 PyObject *resultobj = 0;
14437 mapform_func arg1 = (mapform_func) 0 ;
14438 char *arg2 = (char *) 0 ;
14439 char *arg3 = (char *) 0 ;
14440 PLFLT arg4 ;
14441 PLFLT arg5 ;
14442 PLFLT arg6 ;
14443 PLFLT arg7 ;
14444 PLINT *arg8 = (PLINT *) 0 ;
14445 PLINT arg9 ;
14446 int res2 ;
14447 char *buf2 = 0 ;
14448 int alloc2 = 0 ;
14449 int res3 ;
14450 char *buf3 = 0 ;
14451 int alloc3 = 0 ;
14452 double val4 ;
14453 int ecode4 = 0 ;
14454 double val5 ;
14455 int ecode5 = 0 ;
14456 double val6 ;
14457 int ecode6 = 0 ;
14458 double val7 ;
14459 int ecode7 = 0 ;
14460 PyArrayObject *tmp8 = NULL ;
14461 PyObject * obj0 = 0 ;
14462 PyObject * obj1 = 0 ;
14463 PyObject * obj2 = 0 ;
14464 PyObject * obj3 = 0 ;
14465 PyObject * obj4 = 0 ;
14466 PyObject * obj5 = 0 ;
14467 PyObject * obj6 = 0 ;
14468 PyObject * obj7 = 0 ;
14469
14470 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
14471 {
14472 // it must be a callable or none
14473 if ( obj0 == Py_None )
14474 {
14475 arg1 = NULL;
14476 }
14477 else
14478 {
14479 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14480 {
14481 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14482 return NULL;
14483 }
14484 arg1 = marshal_mapform( obj0 );
14485 }
14486 }
14487 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14488 if (!SWIG_IsOK(res2)) {
14489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14490 }
14491 arg2 = (char *)(buf2);
14492 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
14493 if (!SWIG_IsOK(res3)) {
14494 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14495 }
14496 arg3 = (char *)(buf3);
14497 ecode4 = SWIG_AsVal_double(obj3, &val4);
14498 if (!SWIG_IsOK(ecode4)) {
14499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14500 }
14501 arg4 = (PLFLT)(val4);
14502 ecode5 = SWIG_AsVal_double(obj4, &val5);
14503 if (!SWIG_IsOK(ecode5)) {
14504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14505 }
14506 arg5 = (PLFLT)(val5);
14507 ecode6 = SWIG_AsVal_double(obj5, &val6);
14508 if (!SWIG_IsOK(ecode6)) {
14509 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14510 }
14511 arg6 = (PLFLT)(val6);
14512 ecode7 = SWIG_AsVal_double(obj6, &val7);
14513 if (!SWIG_IsOK(ecode7)) {
14514 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14515 }
14516 arg7 = (PLFLT)(val7);
14517 {
14518 if ( obj7 != Py_None )
14519 {
14520 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
14521 if ( tmp8 == NULL )
14522 return NULL;
14523 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14524 arg9 = PyArray_DIMS( tmp8 )[0];
14525 }
14526 else
14527 {
14528 arg8 = NULL;
14529 arg9 = 0;
14530 }
14531 }
14532 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14533 resultobj = SWIG_Py_Void();
14534 {
14535 cleanup_mapform();
14536 }
14537 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14538 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14539 {
14540 Py_CLEAR( tmp8 );
14541 }
14542 return resultobj;
14543 fail:
14544 {
14545 cleanup_mapform();
14546 }
14547 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14548 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14549 {
14550 Py_CLEAR( tmp8 );
14551 }
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14557 PyObject *resultobj = 0;
14558 mapform_func arg1 = (mapform_func) 0 ;
14559 char *arg2 = (char *) 0 ;
14560 PLFLT arg3 ;
14561 PLFLT arg4 ;
14562 PLFLT arg5 ;
14563 char *arg6 = (char *) 0 ;
14564 PLFLT arg7 ;
14565 PLFLT arg8 ;
14566 PLFLT arg9 ;
14567 PLFLT arg10 ;
14568 PLINT arg11 ;
14569 int res2 ;
14570 char *buf2 = 0 ;
14571 int alloc2 = 0 ;
14572 double val3 ;
14573 int ecode3 = 0 ;
14574 double val4 ;
14575 int ecode4 = 0 ;
14576 double val5 ;
14577 int ecode5 = 0 ;
14578 int res6 ;
14579 char *buf6 = 0 ;
14580 int alloc6 = 0 ;
14581 double val7 ;
14582 int ecode7 = 0 ;
14583 double val8 ;
14584 int ecode8 = 0 ;
14585 double val9 ;
14586 int ecode9 = 0 ;
14587 double val10 ;
14588 int ecode10 = 0 ;
14589 int val11 ;
14590 int ecode11 = 0 ;
14591 PyObject * obj0 = 0 ;
14592 PyObject * obj1 = 0 ;
14593 PyObject * obj2 = 0 ;
14594 PyObject * obj3 = 0 ;
14595 PyObject * obj4 = 0 ;
14596 PyObject * obj5 = 0 ;
14597 PyObject * obj6 = 0 ;
14598 PyObject * obj7 = 0 ;
14599 PyObject * obj8 = 0 ;
14600 PyObject * obj9 = 0 ;
14601 PyObject * obj10 = 0 ;
14602
14603 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14604 {
14605 // it must be a callable or none
14606 if ( obj0 == Py_None )
14607 {
14608 arg1 = NULL;
14609 }
14610 else
14611 {
14612 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14613 {
14614 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14615 return NULL;
14616 }
14617 arg1 = marshal_mapform( obj0 );
14618 }
14619 }
14620 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14621 if (!SWIG_IsOK(res2)) {
14622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14623 }
14624 arg2 = (char *)(buf2);
14625 ecode3 = SWIG_AsVal_double(obj2, &val3);
14626 if (!SWIG_IsOK(ecode3)) {
14627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14628 }
14629 arg3 = (PLFLT)(val3);
14630 ecode4 = SWIG_AsVal_double(obj3, &val4);
14631 if (!SWIG_IsOK(ecode4)) {
14632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14633 }
14634 arg4 = (PLFLT)(val4);
14635 ecode5 = SWIG_AsVal_double(obj4, &val5);
14636 if (!SWIG_IsOK(ecode5)) {
14637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14638 }
14639 arg5 = (PLFLT)(val5);
14640 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
14641 if (!SWIG_IsOK(res6)) {
14642 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14643 }
14644 arg6 = (char *)(buf6);
14645 ecode7 = SWIG_AsVal_double(obj6, &val7);
14646 if (!SWIG_IsOK(ecode7)) {
14647 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14648 }
14649 arg7 = (PLFLT)(val7);
14650 ecode8 = SWIG_AsVal_double(obj7, &val8);
14651 if (!SWIG_IsOK(ecode8)) {
14652 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14653 }
14654 arg8 = (PLFLT)(val8);
14655 ecode9 = SWIG_AsVal_double(obj8, &val9);
14656 if (!SWIG_IsOK(ecode9)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14658 }
14659 arg9 = (PLFLT)(val9);
14660 ecode10 = SWIG_AsVal_double(obj9, &val10);
14661 if (!SWIG_IsOK(ecode10)) {
14662 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14663 }
14664 arg10 = (PLFLT)(val10);
14665 ecode11 = SWIG_AsVal_int(obj10, &val11);
14666 if (!SWIG_IsOK(ecode11)) {
14667 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14668 }
14669 arg11 = (PLINT)(val11);
14670 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14671 resultobj = SWIG_Py_Void();
14672 {
14673 cleanup_mapform();
14674 }
14675 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14676 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14677 return resultobj;
14678 fail:
14679 {
14680 cleanup_mapform();
14681 }
14682 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14683 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14689 PyObject *resultobj = 0;
14690 mapform_func arg1 = (mapform_func) 0 ;
14691 char *arg2 = (char *) 0 ;
14692 PLFLT arg3 ;
14693 PLFLT arg4 ;
14694 PLFLT arg5 ;
14695 PLFLT arg6 ;
14696 PLINT *arg7 = (PLINT *) 0 ;
14697 PLINT arg8 ;
14698 int res2 ;
14699 char *buf2 = 0 ;
14700 int alloc2 = 0 ;
14701 double val3 ;
14702 int ecode3 = 0 ;
14703 double val4 ;
14704 int ecode4 = 0 ;
14705 double val5 ;
14706 int ecode5 = 0 ;
14707 double val6 ;
14708 int ecode6 = 0 ;
14709 PyArrayObject *tmp7 = NULL ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 PyObject * obj2 = 0 ;
14713 PyObject * obj3 = 0 ;
14714 PyObject * obj4 = 0 ;
14715 PyObject * obj5 = 0 ;
14716 PyObject * obj6 = 0 ;
14717
14718 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14719 {
14720 // it must be a callable or none
14721 if ( obj0 == Py_None )
14722 {
14723 arg1 = NULL;
14724 }
14725 else
14726 {
14727 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14728 {
14729 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14730 return NULL;
14731 }
14732 arg1 = marshal_mapform( obj0 );
14733 }
14734 }
14735 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14736 if (!SWIG_IsOK(res2)) {
14737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14738 }
14739 arg2 = (char *)(buf2);
14740 ecode3 = SWIG_AsVal_double(obj2, &val3);
14741 if (!SWIG_IsOK(ecode3)) {
14742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14743 }
14744 arg3 = (PLFLT)(val3);
14745 ecode4 = SWIG_AsVal_double(obj3, &val4);
14746 if (!SWIG_IsOK(ecode4)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14748 }
14749 arg4 = (PLFLT)(val4);
14750 ecode5 = SWIG_AsVal_double(obj4, &val5);
14751 if (!SWIG_IsOK(ecode5)) {
14752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14753 }
14754 arg5 = (PLFLT)(val5);
14755 ecode6 = SWIG_AsVal_double(obj5, &val6);
14756 if (!SWIG_IsOK(ecode6)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14758 }
14759 arg6 = (PLFLT)(val6);
14760 {
14761 if ( obj6 != Py_None )
14762 {
14763 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14764 if ( tmp7 == NULL )
14765 return NULL;
14766 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14767 arg8 = PyArray_DIMS( tmp7 )[0];
14768 }
14769 else
14770 {
14771 arg7 = NULL;
14772 arg8 = 0;
14773 }
14774 }
14775 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14776 resultobj = SWIG_Py_Void();
14777 {
14778 cleanup_mapform();
14779 }
14780 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14781 {
14782 Py_CLEAR( tmp7 );
14783 }
14784 return resultobj;
14785 fail:
14786 {
14787 cleanup_mapform();
14788 }
14789 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14790 {
14791 Py_CLEAR( tmp7 );
14792 }
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 PyObject *resultobj = 0;
14799 mapform_func arg1 = (mapform_func) 0 ;
14800 PLFLT arg2 ;
14801 PLFLT arg3 ;
14802 PLFLT arg4 ;
14803 PLFLT arg5 ;
14804 PLFLT arg6 ;
14805 PLFLT arg7 ;
14806 double val2 ;
14807 int ecode2 = 0 ;
14808 double val3 ;
14809 int ecode3 = 0 ;
14810 double val4 ;
14811 int ecode4 = 0 ;
14812 double val5 ;
14813 int ecode5 = 0 ;
14814 double val6 ;
14815 int ecode6 = 0 ;
14816 double val7 ;
14817 int ecode7 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 PyObject * obj3 = 0 ;
14822 PyObject * obj4 = 0 ;
14823 PyObject * obj5 = 0 ;
14824 PyObject * obj6 = 0 ;
14825
14826 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14827 {
14828 // it must be a callable or none
14829 if ( obj0 == Py_None )
14830 {
14831 arg1 = NULL;
14832 }
14833 else
14834 {
14835 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14836 {
14837 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14838 return NULL;
14839 }
14840 arg1 = marshal_mapform( obj0 );
14841 }
14842 }
14843 ecode2 = SWIG_AsVal_double(obj1, &val2);
14844 if (!SWIG_IsOK(ecode2)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14846 }
14847 arg2 = (PLFLT)(val2);
14848 ecode3 = SWIG_AsVal_double(obj2, &val3);
14849 if (!SWIG_IsOK(ecode3)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14851 }
14852 arg3 = (PLFLT)(val3);
14853 ecode4 = SWIG_AsVal_double(obj3, &val4);
14854 if (!SWIG_IsOK(ecode4)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14856 }
14857 arg4 = (PLFLT)(val4);
14858 ecode5 = SWIG_AsVal_double(obj4, &val5);
14859 if (!SWIG_IsOK(ecode5)) {
14860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14861 }
14862 arg5 = (PLFLT)(val5);
14863 ecode6 = SWIG_AsVal_double(obj5, &val6);
14864 if (!SWIG_IsOK(ecode6)) {
14865 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14866 }
14867 arg6 = (PLFLT)(val6);
14868 ecode7 = SWIG_AsVal_double(obj6, &val7);
14869 if (!SWIG_IsOK(ecode7)) {
14870 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14871 }
14872 arg7 = (PLFLT)(val7);
14873 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14874 resultobj = SWIG_Py_Void();
14875 {
14876 cleanup_mapform();
14877 }
14878 return resultobj;
14879 fail:
14880 {
14881 cleanup_mapform();
14882 }
14883 return NULL;
14884 }
14885
14886
14887 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14888 PyObject *resultobj = 0;
14889 PLFLT **arg1 = (PLFLT **) 0 ;
14890 PLINT arg2 ;
14891 PLINT arg3 ;
14892 PLFLT arg4 ;
14893 PLFLT arg5 ;
14894 PLFLT arg6 ;
14895 PLFLT arg7 ;
14896 PLFLT arg8 ;
14897 PLFLT arg9 ;
14898 PLFLT arg10 ;
14899 PLFLT arg11 ;
14900 PLFLT arg12 ;
14901 PLFLT arg13 ;
14902 PyArrayObject *tmp1 = NULL ;
14903 double val4 ;
14904 int ecode4 = 0 ;
14905 double val5 ;
14906 int ecode5 = 0 ;
14907 double val6 ;
14908 int ecode6 = 0 ;
14909 double val7 ;
14910 int ecode7 = 0 ;
14911 double val8 ;
14912 int ecode8 = 0 ;
14913 double val9 ;
14914 int ecode9 = 0 ;
14915 double val10 ;
14916 int ecode10 = 0 ;
14917 double val11 ;
14918 int ecode11 = 0 ;
14919 double val12 ;
14920 int ecode12 = 0 ;
14921 double val13 ;
14922 int ecode13 = 0 ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 PyObject * obj2 = 0 ;
14926 PyObject * obj3 = 0 ;
14927 PyObject * obj4 = 0 ;
14928 PyObject * obj5 = 0 ;
14929 PyObject * obj6 = 0 ;
14930 PyObject * obj7 = 0 ;
14931 PyObject * obj8 = 0 ;
14932 PyObject * obj9 = 0 ;
14933 PyObject * obj10 = 0 ;
14934
14935 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14936 {
14937 int i, size;
14938 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14939 if ( tmp1 == NULL )
14940 return NULL;
14941 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14942 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14943 size = arg3;
14944 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14945 for ( i = 0; i < arg2; i++ )
14946 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14947 }
14948 ecode4 = SWIG_AsVal_double(obj1, &val4);
14949 if (!SWIG_IsOK(ecode4)) {
14950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14951 }
14952 arg4 = (PLFLT)(val4);
14953 ecode5 = SWIG_AsVal_double(obj2, &val5);
14954 if (!SWIG_IsOK(ecode5)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14956 }
14957 arg5 = (PLFLT)(val5);
14958 ecode6 = SWIG_AsVal_double(obj3, &val6);
14959 if (!SWIG_IsOK(ecode6)) {
14960 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14961 }
14962 arg6 = (PLFLT)(val6);
14963 ecode7 = SWIG_AsVal_double(obj4, &val7);
14964 if (!SWIG_IsOK(ecode7)) {
14965 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14966 }
14967 arg7 = (PLFLT)(val7);
14968 ecode8 = SWIG_AsVal_double(obj5, &val8);
14969 if (!SWIG_IsOK(ecode8)) {
14970 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14971 }
14972 arg8 = (PLFLT)(val8);
14973 ecode9 = SWIG_AsVal_double(obj6, &val9);
14974 if (!SWIG_IsOK(ecode9)) {
14975 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14976 }
14977 arg9 = (PLFLT)(val9);
14978 ecode10 = SWIG_AsVal_double(obj7, &val10);
14979 if (!SWIG_IsOK(ecode10)) {
14980 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14981 }
14982 arg10 = (PLFLT)(val10);
14983 ecode11 = SWIG_AsVal_double(obj8, &val11);
14984 if (!SWIG_IsOK(ecode11)) {
14985 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14986 }
14987 arg11 = (PLFLT)(val11);
14988 ecode12 = SWIG_AsVal_double(obj9, &val12);
14989 if (!SWIG_IsOK(ecode12)) {
14990 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14991 }
14992 arg12 = (PLFLT)(val12);
14993 ecode13 = SWIG_AsVal_double(obj10, &val13);
14994 if (!SWIG_IsOK(ecode13)) {
14995 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14996 }
14997 arg13 = (PLFLT)(val13);
14998 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14999 resultobj = SWIG_Py_Void();
15000 {
15001 Py_CLEAR( tmp1 );
15002 free( arg1 );
15003 }
15004 return resultobj;
15005 fail:
15006 {
15007 Py_CLEAR( tmp1 );
15008 free( arg1 );
15009 }
15010 return NULL;
15011 }
15012
15013
15014 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15015 PyObject *resultobj = 0;
15016 PLFLT **arg1 = (PLFLT **) 0 ;
15017 PLINT arg2 ;
15018 PLINT arg3 ;
15019 PLFLT arg4 ;
15020 PLFLT arg5 ;
15021 PLFLT arg6 ;
15022 PLFLT arg7 ;
15023 PLFLT arg8 ;
15024 PLFLT arg9 ;
15025 PLFLT arg10 ;
15026 PLFLT arg11 ;
15027 pltr_func arg12 = (pltr_func) 0 ;
15028 PLPointer arg13 = (PLPointer) 0 ;
15029 PyArrayObject *tmp1 = NULL ;
15030 double val4 ;
15031 int ecode4 = 0 ;
15032 double val5 ;
15033 int ecode5 = 0 ;
15034 double val6 ;
15035 int ecode6 = 0 ;
15036 double val7 ;
15037 int ecode7 = 0 ;
15038 double val8 ;
15039 int ecode8 = 0 ;
15040 double val9 ;
15041 int ecode9 = 0 ;
15042 double val10 ;
15043 int ecode10 = 0 ;
15044 double val11 ;
15045 int ecode11 = 0 ;
15046 PyObject * obj0 = 0 ;
15047 PyObject * obj1 = 0 ;
15048 PyObject * obj2 = 0 ;
15049 PyObject * obj3 = 0 ;
15050 PyObject * obj4 = 0 ;
15051 PyObject * obj5 = 0 ;
15052 PyObject * obj6 = 0 ;
15053 PyObject * obj7 = 0 ;
15054 PyObject * obj8 = 0 ;
15055 PyObject * obj9 = 0 ;
15056 PyObject * obj10 = 0 ;
15057
15058 {
15059 python_pltr = 0;
15060 arg12 = NULL;
15061 }
15062 {
15063 arg13 = NULL;
15064 }
15065 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
15066 {
15067 int i, size;
15068 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15069 if ( tmp1 == NULL )
15070 return NULL;
15071 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15072 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15073 size = arg3;
15074 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15075 for ( i = 0; i < arg2; i++ )
15076 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15077 }
15078 ecode4 = SWIG_AsVal_double(obj1, &val4);
15079 if (!SWIG_IsOK(ecode4)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15081 }
15082 arg4 = (PLFLT)(val4);
15083 ecode5 = SWIG_AsVal_double(obj2, &val5);
15084 if (!SWIG_IsOK(ecode5)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15086 }
15087 arg5 = (PLFLT)(val5);
15088 ecode6 = SWIG_AsVal_double(obj3, &val6);
15089 if (!SWIG_IsOK(ecode6)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15091 }
15092 arg6 = (PLFLT)(val6);
15093 ecode7 = SWIG_AsVal_double(obj4, &val7);
15094 if (!SWIG_IsOK(ecode7)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15096 }
15097 arg7 = (PLFLT)(val7);
15098 ecode8 = SWIG_AsVal_double(obj5, &val8);
15099 if (!SWIG_IsOK(ecode8)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15101 }
15102 arg8 = (PLFLT)(val8);
15103 ecode9 = SWIG_AsVal_double(obj6, &val9);
15104 if (!SWIG_IsOK(ecode9)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15106 }
15107 arg9 = (PLFLT)(val9);
15108 ecode10 = SWIG_AsVal_double(obj7, &val10);
15109 if (!SWIG_IsOK(ecode10)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15111 }
15112 arg10 = (PLFLT)(val10);
15113 ecode11 = SWIG_AsVal_double(obj8, &val11);
15114 if (!SWIG_IsOK(ecode11)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15116 }
15117 arg11 = (PLFLT)(val11);
15118 if (obj9) {
15119 {
15120 // it must be a callable or None
15121 if ( obj9 == Py_None )
15122 {
15123 arg12 = NULL;
15124 }
15125 else
15126 {
15127 if ( !PyCallable_Check( (PyObject *) obj9 ) )
15128 {
15129 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15130 return NULL;
15131 }
15132 arg12 = marshal_pltr( obj9 );
15133 }
15134 }
15135 }
15136 if (obj10) {
15137 {
15138 if ( obj10 == Py_None )
15139 arg13 = NULL;
15140 else
15141 {
15142 arg13 = marshal_PLPointer( obj10, 1 );
15143 }
15144 }
15145 }
15146 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15147 resultobj = SWIG_Py_Void();
15148 {
15149 Py_CLEAR( tmp1 );
15150 free( arg1 );
15151 }
15152 {
15153 cleanup_pltr();
15154 }
15155 {
15156 cleanup_PLPointer();
15157 }
15158 return resultobj;
15159 fail:
15160 {
15161 Py_CLEAR( tmp1 );
15162 free( arg1 );
15163 }
15164 {
15165 cleanup_pltr();
15166 }
15167 {
15168 cleanup_PLPointer();
15169 }
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15175 PyObject *resultobj = 0;
15176
15177 if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
15178 plClearOpts();
15179 resultobj = SWIG_Py_Void();
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15187 PyObject *resultobj = 0;
15188
15189 if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
15190 plResetOpts();
15191 resultobj = SWIG_Py_Void();
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 char *arg1 = (char *) 0 ;
15201 char *arg2 = (char *) 0 ;
15202 int res1 ;
15203 char *buf1 = 0 ;
15204 int alloc1 = 0 ;
15205 int res2 ;
15206 char *buf2 = 0 ;
15207 int alloc2 = 0 ;
15208 PyObject * obj0 = 0 ;
15209 PyObject * obj1 = 0 ;
15210
15211 if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
15212 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
15213 if (!SWIG_IsOK(res1)) {
15214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15215 }
15216 arg1 = (char *)(buf1);
15217 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15218 if (!SWIG_IsOK(res2)) {
15219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15220 }
15221 arg2 = (char *)(buf2);
15222 plSetUsage((char const *)arg1,(char const *)arg2);
15223 resultobj = SWIG_Py_Void();
15224 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15225 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15226 return resultobj;
15227 fail:
15228 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15229 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15230 return NULL;
15231 }
15232
15233
15234 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15235 PyObject *resultobj = 0;
15236
15237 if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
15238 plOptUsage();
15239 resultobj = SWIG_Py_Void();
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *resultobj = 0;
15248 PLFLT **arg1 = (PLFLT **) 0 ;
15249 PLINT arg2 ;
15250 PLINT arg3 ;
15251 PLFLT *arg4 = (PLFLT *) 0 ;
15252 PLFLT *arg5 = (PLFLT *) 0 ;
15253 PyArrayObject *tmp1 = NULL ;
15254 PLFLT temp4 ;
15255 int res4 = SWIG_TMPOBJ ;
15256 PLFLT temp5 ;
15257 int res5 = SWIG_TMPOBJ ;
15258 PyObject * obj0 = 0 ;
15259
15260 arg4 = &temp4;
15261 arg5 = &temp5;
15262 if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
15263 {
15264 int i, size;
15265 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15266 if ( tmp1 == NULL )
15267 return NULL;
15268 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15269 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15270 size = arg3;
15271 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15272 for ( i = 0; i < arg2; i++ )
15273 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15274 }
15275 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15276 resultobj = SWIG_Py_Void();
15277 if (SWIG_IsTmpObj(res4)) {
15278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15279 } else {
15280 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15282 }
15283 if (SWIG_IsTmpObj(res5)) {
15284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15285 } else {
15286 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15288 }
15289 {
15290 Py_CLEAR( tmp1 );
15291 free( arg1 );
15292 }
15293 return resultobj;
15294 fail:
15295 {
15296 Py_CLEAR( tmp1 );
15297 free( arg1 );
15298 }
15299 return NULL;
15300 }
15301
15302
15303 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15304 PyObject *resultobj = 0;
15305 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15306 void *argp1 = 0 ;
15307 int res1 = 0 ;
15308 PyObject * obj0 = 0 ;
15309 PLINT result;
15310
15311 if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
15312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15315 }
15316 arg1 = (PLGraphicsIn *)(argp1);
15317 result = (PLINT)plGetCursor(arg1);
15318 resultobj = SWIG_From_int((int)(result));
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 static PyMethodDef SwigMethods[] = {
15326 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
15327 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15328 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15329 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15330 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15331 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
15332 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15333 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
15334 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15335 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
15336 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15337 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
15338 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15339 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
15340 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15341 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
15342 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15343 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
15344 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15345 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
15346 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15347 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
15348 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15349 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
15350 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15351 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
15352 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15353 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
15354 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
15355 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
15356 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
15357 { "plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
15358 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
15359 "Set format of numerical label for contours\n"
15360 "\n"
15361 "DESCRIPTION:\n"
15362 "\n"
15363 " Set format of numerical label for contours.\n"
15364 "\n"
15365 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15366 "\n"
15367 " This function is used example 9.\n"
15368 "\n"
15369 "\n"
15370 "\n"
15371 "SYNOPSIS:\n"
15372 "\n"
15373 "pl_setcontlabelformat(lexp, sigdig)\n"
15374 "\n"
15375 "ARGUMENTS:\n"
15376 "\n"
15377 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15378 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15379 " format is used. Default value of lexp is 4.\n"
15380 "\n"
15381 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15382 " value is 2.\n"
15383 "\n"
15384 ""},
15385 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
15386 "Set parameters of contour labelling other than format of numerical label\n"
15387 "\n"
15388 "DESCRIPTION:\n"
15389 "\n"
15390 " Set parameters of contour labelling other than those handled by\n"
15391 " pl_setcontlabelformat.\n"
15392 "\n"
15393 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15394 "\n"
15395 " This function is used in example 9.\n"
15396 "\n"
15397 "\n"
15398 "\n"
15399 "SYNOPSIS:\n"
15400 "\n"
15401 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15402 "\n"
15403 "ARGUMENTS:\n"
15404 "\n"
15405 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15406 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15407 "\n"
15408 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15409 " Default value is 0.3.\n"
15410 "\n"
15411 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15412 " Default value is 0.1.\n"
15413 "\n"
15414 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15415 " contour labels on. Default is off (0).\n"
15416 "\n"
15417 ""},
15418 { "pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
15419 "Advance the (sub-)page\n"
15420 "\n"
15421 "DESCRIPTION:\n"
15422 "\n"
15423 " Advances to the next subpage if sub=0, performing a page advance if\n"
15424 " there are no remaining subpages on the current page. If subpages\n"
15425 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15426 " PLplot switches to the specified subpage. Note that this allows you\n"
15427 " to overwrite a plot on the specified subpage; if this is not what you\n"
15428 " intended, use pleop followed by plbop to first advance the page. This\n"
15429 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15430 " is not used, pladv must be called after initializing PLplot but before\n"
15431 " defining the viewport.\n"
15432 "\n"
15433 " Redacted form: pladv(page)\n"
15434 "\n"
15435 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15436 " 29, and 31.\n"
15437 "\n"
15438 "\n"
15439 "\n"
15440 "SYNOPSIS:\n"
15441 "\n"
15442 "pladv(page)\n"
15443 "\n"
15444 "ARGUMENTS:\n"
15445 "\n"
15446 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15447 " in the top left corner and increasing along the rows) to which to\n"
15448 " advance. Set to zero to advance to the next subpage (or to the\n"
15449 " next page if subpages are not being used).\n"
15450 "\n"
15451 ""},
15452 { "plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
15453 "Draw a circular or elliptical arc\n"
15454 "\n"
15455 "DESCRIPTION:\n"
15456 "\n"
15457 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15458 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15459 "\n"
15460 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15461 " fill)\n"
15462 "\n"
15463 "\n"
15464 " This function is used in examples 3 and 27.\n"
15465 "\n"
15466 "\n"
15467 "\n"
15468 "SYNOPSIS:\n"
15469 "\n"
15470 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15471 "\n"
15472 "ARGUMENTS:\n"
15473 "\n"
15474 " x (PLFLT, input) : X coordinate of arc center.\n"
15475 "\n"
15476 " y (PLFLT, input) : Y coordinate of arc center.\n"
15477 "\n"
15478 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15479 "\n"
15480 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15481 "\n"
15482 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15483 " semimajor axis.\n"
15484 "\n"
15485 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15486 " semimajor axis.\n"
15487 "\n"
15488 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15489 " X-axis.\n"
15490 "\n"
15491 " fill (PLBOOL, input) : Draw a filled arc.\n"
15492 "\n"
15493 ""},
15494 { "plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
15495 "Draw a box with axes, etc. with arbitrary origin\n"
15496 "\n"
15497 "DESCRIPTION:\n"
15498 "\n"
15499 " Draws a box around the currently defined viewport with arbitrary\n"
15500 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15501 " world coordinate values appropriate to the window. Thus plaxes should\n"
15502 " only be called after defining both viewport and window. The ascii\n"
15503 " character strings xopt and yopt specify how the box should be drawn as\n"
15504 " described below. If ticks and/or subticks are to be drawn for a\n"
15505 " particular axis, the tick intervals and number of subintervals may be\n"
15506 " specified explicitly, or they may be defaulted by setting the\n"
15507 " appropriate arguments to zero.\n"
15508 "\n"
15509 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15510 " ytick, nysub)\n"
15511 "\n"
15512 "\n"
15513 " This function is not used in any examples.\n"
15514 "\n"
15515 "\n"
15516 "\n"
15517 "SYNOPSIS:\n"
15518 "\n"
15519 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15520 "\n"
15521 "ARGUMENTS:\n"
15522 "\n"
15523 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15524 "\n"
15525 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15526 "\n"
15527 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15528 " options for the x axis. The string can include any combination of\n"
15529 " the following letters (upper or lower case) in any order: a: Draws\n"
15530 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15531 " (x=0).\n"
15532 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15533 " c: Draws top (X) or right (Y) edge of frame.\n"
15534 " d: Plot labels as date / time. Values are assumed to be\n"
15535 " seconds since the epoch (as used by gmtime).\n"
15536 " f: Always use fixed point numeric labels.\n"
15537 " g: Draws a grid at the major tick interval.\n"
15538 " h: Draws a grid at the minor tick interval.\n"
15539 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15540 " inwards.\n"
15541 " l: Labels axis logarithmically. This only affects the labels,\n"
15542 " not the data, and so it is necessary to compute the logarithms\n"
15543 " of data points before passing them to any of the drawing\n"
15544 " routines.\n"
15545 " m: Writes numeric labels at major tick intervals in the\n"
15546 " unconventional location (above box for X, right of box for Y).\n"
15547 " n: Writes numeric labels at major tick intervals in the\n"
15548 " conventional location (below box for X, left of box for Y).\n"
15549 " o: Use custom labelling function to generate axis label text.\n"
15550 " The custom labelling function can be defined with the\n"
15551 " plslabelfunc command.\n"
15552 " s: Enables subticks between major ticks, only valid if t is\n"
15553 " also specified.\n"
15554 " t: Draws major ticks.\n"
15555 " u: Exactly like \"b\" except don't draw edge line.\n"
15556 " w: Exactly like \"c\" except don't draw edge line.\n"
15557 " x: Exactly like \"t\" (including the side effect of the\n"
15558 " numerical labels for the major ticks) except exclude drawing\n"
15559 " the major and minor tick marks.\n"
15560 "\n"
15561 "\n"
15562 " xtick (PLFLT, input) : World coordinate interval between major\n"
15563 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15564 " generates a suitable tick interval.\n"
15565 "\n"
15566 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15567 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15568 " generates a suitable minor tick interval.\n"
15569 "\n"
15570 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15571 " options for the y axis. The string can include any combination of\n"
15572 " the letters defined above for xopt, and in addition may contain:\n"
15573 " v: Write numeric labels for the y axis parallel to the base of the\n"
15574 " graph, rather than parallel to the axis.\n"
15575 "\n"
15576 "\n"
15577 " ytick (PLFLT, input) : World coordinate interval between major\n"
15578 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15579 " generates a suitable tick interval.\n"
15580 "\n"
15581 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15582 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15583 " generates a suitable minor tick interval.\n"
15584 "\n"
15585 ""},
15586 { "plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
15587 "Plot a histogram from binned data\n"
15588 "\n"
15589 "DESCRIPTION:\n"
15590 "\n"
15591 " Plots a histogram consisting of nbin bins. The value associated with\n"
15592 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15593 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15594 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15595 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15596 " placed midway between the values in the x vector. Also see plhist for\n"
15597 " drawing histograms from unbinned data.\n"
15598 "\n"
15599 " Redacted form: General: plbin(x, y, opt)\n"
15600 " Python: plbin(nbin, x, y, opt)\n"
15601 "\n"
15602 "\n"
15603 " This function is not used in any examples.\n"
15604 "\n"
15605 "\n"
15606 "\n"
15607 "SYNOPSIS:\n"
15608 "\n"
15609 "plbin(nbin, x, y, opt)\n"
15610 "\n"
15611 "ARGUMENTS:\n"
15612 "\n"
15613 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15614 " and y vectors.)\n"
15615 "\n"
15616 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15617 " with bins. These must form a strictly increasing sequence.\n"
15618 "\n"
15619 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15620 " proportional to the number of points in each bin. This is a PLFLT\n"
15621 " (instead of PLINT) vector so as to allow histograms of\n"
15622 " probabilities, etc.\n"
15623 "\n"
15624 " opt (PLINT, input) : Is a combination of several flags:\n"
15625 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15626 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15627 " zero height are simply drawn.\n"
15628 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15629 " between the x values. If the values in x are equally spaced,\n"
15630 " the values are the center values of the bins.\n"
15631 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15632 " size as the ones inside.\n"
15633 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15634 " (there is a gap for such bins).\n"
15635 "\n"
15636 ""},
15637 { "plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15638 "Calculate broken-down time from continuous time for the current stream\n"
15639 "\n"
15640 "DESCRIPTION:\n"
15641 "\n"
15642 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15643 " continuous time, ctime for the current stream. This function is the\n"
15644 " inverse of plctime.\n"
15645 "\n"
15646 " The PLplot definition of broken-down time is a calendar time that\n"
15647 " completely ignores all time zone offsets, i.e., it is the user's\n"
15648 " responsibility to apply those offsets (if so desired) before using the\n"
15649 " PLplot time API. By default broken-down time is defined using the\n"
15650 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15651 " continuous time is defined as the number of seconds since the Unix\n"
15652 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15653 " broken-down and continuous time are possible, see plconfigtime.\n"
15654 "\n"
15655 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15656 " ctime)\n"
15657 "\n"
15658 "\n"
15659 " This function is used in example 29.\n"
15660 "\n"
15661 "\n"
15662 "\n"
15663 "SYNOPSIS:\n"
15664 "\n"
15665 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15666 "\n"
15667 "ARGUMENTS:\n"
15668 "\n"
15669 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15670 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15671 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15672 " BCE, etc.)\n"
15673 "\n"
15674 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15675 " the year in the range from 0 (January) to 11 (December).\n"
15676 "\n"
15677 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15678 " month in the range from 1 to 31.\n"
15679 "\n"
15680 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15681 " day in the range from 0 to 23.\n"
15682 "\n"
15683 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15684 " hour in the range from 0 to 59\n"
15685 "\n"
15686 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15687 " minute in range from 0. to 60.\n"
15688 "\n"
15689 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15690 " time is calculated.\n"
15691 "\n"
15692 ""},
15693 { "plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15694 "Begin a new page\n"
15695 "\n"
15696 "DESCRIPTION:\n"
15697 "\n"
15698 " Begins a new page. For a file driver, the output file is opened if\n"
15699 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15700 " page break is desired at a particular point when plotting to subpages.\n"
15701 " Another use for pleop and plbop is when plotting pages to different\n"
15702 " files, since you can manually set the file name by calling plsfnam\n"
15703 " after the call to pleop. (In fact some drivers may only support a\n"
15704 " single page per file, making this a necessity.) One way to handle\n"
15705 " this case automatically is to page advance via pladv, but enable\n"
15706 " familying (see plsfam) with a small limit on the file size so that a\n"
15707 " new family member file will be created on each page break.\n"
15708 "\n"
15709 " Redacted form: plbop()\n"
15710 "\n"
15711 " This function is used in examples 2 and 20.\n"
15712 "\n"
15713 "\n"
15714 "\n"
15715 "SYNOPSIS:\n"
15716 "\n"
15717 "plbop()\n"
15718 "\n"
15719 ""},
15720 { "plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15721 "Draw a box with axes, etc\n"
15722 "\n"
15723 "DESCRIPTION:\n"
15724 "\n"
15725 " Draws a box around the currently defined viewport, and labels it with\n"
15726 " world coordinate values appropriate to the window. Thus plbox should\n"
15727 " only be called after defining both viewport and window. The ascii\n"
15728 " character strings xopt and yopt specify how the box should be drawn as\n"
15729 " described below. If ticks and/or subticks are to be drawn for a\n"
15730 " particular axis, the tick intervals and number of subintervals may be\n"
15731 " specified explicitly, or they may be defaulted by setting the\n"
15732 " appropriate arguments to zero.\n"
15733 "\n"
15734 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15735 "\n"
15736 "\n"
15737 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15738 " and 29.\n"
15739 "\n"
15740 "\n"
15741 "\n"
15742 "SYNOPSIS:\n"
15743 "\n"
15744 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15745 "\n"
15746 "ARGUMENTS:\n"
15747 "\n"
15748 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15749 " options for the x axis. The string can include any combination of\n"
15750 " the following letters (upper or lower case) in any order: a: Draws\n"
15751 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15752 " (x=0).\n"
15753 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15754 " c: Draws top (X) or right (Y) edge of frame.\n"
15755 " d: Plot labels as date / time. Values are assumed to be\n"
15756 " seconds since the epoch (as used by gmtime).\n"
15757 " f: Always use fixed point numeric labels.\n"
15758 " g: Draws a grid at the major tick interval.\n"
15759 " h: Draws a grid at the minor tick interval.\n"
15760 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15761 " inwards.\n"
15762 " l: Labels axis logarithmically. This only affects the labels,\n"
15763 " not the data, and so it is necessary to compute the logarithms\n"
15764 " of data points before passing them to any of the drawing\n"
15765 " routines.\n"
15766 " m: Writes numeric labels at major tick intervals in the\n"
15767 " unconventional location (above box for X, right of box for Y).\n"
15768 " n: Writes numeric labels at major tick intervals in the\n"
15769 " conventional location (below box for X, left of box for Y).\n"
15770 " o: Use custom labelling function to generate axis label text.\n"
15771 " The custom labelling function can be defined with the\n"
15772 " plslabelfunc command.\n"
15773 " s: Enables subticks between major ticks, only valid if t is\n"
15774 " also specified.\n"
15775 " t: Draws major ticks.\n"
15776 " u: Exactly like \"b\" except don't draw edge line.\n"
15777 " w: Exactly like \"c\" except don't draw edge line.\n"
15778 " x: Exactly like \"t\" (including the side effect of the\n"
15779 " numerical labels for the major ticks) except exclude drawing\n"
15780 " the major and minor tick marks.\n"
15781 "\n"
15782 "\n"
15783 " xtick (PLFLT, input) : World coordinate interval between major\n"
15784 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15785 " generates a suitable tick interval.\n"
15786 "\n"
15787 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15788 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15789 " generates a suitable minor tick interval.\n"
15790 "\n"
15791 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15792 " options for the y axis. The string can include any combination of\n"
15793 " the letters defined above for xopt, and in addition may contain:\n"
15794 " v: Write numeric labels for the y axis parallel to the base of the\n"
15795 " graph, rather than parallel to the axis.\n"
15796 "\n"
15797 "\n"
15798 " ytick (PLFLT, input) : World coordinate interval between major\n"
15799 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15800 " generates a suitable tick interval.\n"
15801 "\n"
15802 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15803 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15804 " generates a suitable minor tick interval.\n"
15805 "\n"
15806 ""},
15807 { "plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15808 "Draw a box with axes, etc, in 3-d\n"
15809 "\n"
15810 "DESCRIPTION:\n"
15811 "\n"
15812 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15813 " plot. For a more complete description of three-dimensional plotting\n"
15814 " see the PLplot documentation.\n"
15815 "\n"
15816 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15817 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15818 "\n"
15819 "\n"
15820 " This function is used in examples 8, 11, 18, and 21.\n"
15821 "\n"
15822 "\n"
15823 "\n"
15824 "SYNOPSIS:\n"
15825 "\n"
15826 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15827 "\n"
15828 "ARGUMENTS:\n"
15829 "\n"
15830 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15831 " options for the x axis. The string can include any combination of\n"
15832 " the following letters (upper or lower case) in any order: b: Draws\n"
15833 " axis at base, at height z=\n"
15834 " zmin where zmin is defined by call to plw3d. This character must be\n"
15835 " specified in order to use any of the other options.\n"
15836 " d: Plot labels as date / time. Values are assumed to be\n"
15837 " seconds since the epoch (as used by gmtime).\n"
15838 " f: Always use fixed point numeric labels.\n"
15839 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15840 " than upwards.\n"
15841 " l: Labels axis logarithmically. This only affects the labels,\n"
15842 " not the data, and so it is necessary to compute the logarithms\n"
15843 " of data points before passing them to any of the drawing\n"
15844 " routines.\n"
15845 " n: Writes numeric labels at major tick intervals.\n"
15846 " o: Use custom labelling function to generate axis label text.\n"
15847 " The custom labelling function can be defined with the\n"
15848 " plslabelfunc command.\n"
15849 " s: Enables subticks between major ticks, only valid if t is\n"
15850 " also specified.\n"
15851 " t: Draws major ticks.\n"
15852 " u: If this is specified, the text label for the axis is\n"
15853 " written under the axis.\n"
15854 "\n"
15855 "\n"
15856 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15857 " the text label for the x axis. It is only drawn if u is in the\n"
15858 " xopt string.\n"
15859 "\n"
15860 " xtick (PLFLT, input) : World coordinate interval between major\n"
15861 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15862 " generates a suitable tick interval.\n"
15863 "\n"
15864 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15865 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15866 " generates a suitable minor tick interval.\n"
15867 "\n"
15868 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15869 " options for the y axis. The string is interpreted in the same way\n"
15870 " as xopt.\n"
15871 "\n"
15872 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15873 " the text label for the y axis. It is only drawn if u is in the\n"
15874 " yopt string.\n"
15875 "\n"
15876 " ytick (PLFLT, input) : World coordinate interval between major\n"
15877 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15878 " generates a suitable tick interval.\n"
15879 "\n"
15880 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15881 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15882 " generates a suitable minor tick interval.\n"
15883 "\n"
15884 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15885 " options for the z axis. The string can include any combination of\n"
15886 " the following letters (upper or lower case) in any order: b: Draws\n"
15887 " z axis to the left of the surface plot.\n"
15888 " c: Draws z axis to the right of the surface plot.\n"
15889 " d: Draws grid lines parallel to the x-y plane behind the\n"
15890 " figure. These lines are not drawn until after plot3d or\n"
15891 " plmesh are called because of the need for hidden line removal.\n"
15892 " e: Plot labels as date / time. Values are assumed to be\n"
15893 " seconds since the epoch (as used by gmtime). Note this\n"
15894 " suboption is interpreted the same as the d suboption for xopt\n"
15895 " and yopt, but it has to be identified as e for zopt since d\n"
15896 " has already been used for the different purpose above.\n"
15897 " f: Always use fixed point numeric labels.\n"
15898 " i: Inverts tick marks, so they are drawn away from the center.\n"
15899 " l: Labels axis logarithmically. This only affects the labels,\n"
15900 " not the data, and so it is necessary to compute the logarithms\n"
15901 " of data points before passing them to any of the drawing\n"
15902 " routines.\n"
15903 " m: Writes numeric labels at major tick intervals on the\n"
15904 " right-hand z axis.\n"
15905 " n: Writes numeric labels at major tick intervals on the\n"
15906 " left-hand z axis.\n"
15907 " o: Use custom labelling function to generate axis label text.\n"
15908 " The custom labelling function can be defined with the\n"
15909 " plslabelfunc command.\n"
15910 " s: Enables subticks between major ticks, only valid if t is\n"
15911 " also specified.\n"
15912 " t: Draws major ticks.\n"
15913 " u: If this is specified, the text label is written beside the\n"
15914 " left-hand axis.\n"
15915 " v: If this is specified, the text label is written beside the\n"
15916 " right-hand axis.\n"
15917 "\n"
15918 "\n"
15919 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15920 " the text label for the z axis. It is only drawn if u or v are in\n"
15921 " the zopt string.\n"
15922 "\n"
15923 " ztick (PLFLT, input) : World coordinate interval between major\n"
15924 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15925 " generates a suitable tick interval.\n"
15926 "\n"
15927 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15928 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15929 " generates a suitable minor tick interval.\n"
15930 "\n"
15931 ""},
15932 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15933 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15934 "\n"
15935 "DESCRIPTION:\n"
15936 "\n"
15937 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15938 " from relative device coordinates, rx and ry.\n"
15939 "\n"
15940 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15941 "\n"
15942 "\n"
15943 " This function is used in example 31.\n"
15944 "\n"
15945 "\n"
15946 "\n"
15947 "SYNOPSIS:\n"
15948 "\n"
15949 "plcalc_world(rx, ry, wx, wy, window)\n"
15950 "\n"
15951 "ARGUMENTS:\n"
15952 "\n"
15953 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15954 " the x coordinate.\n"
15955 "\n"
15956 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15957 " the y coordinate.\n"
15958 "\n"
15959 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15960 " coordinate corresponding to the relative device coordinates rx and\n"
15961 " ry.\n"
15962 "\n"
15963 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15964 " coordinate corresponding to the relative device coordinates rx and\n"
15965 " ry.\n"
15966 "\n"
15967 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15968 " defined window index that corresponds to the input relative device\n"
15969 " coordinates (and the returned world coordinates). To give some\n"
15970 " background on the window index, for each page the initial window\n"
15971 " index is set to zero, and each time plwind is called within the\n"
15972 " page, world and device coordinates are stored for the window and\n"
15973 " the window index is incremented. Thus, for a simple page layout\n"
15974 " with non-overlapping viewports and one window per viewport, window\n"
15975 " corresponds to the viewport index (in the order which the\n"
15976 " viewport/windows were created) of the only viewport/window\n"
15977 " corresponding to rx and ry. However, for more complicated layouts\n"
15978 " with potentially overlapping viewports and possibly more than one\n"
15979 " window (set of world coordinates) per viewport, window and the\n"
15980 " corresponding output world coordinates corresponds to the last\n"
15981 " window created that fulfills the criterion that the relative\n"
15982 " device coordinates are inside it. Finally, in all cases where the\n"
15983 " input relative device coordinates are not inside any\n"
15984 " viewport/window, then the returned value of the last defined\n"
15985 " window index is set to -1.\n"
15986 "\n"
15987 ""},
15988 { "plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15989 "Clear current (sub)page\n"
15990 "\n"
15991 "DESCRIPTION:\n"
15992 "\n"
15993 " Clears the current page, effectively erasing everything that have been\n"
15994 " drawn. This command only works with interactive drivers; if the\n"
15995 " driver does not support this, the page is filled with the background\n"
15996 " color in use. If the current page is divided into subpages, only the\n"
15997 " current subpage is erased. The nth subpage can be selected with\n"
15998 " pladv(n).\n"
15999 "\n"
16000 " Redacted form: General: plclear()\n"
16001 "\n"
16002 "\n"
16003 " This function is not used in any examples.\n"
16004 "\n"
16005 "\n"
16006 "\n"
16007 "SYNOPSIS:\n"
16008 "\n"
16009 "plclear()\n"
16010 "\n"
16011 ""},
16012 { "plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
16013 "Set color, cmap0\n"
16014 "\n"
16015 "DESCRIPTION:\n"
16016 "\n"
16017 " Sets the color index for cmap0 (see the PLplot documentation).\n"
16018 "\n"
16019 " Redacted form: plcol0(icol0)\n"
16020 "\n"
16021 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16022 "\n"
16023 "\n"
16024 "\n"
16025 "SYNOPSIS:\n"
16026 "\n"
16027 "plcol0(icol0)\n"
16028 "\n"
16029 "ARGUMENTS:\n"
16030 "\n"
16031 " icol0 (PLINT, input) : Integer representing the color. The\n"
16032 " defaults at present are (these may change):\n"
16033 " 0 black (default background)\n"
16034 " 1 red (default foreground)\n"
16035 " 2 yellow\n"
16036 " 3 green\n"
16037 " 4 aquamarine\n"
16038 " 5 pink\n"
16039 " 6 wheat\n"
16040 " 7 grey\n"
16041 " 8 brown\n"
16042 " 9 blue\n"
16043 " 10 BlueViolet\n"
16044 " 11 cyan\n"
16045 " 12 turquoise\n"
16046 " 13 magenta\n"
16047 " 14 salmon\n"
16048 " 15 white\n"
16049 "\n"
16050 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16051 " change an individual color in the cmap0 color palette.\n"
16052 "\n"
16053 ""},
16054 { "plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
16055 "Set color, cmap1\n"
16056 "\n"
16057 "DESCRIPTION:\n"
16058 "\n"
16059 " Sets the color for cmap1 (see the PLplot documentation).\n"
16060 "\n"
16061 " Redacted form: plcol1(col1)\n"
16062 "\n"
16063 " This function is used in examples 12 and 21.\n"
16064 "\n"
16065 "\n"
16066 "\n"
16067 "SYNOPSIS:\n"
16068 "\n"
16069 "plcol1(col1)\n"
16070 "\n"
16071 "ARGUMENTS:\n"
16072 "\n"
16073 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16074 " is mapped to color using the continuous cmap1 palette which by\n"
16075 " default ranges from blue to the background color to red. The\n"
16076 " cmap1 palette can also be straightforwardly changed by the user\n"
16077 " with plscmap1 or plscmap1l.\n"
16078 "\n"
16079 ""},
16080 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
16081 "Configure the transformation between continuous and broken-down time for the current stream\n"
16082 "\n"
16083 "DESCRIPTION:\n"
16084 "\n"
16085 " Configure the transformation between continuous and broken-down time\n"
16086 " for the current stream. This transformation is used by both plbtime\n"
16087 " and plctime.\n"
16088 "\n"
16089 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16090 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16091 "\n"
16092 "\n"
16093 " This function is used in example 29.\n"
16094 "\n"
16095 "\n"
16096 "\n"
16097 "SYNOPSIS:\n"
16098 "\n"
16099 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16100 "\n"
16101 "ARGUMENTS:\n"
16102 "\n"
16103 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16104 " As a special case, if\n"
16105 " scale is 0., then all other arguments are ignored, and the result (the\n"
16106 " default used by PLplot) is the equivalent of a call to\n"
16107 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16108 " That is, for this special case broken-down time is calculated with\n"
16109 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16110 " and the continuous time is defined as the number of seconds since\n"
16111 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16112 "\n"
16113 " offset1 (PLFLT, input) : If\n"
16114 " ifbtime_offset is true, the parameters\n"
16115 " offset1 and\n"
16116 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16117 " (with units in days) specify the epoch of the continuous time\n"
16118 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16119 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16120 " are used to specify the origin to allow users (by specifying\n"
16121 " offset1 as an integer that can be exactly represented by a\n"
16122 " floating-point variable and specifying\n"
16123 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16124 " the numerical errors of the continuous time representation.\n"
16125 "\n"
16126 " offset2 (PLFLT, input) : See documentation of\n"
16127 " offset1.\n"
16128 "\n"
16129 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16130 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16131 " calendar is used for broken-down time rather than the proleptic\n"
16132 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16133 " have been historically used to define UTC are inserted into the\n"
16134 " broken-down time. Other possibilities for additional control bits\n"
16135 " for ccontrol exist such as making the historical time corrections\n"
16136 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16137 " making the (slightly non-constant) corrections from international\n"
16138 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16139 " (TT). But those additional possibilities have not been\n"
16140 " implemented yet in the qsastime library (one of the PLplot utility\n"
16141 " libraries).\n"
16142 "\n"
16143 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16144 " epoch of the continuous time scale is specified by the user. If\n"
16145 " ifbtime_offset is false, then\n"
16146 " offset1 and\n"
16147 " offset2 are used to specify the epoch, and the following broken-down\n"
16148 " time parameters are completely ignored. If\n"
16149 " ifbtime_offset is true, then\n"
16150 " offset1 and\n"
16151 " offset2 are completely ignored, and the following broken-down time\n"
16152 " parameters are used to specify the epoch.\n"
16153 "\n"
16154 " year (PLINT, input) : Year of epoch.\n"
16155 "\n"
16156 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16157 " 11 (December).\n"
16158 "\n"
16159 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16160 "\n"
16161 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16162 "\n"
16163 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16164 "\n"
16165 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16166 "\n"
16167 ""},
16168 { "plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
16169 "Contour plot\n"
16170 "\n"
16171 "DESCRIPTION:\n"
16172 "\n"
16173 " Draws a contour plot of the data in f[\n"
16174 " nx][\n"
16175 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16176 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16177 " where all these index ranges are interpreted as one-based for\n"
16178 " historical reasons. A transformation routine pointed to by pltr with\n"
16179 " a generic pointer pltr_data for additional data required by the\n"
16180 " transformation routine is used to map indices within the matrix to the\n"
16181 " world coordinates.\n"
16182 "\n"
16183 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16184 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16185 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16186 " vectors; or xg and yg matrices.\n"
16187 "\n"
16188 " This function is used in examples 9, 14, 16, and 22.\n"
16189 "\n"
16190 "\n"
16191 "\n"
16192 "SYNOPSIS:\n"
16193 "\n"
16194 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16195 "\n"
16196 "ARGUMENTS:\n"
16197 "\n"
16198 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16199 "\n"
16200 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16201 "\n"
16202 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16203 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16204 " zero-based for historical backwards-compatibility reasons.\n"
16205 "\n"
16206 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16207 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16208 " zero-based for historical backwards-compatibility reasons.\n"
16209 "\n"
16210 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16211 " which to draw contours.\n"
16212 "\n"
16213 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16214 "\n"
16215 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16216 " defines the transformation between the zero-based indices of the\n"
16217 " matrix f and the world coordinates.For the C case, transformation\n"
16218 " functions are provided in the PLplot library: pltr0 for the\n"
16219 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16220 " respectively defined by vectors and matrices. In addition, C\n"
16221 " callback routines for the transformation can be supplied by the\n"
16222 " user such as the mypltr function in examples/c/x09c.c which\n"
16223 " provides a general linear transformation between index coordinates\n"
16224 " and world coordinates.For languages other than C you should\n"
16225 " consult the PLplot documentation for the details concerning how\n"
16226 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16227 " general, a particular pattern of callback-associated arguments\n"
16228 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16229 " yg matrices are respectively interfaced to a linear-transformation\n"
16230 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16231 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16232 " the PLplot documentation) support native language callbacks for\n"
16233 " handling index to world-coordinate transformations. Examples of\n"
16234 " these various approaches are given in examples/<language>x09*,\n"
16235 " examples/<language>x16*, examples/<language>x20*,\n"
16236 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16237 " supported languages.\n"
16238 "\n"
16239 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16240 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16241 " that is externally supplied.\n"
16242 "\n"
16243 ""},
16244 { "plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
16245 "Calculate continuous time from broken-down time for the current stream\n"
16246 "\n"
16247 "DESCRIPTION:\n"
16248 "\n"
16249 " Calculate continuous time, ctime, from broken-down time for the\n"
16250 " current stream. The broken-down\n"
16251 " time is specified by the following parameters: year, month, day, hour,\n"
16252 " min, and sec. This function is the inverse of plbtime.\n"
16253 "\n"
16254 " The PLplot definition of broken-down time is a calendar time that\n"
16255 " completely ignores all time zone offsets, i.e., it is the user's\n"
16256 " responsibility to apply those offsets (if so desired) before using the\n"
16257 " PLplot time API. By default broken-down time is defined using the\n"
16258 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16259 " continuous time is defined as the number of seconds since the Unix\n"
16260 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16261 " broken-down and continuous time are possible, see plconfigtime which\n"
16262 " specifies that transformation for the current stream.\n"
16263 "\n"
16264 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16265 " ctime)\n"
16266 "\n"
16267 "\n"
16268 " This function is used in example 29.\n"
16269 "\n"
16270 "\n"
16271 "\n"
16272 "SYNOPSIS:\n"
16273 "\n"
16274 "plctime(year, month, day, hour, min, sec, ctime)\n"
16275 "\n"
16276 "ARGUMENTS:\n"
16277 "\n"
16278 " year (PLINT, input) : Input year.\n"
16279 "\n"
16280 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16281 " (December).\n"
16282 "\n"
16283 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16284 "\n"
16285 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16286 "\n"
16287 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16288 "\n"
16289 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16290 "\n"
16291 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16292 " time calculated from the broken-down time specified by the\n"
16293 " previous parameters.\n"
16294 "\n"
16295 ""},
16296 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
16297 "Copy state parameters from the reference stream to the current stream\n"
16298 "\n"
16299 "DESCRIPTION:\n"
16300 "\n"
16301 " Copies state parameters from the reference stream to the current\n"
16302 " stream. Tell driver interface to map device coordinates unless flags\n"
16303 " == 1.\n"
16304 "\n"
16305 " This function is used for making save files of selected plots (e.g.\n"
16306 " from the TK driver). After initializing, you can get a copy of the\n"
16307 " current plot to the specified device by switching to this stream and\n"
16308 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16309 " appropriate. The plot buffer must have previously been enabled (done\n"
16310 " automatically by some display drivers, such as X).\n"
16311 "\n"
16312 " Redacted form: plcpstrm(iplsr, flags)\n"
16313 "\n"
16314 " This function is used in example 1,20.\n"
16315 "\n"
16316 "\n"
16317 "\n"
16318 "SYNOPSIS:\n"
16319 "\n"
16320 "plcpstrm(iplsr, flags)\n"
16321 "\n"
16322 "ARGUMENTS:\n"
16323 "\n"
16324 " iplsr (PLINT, input) : Number of reference stream.\n"
16325 "\n"
16326 " flags (PLBOOL, input) : If flags is set to true the device\n"
16327 " coordinates are not copied from the reference to current stream.\n"
16328 "\n"
16329 ""},
16330 { "plend", _wrap_plend, METH_VARARGS, (char *)"\n"
16331 "End plotting session\n"
16332 "\n"
16333 "DESCRIPTION:\n"
16334 "\n"
16335 " Ends a plotting session, tidies up all the output files, switches\n"
16336 " interactive devices back into text mode and frees up any memory that\n"
16337 " was allocated. Must be called before end of program.\n"
16338 "\n"
16339 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16340 " wait state after a call to plend or other functions which trigger the\n"
16341 " end of a plot page. To avoid this, use the plspause function.\n"
16342 "\n"
16343 " Redacted form: plend()\n"
16344 "\n"
16345 " This function is used in all of the examples.\n"
16346 "\n"
16347 "\n"
16348 "\n"
16349 "SYNOPSIS:\n"
16350 "\n"
16351 "plend()\n"
16352 "\n"
16353 ""},
16354 { "plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
16355 "End plotting session for current stream\n"
16356 "\n"
16357 "DESCRIPTION:\n"
16358 "\n"
16359 " Ends a plotting session for the current output stream only. See\n"
16360 " plsstrm for more info.\n"
16361 "\n"
16362 " Redacted form: plend1()\n"
16363 "\n"
16364 " This function is used in examples 1 and 20.\n"
16365 "\n"
16366 "\n"
16367 "\n"
16368 "SYNOPSIS:\n"
16369 "\n"
16370 "plend1()\n"
16371 "\n"
16372 ""},
16373 { "plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
16374 "Set up standard window and draw box\n"
16375 "\n"
16376 "DESCRIPTION:\n"
16377 "\n"
16378 " Sets up plotter environment for simple graphs by calling pladv and\n"
16379 " setting up viewport and window to sensible default values. plenv\n"
16380 " leaves a standard margin (left-hand margin of eight character heights,\n"
16381 " and a margin around the other three sides of five character heights)\n"
16382 " around most graphs for axis labels and a title. When these defaults\n"
16383 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16384 " plvasp for setting up the viewport, plwind for defining the window,\n"
16385 " and plbox for drawing the box.\n"
16386 "\n"
16387 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16388 "\n"
16389 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16390 "\n"
16391 "\n"
16392 "\n"
16393 "SYNOPSIS:\n"
16394 "\n"
16395 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16396 "\n"
16397 "ARGUMENTS:\n"
16398 "\n"
16399 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16400 " world coordinates).\n"
16401 "\n"
16402 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16403 " world coordinates).\n"
16404 "\n"
16405 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16406 " coordinates).\n"
16407 "\n"
16408 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16409 " coordinates).\n"
16410 "\n"
16411 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16412 " scales will not be set, the user must set up the scale before\n"
16413 " calling plenv using plsvpa, plvasp or other.\n"
16414 " 0: the x and y axes are scaled independently to use as much of\n"
16415 " the screen as possible.\n"
16416 " 1: the scales of the x and y axes are made equal.\n"
16417 " 2: the axis of the x and y axes are made equal, and the plot\n"
16418 " box will be square.\n"
16419 "\n"
16420 "\n"
16421 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16422 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16423 " -1: draw box only.\n"
16424 " 0: draw box, ticks, and numeric tick labels.\n"
16425 " 1: also draw coordinate axes at x=0 and y=0.\n"
16426 " 2: also draw a grid at major tick positions in both\n"
16427 " coordinates.\n"
16428 " 3: also draw a grid at minor tick positions in both\n"
16429 " coordinates.\n"
16430 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16431 " have to be converted to logarithms separately.)\n"
16432 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16433 " have to be converted to logarithms separately.)\n"
16434 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16435 " have to be converted to logarithms separately.)\n"
16436 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16437 " have to be converted to logarithms separately.)\n"
16438 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16439 " have to be converted to logarithms separately.)\n"
16440 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16441 " have to be converted to logarithms separately.)\n"
16442 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16443 " have to be converted to logarithms separately.)\n"
16444 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16445 " have to be converted to logarithms separately.)\n"
16446 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16447 " and y data have to be converted to logarithms separately.)\n"
16448 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16449 " and y data have to be converted to logarithms separately.)\n"
16450 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16451 " and y data have to be converted to logarithms separately.)\n"
16452 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16453 " and y data have to be converted to logarithms separately.)\n"
16454 " 40: same as 0 except date / time x labels.\n"
16455 " 41: same as 1 except date / time x labels.\n"
16456 " 42: same as 2 except date / time x labels.\n"
16457 " 43: same as 3 except date / time x labels.\n"
16458 " 50: same as 0 except date / time y labels.\n"
16459 " 51: same as 1 except date / time y labels.\n"
16460 " 52: same as 2 except date / time y labels.\n"
16461 " 53: same as 3 except date / time y labels.\n"
16462 " 60: same as 0 except date / time x and y labels.\n"
16463 " 61: same as 1 except date / time x and y labels.\n"
16464 " 62: same as 2 except date / time x and y labels.\n"
16465 " 63: same as 3 except date / time x and y labels.\n"
16466 " 70: same as 0 except custom x and y labels.\n"
16467 " 71: same as 1 except custom x and y labels.\n"
16468 " 72: same as 2 except custom x and y labels.\n"
16469 " 73: same as 3 except custom x and y labels.\n"
16470 "\n"
16471 ""},
16472 { "plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
16473 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16474 "\n"
16475 "DESCRIPTION:\n"
16476 "\n"
16477 " Sets up plotter environment for simple graphs by calling pladv and\n"
16478 " setting up viewport and window to sensible default values. plenv0\n"
16479 " leaves a standard margin (left-hand margin of eight character heights,\n"
16480 " and a margin around the other three sides of five character heights)\n"
16481 " around most graphs for axis labels and a title. When these defaults\n"
16482 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16483 " plvasp for setting up the viewport, plwind for defining the window,\n"
16484 " and plbox for drawing the box.\n"
16485 "\n"
16486 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16487 "\n"
16488 " This function is used in example 21.\n"
16489 "\n"
16490 "\n"
16491 "\n"
16492 "SYNOPSIS:\n"
16493 "\n"
16494 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16495 "\n"
16496 "ARGUMENTS:\n"
16497 "\n"
16498 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16499 " world coordinates).\n"
16500 "\n"
16501 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16502 " world coordinates).\n"
16503 "\n"
16504 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16505 " coordinates).\n"
16506 "\n"
16507 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16508 " coordinates).\n"
16509 "\n"
16510 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16511 " scales will not be set, the user must set up the scale before\n"
16512 " calling plenv0 using plsvpa, plvasp or other.\n"
16513 " 0: the x and y axes are scaled independently to use as much of\n"
16514 " the screen as possible.\n"
16515 " 1: the scales of the x and y axes are made equal.\n"
16516 " 2: the axis of the x and y axes are made equal, and the plot\n"
16517 " box will be square.\n"
16518 "\n"
16519 "\n"
16520 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16521 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16522 " -1: draw box only.\n"
16523 " 0: draw box, ticks, and numeric tick labels.\n"
16524 " 1: also draw coordinate axes at x=0 and y=0.\n"
16525 " 2: also draw a grid at major tick positions in both\n"
16526 " coordinates.\n"
16527 " 3: also draw a grid at minor tick positions in both\n"
16528 " coordinates.\n"
16529 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16530 " have to be converted to logarithms separately.)\n"
16531 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16532 " have to be converted to logarithms separately.)\n"
16533 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16534 " have to be converted to logarithms separately.)\n"
16535 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16536 " have to be converted to logarithms separately.)\n"
16537 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16538 " have to be converted to logarithms separately.)\n"
16539 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16540 " have to be converted to logarithms separately.)\n"
16541 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16542 " have to be converted to logarithms separately.)\n"
16543 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16544 " have to be converted to logarithms separately.)\n"
16545 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16546 " and y data have to be converted to logarithms separately.)\n"
16547 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16548 " and y data have to be converted to logarithms separately.)\n"
16549 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16550 " and y data have to be converted to logarithms separately.)\n"
16551 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16552 " and y data have to be converted to logarithms separately.)\n"
16553 " 40: same as 0 except date / time x labels.\n"
16554 " 41: same as 1 except date / time x labels.\n"
16555 " 42: same as 2 except date / time x labels.\n"
16556 " 43: same as 3 except date / time x labels.\n"
16557 " 50: same as 0 except date / time y labels.\n"
16558 " 51: same as 1 except date / time y labels.\n"
16559 " 52: same as 2 except date / time y labels.\n"
16560 " 53: same as 3 except date / time y labels.\n"
16561 " 60: same as 0 except date / time x and y labels.\n"
16562 " 61: same as 1 except date / time x and y labels.\n"
16563 " 62: same as 2 except date / time x and y labels.\n"
16564 " 63: same as 3 except date / time x and y labels.\n"
16565 " 70: same as 0 except custom x and y labels.\n"
16566 " 71: same as 1 except custom x and y labels.\n"
16567 " 72: same as 2 except custom x and y labels.\n"
16568 " 73: same as 3 except custom x and y labels.\n"
16569 "\n"
16570 ""},
16571 { "pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
16572 "Eject current page\n"
16573 "\n"
16574 "DESCRIPTION:\n"
16575 "\n"
16576 " Clears the graphics screen of an interactive device, or ejects a page\n"
16577 " on a plotter. See plbop for more information.\n"
16578 "\n"
16579 " Redacted form: pleop()\n"
16580 "\n"
16581 " This function is used in example 2,14.\n"
16582 "\n"
16583 "\n"
16584 "\n"
16585 "SYNOPSIS:\n"
16586 "\n"
16587 "pleop()\n"
16588 "\n"
16589 ""},
16590 { "plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
16591 "Draw error bars in x direction\n"
16592 "\n"
16593 "DESCRIPTION:\n"
16594 "\n"
16595 " Draws a set of n error bars in x direction, the i'th error bar\n"
16596 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16597 " of the error bars are of length equal to the minor tick length\n"
16598 " (settable using plsmin).\n"
16599 "\n"
16600 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16601 "\n"
16602 "\n"
16603 " This function is used in example 29.\n"
16604 "\n"
16605 "\n"
16606 "\n"
16607 "SYNOPSIS:\n"
16608 "\n"
16609 "plerrx(n, xmin, xmax, y)\n"
16610 "\n"
16611 "ARGUMENTS:\n"
16612 "\n"
16613 " n (PLINT, input) : Number of error bars to draw.\n"
16614 "\n"
16615 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16616 " of the left-hand endpoints of the error bars.\n"
16617 "\n"
16618 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16619 " of the right-hand endpoints of the error bars.\n"
16620 "\n"
16621 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16622 " the error bars.\n"
16623 "\n"
16624 ""},
16625 { "plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
16626 "Draw error bars in the y direction\n"
16627 "\n"
16628 "DESCRIPTION:\n"
16629 "\n"
16630 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16631 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16632 " of the error bars are of length equal to the minor tick length\n"
16633 " (settable using plsmin).\n"
16634 "\n"
16635 " Redacted form: General: plerry(x, ymin, ymax)\n"
16636 "\n"
16637 "\n"
16638 " This function is used in example 29.\n"
16639 "\n"
16640 "\n"
16641 "\n"
16642 "SYNOPSIS:\n"
16643 "\n"
16644 "plerry(n, x, ymin, ymax)\n"
16645 "\n"
16646 "ARGUMENTS:\n"
16647 "\n"
16648 " n (PLINT, input) : Number of error bars to draw.\n"
16649 "\n"
16650 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16651 " the error bars.\n"
16652 "\n"
16653 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16654 " of the lower endpoints of the error bars.\n"
16655 "\n"
16656 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16657 " of the upper endpoints of the error bars.\n"
16658 "\n"
16659 ""},
16660 { "plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16661 "Advance to the next family file on the next new page\n"
16662 "\n"
16663 "DESCRIPTION:\n"
16664 "\n"
16665 " Advance to the next family file on the next new page.\n"
16666 "\n"
16667 " Redacted form: plfamadv()\n"
16668 "\n"
16669 " This function is not used in any examples.\n"
16670 "\n"
16671 "\n"
16672 "\n"
16673 "SYNOPSIS:\n"
16674 "\n"
16675 "plfamadv()\n"
16676 "\n"
16677 ""},
16678 { "plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16679 "Draw filled polygon\n"
16680 "\n"
16681 "DESCRIPTION:\n"
16682 "\n"
16683 " Fills the polygon defined by the n points (\n"
16684 " x[i],\n"
16685 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16686 " style is a solid fill. The routine will automatically close the\n"
16687 " polygon between the last and first vertices. If multiple closed\n"
16688 " polygons are passed in x and y then plfill will fill in between them.\n"
16689 "\n"
16690 " Redacted form: plfill(x,y)\n"
16691 "\n"
16692 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16693 "\n"
16694 "\n"
16695 "\n"
16696 "SYNOPSIS:\n"
16697 "\n"
16698 "plfill(n, x, y)\n"
16699 "\n"
16700 "ARGUMENTS:\n"
16701 "\n"
16702 " n (PLINT, input) : Number of vertices in polygon.\n"
16703 "\n"
16704 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16705 " vertices.\n"
16706 "\n"
16707 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16708 " vertices.\n"
16709 "\n"
16710 ""},
16711 { "plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16712 "Draw filled polygon in 3D\n"
16713 "\n"
16714 "DESCRIPTION:\n"
16715 "\n"
16716 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16717 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16718 " will automatically close the polygon between the last and first\n"
16719 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16720 " plfill3 will fill in between them.\n"
16721 "\n"
16722 " Redacted form: General: plfill3(x, y, z)\n"
16723 "\n"
16724 "\n"
16725 " This function is used in example 15.\n"
16726 "\n"
16727 "\n"
16728 "\n"
16729 "SYNOPSIS:\n"
16730 "\n"
16731 "plfill3(n, x, y, z)\n"
16732 "\n"
16733 "ARGUMENTS:\n"
16734 "\n"
16735 " n (PLINT, input) : Number of vertices in polygon.\n"
16736 "\n"
16737 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16738 " vertices.\n"
16739 "\n"
16740 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16741 " vertices.\n"
16742 "\n"
16743 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16744 " vertices.\n"
16745 "\n"
16746 ""},
16747 { "plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16748 "Draw linear gradient inside polygon\n"
16749 "\n"
16750 "DESCRIPTION:\n"
16751 "\n"
16752 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16753 " points (\n"
16754 " x[i],\n"
16755 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16756 " polygon coordinates and the gradient angle are all expressed in world\n"
16757 " coordinates. The angle from the x axis for both the rotated\n"
16758 " coordinate system and the gradient vector is specified by angle. The\n"
16759 " magnitude of the gradient vector is the difference between the maximum\n"
16760 " and minimum values of x for the vertices in the rotated coordinate\n"
16761 " system. The origin of the gradient vector can be interpreted as being\n"
16762 " anywhere on the line corresponding to the minimum x value for the\n"
16763 " vertices in the rotated coordinate system. The distance along the\n"
16764 " gradient vector is linearly transformed to the independent variable of\n"
16765 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16766 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16767 " color corresponding to the independent variable of cmap1. For more\n"
16768 " information about cmap1 (see the PLplot documentation).\n"
16769 "\n"
16770 " Redacted form: plgradient(x,y,angle)\n"
16771 "\n"
16772 " This function is used in examples 25 and 30.\n"
16773 "\n"
16774 "\n"
16775 "\n"
16776 "SYNOPSIS:\n"
16777 "\n"
16778 "plgradient(n, x, y, angle)\n"
16779 "\n"
16780 "ARGUMENTS:\n"
16781 "\n"
16782 " n (PLINT, input) : Number of vertices in polygon.\n"
16783 "\n"
16784 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16785 " vertices.\n"
16786 "\n"
16787 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16788 " vertices.\n"
16789 "\n"
16790 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16791 " axis.\n"
16792 "\n"
16793 ""},
16794 { "plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16795 "Flushes the output stream\n"
16796 "\n"
16797 "DESCRIPTION:\n"
16798 "\n"
16799 " Flushes the output stream. Use sparingly, if at all.\n"
16800 "\n"
16801 " Redacted form: plflush()\n"
16802 "\n"
16803 " This function is used in examples 1 and 14.\n"
16804 "\n"
16805 "\n"
16806 "\n"
16807 "SYNOPSIS:\n"
16808 "\n"
16809 "plflush()\n"
16810 "\n"
16811 ""},
16812 { "plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16813 "Set font\n"
16814 "\n"
16815 "DESCRIPTION:\n"
16816 "\n"
16817 " Sets the font used for subsequent text and symbols. For devices that\n"
16818 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16819 " fonts with extended character set are loaded (see plfontld). For\n"
16820 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16821 " this routine calls the plsfci routine with argument set up\n"
16822 " appropriately for the various cases below. However, this method of\n"
16823 " specifying the font for unicode-aware devices is deprecated, and the\n"
16824 " much more flexible method of calling plsfont directly is recommended\n"
16825 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16826 "\n"
16827 " Redacted form: plfont(ifont)\n"
16828 "\n"
16829 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16830 "\n"
16831 "\n"
16832 "\n"
16833 "SYNOPSIS:\n"
16834 "\n"
16835 "plfont(ifont)\n"
16836 "\n"
16837 "ARGUMENTS:\n"
16838 "\n"
16839 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16840 " (simplest and fastest)\n"
16841 " 2: Serif font\n"
16842 " 3: Italic font\n"
16843 " 4: Script font\n"
16844 "\n"
16845 ""},
16846 { "plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16847 "Load Hershey fonts\n"
16848 "\n"
16849 "DESCRIPTION:\n"
16850 "\n"
16851 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16852 " be called before or after initializing PLplot. If not explicitly\n"
16853 " called before PLplot initialization, then by default that\n"
16854 " initialization loads Hershey fonts with the extended character set.\n"
16855 " This routine only has a practical effect for devices that still use\n"
16856 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16857 " system fonts instead of Hershey fonts).\n"
16858 "\n"
16859 " Redacted form: plfontld(fnt)\n"
16860 "\n"
16861 " This function is used in examples 1 and 7.\n"
16862 "\n"
16863 "\n"
16864 "\n"
16865 "SYNOPSIS:\n"
16866 "\n"
16867 "plfontld(fnt)\n"
16868 "\n"
16869 "ARGUMENTS:\n"
16870 "\n"
16871 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16872 " A zero value specifies Hershey fonts with the standard character\n"
16873 " set and a non-zero value (the default assumed if plfontld is never\n"
16874 " called) specifies Hershey fonts with the extended character set.\n"
16875 "\n"
16876 ""},
16877 { "plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16878 "Get character default height and current (scaled) height\n"
16879 "\n"
16880 "DESCRIPTION:\n"
16881 "\n"
16882 " Get character default height and current (scaled) height.\n"
16883 "\n"
16884 " Redacted form: plgchr(p_def, p_ht)\n"
16885 "\n"
16886 " This function is used in example 23.\n"
16887 "\n"
16888 "\n"
16889 "\n"
16890 "SYNOPSIS:\n"
16891 "\n"
16892 "plgchr(p_def, p_ht)\n"
16893 "\n"
16894 "ARGUMENTS:\n"
16895 "\n"
16896 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16897 " character height (mm).\n"
16898 "\n"
16899 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16900 " character height (mm).\n"
16901 "\n"
16902 ""},
16903 { "plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16904 "Returns 8-bit RGB values for given color index from cmap0\n"
16905 "\n"
16906 "DESCRIPTION:\n"
16907 "\n"
16908 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16909 " PLplot documentation). Values are negative if an invalid color id is\n"
16910 " given.\n"
16911 "\n"
16912 " Redacted form: plgcol0(icol0, r, g, b)\n"
16913 "\n"
16914 " This function is used in example 2.\n"
16915 "\n"
16916 "\n"
16917 "\n"
16918 "SYNOPSIS:\n"
16919 "\n"
16920 "plgcol0(icol0, r, g, b)\n"
16921 "\n"
16922 "ARGUMENTS:\n"
16923 "\n"
16924 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16925 "\n"
16926 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16927 " value.\n"
16928 "\n"
16929 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16930 " value.\n"
16931 "\n"
16932 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16933 " value.\n"
16934 "\n"
16935 ""},
16936 { "plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16937 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16938 "\n"
16939 "DESCRIPTION:\n"
16940 "\n"
16941 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16942 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16943 " Values are negative if an invalid color id is given.\n"
16944 "\n"
16945 " Redacted form: plgcola(r, g, b)\n"
16946 "\n"
16947 " This function is used in example 30.\n"
16948 "\n"
16949 "\n"
16950 "\n"
16951 "SYNOPSIS:\n"
16952 "\n"
16953 "plgcol0a(icol0, r, g, b, alpha)\n"
16954 "\n"
16955 "ARGUMENTS:\n"
16956 "\n"
16957 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16958 "\n"
16959 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16960 " in the range from 0 to 255.\n"
16961 "\n"
16962 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16963 " in the range from 0 to 255.\n"
16964 "\n"
16965 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16966 " in the range from 0 to 255.\n"
16967 "\n"
16968 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16969 " transparency in the range from (0.0-1.0).\n"
16970 "\n"
16971 ""},
16972 { "plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16973 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16974 "\n"
16975 "DESCRIPTION:\n"
16976 "\n"
16977 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16978 "\n"
16979 " Redacted form: plgcolbg(r, g, b)\n"
16980 "\n"
16981 " This function is used in example 31.\n"
16982 "\n"
16983 "\n"
16984 "\n"
16985 "SYNOPSIS:\n"
16986 "\n"
16987 "plgcolbg(r, g, b)\n"
16988 "\n"
16989 "ARGUMENTS:\n"
16990 "\n"
16991 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16992 " in the range from 0 to 255.\n"
16993 "\n"
16994 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16995 " in the range from 0 to 255.\n"
16996 "\n"
16997 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16998 " in the range from 0 to 255.\n"
16999 "\n"
17000 ""},
17001 { "plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
17002 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
17003 "\n"
17004 "DESCRIPTION:\n"
17005 "\n"
17006 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17007 " alpha transparency value.\n"
17008 "\n"
17009 " This function is used in example 31.\n"
17010 "\n"
17011 "\n"
17012 "\n"
17013 "SYNOPSIS:\n"
17014 "\n"
17015 "plgcolbga(r, g, b, alpha)\n"
17016 "\n"
17017 "ARGUMENTS:\n"
17018 "\n"
17019 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17020 " in the range from 0 to 255.\n"
17021 "\n"
17022 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17023 " in the range from 0 to 255.\n"
17024 "\n"
17025 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17026 " in the range from 0 to 255.\n"
17027 "\n"
17028 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17029 " transparency in the range (0.0-1.0).\n"
17030 "\n"
17031 ""},
17032 { "plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
17033 "Get the current device-compression setting\n"
17034 "\n"
17035 "DESCRIPTION:\n"
17036 "\n"
17037 " Get the current device-compression setting. This parameter is only\n"
17038 " used for drivers that provide compression.\n"
17039 "\n"
17040 " Redacted form: plgcompression(compression)\n"
17041 "\n"
17042 " This function is used in example 31.\n"
17043 "\n"
17044 "\n"
17045 "\n"
17046 "SYNOPSIS:\n"
17047 "\n"
17048 "plgcompression(compression)\n"
17049 "\n"
17050 "ARGUMENTS:\n"
17051 "\n"
17052 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17053 " compression setting for the current device.\n"
17054 "\n"
17055 ""},
17056 { "plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
17057 "Get the current device (keyword) name\n"
17058 "\n"
17059 "DESCRIPTION:\n"
17060 "\n"
17061 " Get the current device (keyword) name. Note: you must have allocated\n"
17062 " space for this (80 characters is safe).\n"
17063 "\n"
17064 " Redacted form: plgdev(p_dev)\n"
17065 "\n"
17066 " This function is used in example 14.\n"
17067 "\n"
17068 "\n"
17069 "\n"
17070 "SYNOPSIS:\n"
17071 "\n"
17072 "plgdev(p_dev)\n"
17073 "\n"
17074 "ARGUMENTS:\n"
17075 "\n"
17076 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17077 " (with preallocated length of 80 characters or more) containing the\n"
17078 " device (keyword) name.\n"
17079 "\n"
17080 ""},
17081 { "plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
17082 "Get parameters that define current device-space window\n"
17083 "\n"
17084 "DESCRIPTION:\n"
17085 "\n"
17086 " Get relative margin width, aspect ratio, and relative justification\n"
17087 " that define current device-space window. If plsdidev has not been\n"
17088 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17089 " p_jy will all be 0.\n"
17090 "\n"
17091 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17092 "\n"
17093 " This function is used in example 31.\n"
17094 "\n"
17095 "\n"
17096 "\n"
17097 "SYNOPSIS:\n"
17098 "\n"
17099 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17100 "\n"
17101 "ARGUMENTS:\n"
17102 "\n"
17103 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17104 " margin width.\n"
17105 "\n"
17106 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17107 " ratio.\n"
17108 "\n"
17109 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17110 " justification in x.\n"
17111 "\n"
17112 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17113 " justification in y.\n"
17114 "\n"
17115 ""},
17116 { "plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
17117 "Get plot orientation\n"
17118 "\n"
17119 "DESCRIPTION:\n"
17120 "\n"
17121 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17122 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17123 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17124 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17125 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17126 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17127 " not been called the default value pointed to by p_rot will be 0.\n"
17128 "\n"
17129 " Redacted form: plgdiori(p_rot)\n"
17130 "\n"
17131 " This function is not used in any examples.\n"
17132 "\n"
17133 "\n"
17134 "\n"
17135 "SYNOPSIS:\n"
17136 "\n"
17137 "plgdiori(p_rot)\n"
17138 "\n"
17139 "ARGUMENTS:\n"
17140 "\n"
17141 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17142 " parameter.\n"
17143 "\n"
17144 ""},
17145 { "plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
17146 "Get parameters that define current plot-space window\n"
17147 "\n"
17148 "DESCRIPTION:\n"
17149 "\n"
17150 " Get relative minima and maxima that define current plot-space window.\n"
17151 " If plsdiplt has not been called the default values pointed to by\n"
17152 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17153 "\n"
17154 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17155 "\n"
17156 " This function is used in example 31.\n"
17157 "\n"
17158 "\n"
17159 "\n"
17160 "SYNOPSIS:\n"
17161 "\n"
17162 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17163 "\n"
17164 "ARGUMENTS:\n"
17165 "\n"
17166 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17167 " minimum in x.\n"
17168 "\n"
17169 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17170 " minimum in y.\n"
17171 "\n"
17172 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17173 " maximum in x.\n"
17174 "\n"
17175 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17176 " maximum in y.\n"
17177 "\n"
17178 ""},
17179 { "plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
17180 "Get family file parameters\n"
17181 "\n"
17182 "DESCRIPTION:\n"
17183 "\n"
17184 " Gets information about current family file, if familying is enabled.\n"
17185 " See the PLplot documentation for more information.\n"
17186 "\n"
17187 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17188 "\n"
17189 " This function is used in examples 14 and 31.\n"
17190 "\n"
17191 "\n"
17192 "\n"
17193 "SYNOPSIS:\n"
17194 "\n"
17195 "plgfam(p_fam, p_num, p_bmax)\n"
17196 "\n"
17197 "ARGUMENTS:\n"
17198 "\n"
17199 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17200 " family flag value. If nonzero, familying is enabled for the\n"
17201 " current device.\n"
17202 "\n"
17203 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17204 " family file number.\n"
17205 "\n"
17206 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17207 " file size (in bytes) for a family file.\n"
17208 "\n"
17209 ""},
17210 { "plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
17211 "Get FCI (font characterization integer)\n"
17212 "\n"
17213 "DESCRIPTION:\n"
17214 "\n"
17215 " Gets information about the current font using the FCI approach. See\n"
17216 " the PLplot documentation for more information.\n"
17217 "\n"
17218 " Redacted form: plgfci(p_fci)\n"
17219 "\n"
17220 " This function is used in example 23.\n"
17221 "\n"
17222 "\n"
17223 "\n"
17224 "SYNOPSIS:\n"
17225 "\n"
17226 "plgfci(p_fci)\n"
17227 "\n"
17228 "ARGUMENTS:\n"
17229 "\n"
17230 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17231 " FCI value.\n"
17232 "\n"
17233 ""},
17234 { "plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
17235 "Get output file name\n"
17236 "\n"
17237 "DESCRIPTION:\n"
17238 "\n"
17239 " Gets the current output file name, if applicable.\n"
17240 "\n"
17241 " Redacted form: plgfnam(fnam)\n"
17242 "\n"
17243 " This function is used in example 31.\n"
17244 "\n"
17245 "\n"
17246 "\n"
17247 "SYNOPSIS:\n"
17248 "\n"
17249 "plgfnam(fnam)\n"
17250 "\n"
17251 "ARGUMENTS:\n"
17252 "\n"
17253 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17254 " (with preallocated length of 80 characters or more) containing the\n"
17255 " file name.\n"
17256 "\n"
17257 ""},
17258 { "plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
17259 "Get family, style and weight of the current font\n"
17260 "\n"
17261 "DESCRIPTION:\n"
17262 "\n"
17263 " Gets information about current font. See the PLplot documentation for\n"
17264 " more information on font selection.\n"
17265 "\n"
17266 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17267 "\n"
17268 " This function is used in example 23.\n"
17269 "\n"
17270 "\n"
17271 "\n"
17272 "SYNOPSIS:\n"
17273 "\n"
17274 "plgfont(p_family, p_style, p_weight)\n"
17275 "\n"
17276 "ARGUMENTS:\n"
17277 "\n"
17278 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17279 " font family. The available values are given by the PL_FCI_*\n"
17280 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17281 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17282 " p_family is NULL then the font family is not returned.\n"
17283 "\n"
17284 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17285 " font style. The available values are given by the PL_FCI_*\n"
17286 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17287 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17288 " style is not returned.\n"
17289 "\n"
17290 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17291 " font weight. The available values are given by the PL_FCI_*\n"
17292 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17293 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17294 " returned.\n"
17295 "\n"
17296 ""},
17297 { "plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
17298 "Get the (current) run level\n"
17299 "\n"
17300 "DESCRIPTION:\n"
17301 "\n"
17302 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17303 " 1, initialized\n"
17304 " 2, viewport defined\n"
17305 " 3, world coordinates defined\n"
17306 "\n"
17307 "\n"
17308 " Redacted form: plglevel(p_level)\n"
17309 "\n"
17310 " This function is used in example 31.\n"
17311 "\n"
17312 "\n"
17313 "\n"
17314 "SYNOPSIS:\n"
17315 "\n"
17316 "plglevel(p_level)\n"
17317 "\n"
17318 "ARGUMENTS:\n"
17319 "\n"
17320 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17321 " level.\n"
17322 "\n"
17323 ""},
17324 { "plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
17325 "Get page parameters\n"
17326 "\n"
17327 "DESCRIPTION:\n"
17328 "\n"
17329 " Gets the current page configuration. The length and offset values are\n"
17330 " expressed in units that are specific to the current driver. For\n"
17331 " instance: screen drivers will usually interpret them as number of\n"
17332 " pixels, whereas printer drivers will usually use mm.\n"
17333 "\n"
17334 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17335 "\n"
17336 " This function is used in examples 14 and 31.\n"
17337 "\n"
17338 "\n"
17339 "\n"
17340 "SYNOPSIS:\n"
17341 "\n"
17342 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17343 "\n"
17344 "ARGUMENTS:\n"
17345 "\n"
17346 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17347 " pixels/inch (DPI) in x.\n"
17348 "\n"
17349 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17350 " pixels/inch (DPI) in y.\n"
17351 "\n"
17352 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17353 " length.\n"
17354 "\n"
17355 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17356 " length.\n"
17357 "\n"
17358 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17359 " offset.\n"
17360 "\n"
17361 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17362 " offset.\n"
17363 "\n"
17364 ""},
17365 { "plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
17366 "Switch to graphics screen\n"
17367 "\n"
17368 "DESCRIPTION:\n"
17369 "\n"
17370 " Sets an interactive device to graphics mode, used in conjunction with\n"
17371 " pltext to allow graphics and text to be interspersed. On a device\n"
17372 " which supports separate text and graphics windows, this command causes\n"
17373 " control to be switched to the graphics window. If already in graphics\n"
17374 " mode, this command is ignored. It is also ignored on devices which\n"
17375 " only support a single window or use a different method for shifting\n"
17376 " focus. See also pltext.\n"
17377 "\n"
17378 " Redacted form: plgra()\n"
17379 "\n"
17380 " This function is used in example 1.\n"
17381 "\n"
17382 "\n"
17383 "\n"
17384 "SYNOPSIS:\n"
17385 "\n"
17386 "plgra()\n"
17387 "\n"
17388 ""},
17389 { "plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
17390 "Grid data from irregularly sampled data\n"
17391 "\n"
17392 "DESCRIPTION:\n"
17393 "\n"
17394 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17395 " require data organized as a grid, i.e., with x sample point values\n"
17396 " independent of y coordinate and vice versa. This function takes\n"
17397 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17398 " vectors; reads the desired grid location from the input vectors\n"
17399 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17400 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17401 " interpolate the data to the grid is specified with the argument type\n"
17402 " which can have one parameter specified in argument data.\n"
17403 "\n"
17404 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17405 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17406 "\n"
17407 "\n"
17408 " This function is used in example 21.\n"
17409 "\n"
17410 "\n"
17411 "\n"
17412 "SYNOPSIS:\n"
17413 "\n"
17414 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17415 "\n"
17416 "ARGUMENTS:\n"
17417 "\n"
17418 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17419 "\n"
17420 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17421 "\n"
17422 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17423 " y[i], z[i] represents one data sample coordinate.\n"
17424 "\n"
17425 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17426 " vectors.\n"
17427 "\n"
17428 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17429 " in the x direction. Usually xg has nptsx equally spaced values\n"
17430 " from the minimum to the maximum values of the x input vector.\n"
17431 "\n"
17432 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17433 "\n"
17434 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17435 " in the y direction. Similar to the xg parameter.\n"
17436 "\n"
17437 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17438 "\n"
17439 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17440 " where data lies in the grid specified by xg and yg. Therefore the\n"
17441 " zg matrix must be dimensioned\n"
17442 " nptsx by\n"
17443 " nptsy.\n"
17444 "\n"
17445 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17446 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17447 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17448 " GRID_NNI: Natural Neighbors Interpolation\n"
17449 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17450 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17451 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17452 " Weighted\n"
17453 " For details of the algorithms read the source file plgridd.c.\n"
17454 "\n"
17455 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17456 " which can be specified through this argument. Currently, for\n"
17457 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17458 " use, the lower the value, the noisier (more local) the\n"
17459 " approximation is.\n"
17460 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17461 " range [1. .. 2.]. High values enable the usage of very thin\n"
17462 " triangles for interpolation, possibly resulting in error in\n"
17463 " the approximation.\n"
17464 " GRID_NNI, only weights greater than data will be accepted. If\n"
17465 " 0, all weights will be accepted.\n"
17466 "\n"
17467 ""},
17468 { "plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
17469 "Get current subpage parameters\n"
17470 "\n"
17471 "DESCRIPTION:\n"
17472 "\n"
17473 " Gets the size of the current subpage in millimeters measured from the\n"
17474 " bottom left hand corner of the output device page or screen. Can be\n"
17475 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17476 " absolute coordinates (millimeters).\n"
17477 "\n"
17478 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17479 "\n"
17480 " This function is used in example 23.\n"
17481 "\n"
17482 "\n"
17483 "\n"
17484 "SYNOPSIS:\n"
17485 "\n"
17486 "plgspa(xmin, xmax, ymin, ymax)\n"
17487 "\n"
17488 "ARGUMENTS:\n"
17489 "\n"
17490 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17491 " the left hand edge of the subpage in millimeters.\n"
17492 "\n"
17493 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17494 " the right hand edge of the subpage in millimeters.\n"
17495 "\n"
17496 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17497 " the bottom edge of the subpage in millimeters.\n"
17498 "\n"
17499 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17500 " the top edge of the subpage in millimeters.\n"
17501 "\n"
17502 ""},
17503 { "plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
17504 "Get current stream number\n"
17505 "\n"
17506 "DESCRIPTION:\n"
17507 "\n"
17508 " Gets the number of the current output stream. See also plsstrm.\n"
17509 "\n"
17510 " Redacted form: plgstrm(p_strm)\n"
17511 "\n"
17512 " This function is used in example 1,20.\n"
17513 "\n"
17514 "\n"
17515 "\n"
17516 "SYNOPSIS:\n"
17517 "\n"
17518 "plgstrm(p_strm)\n"
17519 "\n"
17520 "ARGUMENTS:\n"
17521 "\n"
17522 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17523 " stream value.\n"
17524 "\n"
17525 ""},
17526 { "plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
17527 "Get the current library version number\n"
17528 "\n"
17529 "DESCRIPTION:\n"
17530 "\n"
17531 " Get the current library version number. Note: you must have allocated\n"
17532 " space for this (80 characters is safe).\n"
17533 "\n"
17534 " Redacted form: plgver(p_ver)\n"
17535 "\n"
17536 " This function is used in example 1.\n"
17537 "\n"
17538 "\n"
17539 "\n"
17540 "SYNOPSIS:\n"
17541 "\n"
17542 "plgver(p_ver)\n"
17543 "\n"
17544 "ARGUMENTS:\n"
17545 "\n"
17546 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17547 " (with preallocated length of 80 characters or more) containing the\n"
17548 " PLplot version number.\n"
17549 "\n"
17550 ""},
17551 { "plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
17552 "Get viewport limits in normalized device coordinates\n"
17553 "\n"
17554 "DESCRIPTION:\n"
17555 "\n"
17556 " Get viewport limits in normalized device coordinates.\n"
17557 "\n"
17558 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17559 "\n"
17560 "\n"
17561 " This function is used in example 31.\n"
17562 "\n"
17563 "\n"
17564 "\n"
17565 "SYNOPSIS:\n"
17566 "\n"
17567 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17568 "\n"
17569 "ARGUMENTS:\n"
17570 "\n"
17571 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17572 " viewport limit of the normalized device coordinate in x.\n"
17573 "\n"
17574 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17575 " viewport limit of the normalized device coordinate in x.\n"
17576 "\n"
17577 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17578 " viewport limit of the normalized device coordinate in y.\n"
17579 "\n"
17580 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17581 " viewport limit of the normalized device coordinate in y.\n"
17582 "\n"
17583 ""},
17584 { "plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
17585 "Get viewport limits in world coordinates\n"
17586 "\n"
17587 "DESCRIPTION:\n"
17588 "\n"
17589 " Get viewport limits in world coordinates.\n"
17590 "\n"
17591 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17592 "\n"
17593 "\n"
17594 " This function is used in example 31.\n"
17595 "\n"
17596 "\n"
17597 "\n"
17598 "SYNOPSIS:\n"
17599 "\n"
17600 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17601 "\n"
17602 "ARGUMENTS:\n"
17603 "\n"
17604 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17605 " viewport limit of the world coordinate in x.\n"
17606 "\n"
17607 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17608 " viewport limit of the world coordinate in x.\n"
17609 "\n"
17610 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17611 " viewport limit of the world coordinate in y.\n"
17612 "\n"
17613 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17614 " viewport limit of the world coordinate in y.\n"
17615 "\n"
17616 ""},
17617 { "plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
17618 "Get x axis parameters\n"
17619 "\n"
17620 "DESCRIPTION:\n"
17621 "\n"
17622 " Returns current values of the p_digmax and p_digits flags for the x\n"
17623 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17624 " should only be called after the call to plbox (or plbox3) is complete.\n"
17625 " See the PLplot documentation for more information.\n"
17626 "\n"
17627 " Redacted form: plgxax(p_digmax, p_digits)\n"
17628 "\n"
17629 " This function is used in example 31.\n"
17630 "\n"
17631 "\n"
17632 "\n"
17633 "SYNOPSIS:\n"
17634 "\n"
17635 "plgxax(p_digmax, p_digits)\n"
17636 "\n"
17637 "ARGUMENTS:\n"
17638 "\n"
17639 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17640 " number of digits for the x axis. If nonzero, the printed label\n"
17641 " has been switched to a floating-point representation when the\n"
17642 " number of digits exceeds this value.\n"
17643 "\n"
17644 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17645 " number of digits for the numeric labels (x axis) from the last\n"
17646 " plot.\n"
17647 "\n"
17648 ""},
17649 { "plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
17650 "Get y axis parameters\n"
17651 "\n"
17652 "DESCRIPTION:\n"
17653 "\n"
17654 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17655 " the description of plgxax for more detail.\n"
17656 "\n"
17657 " Redacted form: plgyax(p_digmax, p_digits)\n"
17658 "\n"
17659 " This function is used in example 31.\n"
17660 "\n"
17661 "\n"
17662 "\n"
17663 "SYNOPSIS:\n"
17664 "\n"
17665 "plgyax(p_digmax, p_digits)\n"
17666 "\n"
17667 "ARGUMENTS:\n"
17668 "\n"
17669 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17670 " number of digits for the y axis. If nonzero, the printed label\n"
17671 " has been switched to a floating-point representation when the\n"
17672 " number of digits exceeds this value.\n"
17673 "\n"
17674 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17675 " number of digits for the numeric labels (y axis) from the last\n"
17676 " plot.\n"
17677 "\n"
17678 ""},
17679 { "plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
17680 "Get z axis parameters\n"
17681 "\n"
17682 "DESCRIPTION:\n"
17683 "\n"
17684 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17685 " the description of plgxax for more detail.\n"
17686 "\n"
17687 " Redacted form: plgzax(p_digmax, p_digits)\n"
17688 "\n"
17689 " This function is used in example 31.\n"
17690 "\n"
17691 "\n"
17692 "\n"
17693 "SYNOPSIS:\n"
17694 "\n"
17695 "plgzax(p_digmax, p_digits)\n"
17696 "\n"
17697 "ARGUMENTS:\n"
17698 "\n"
17699 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17700 " number of digits for the z axis. If nonzero, the printed label\n"
17701 " has been switched to a floating-point representation when the\n"
17702 " number of digits exceeds this value.\n"
17703 "\n"
17704 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17705 " number of digits for the numeric labels (z axis) from the last\n"
17706 " plot.\n"
17707 "\n"
17708 ""},
17709 { "plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17710 "Plot a histogram from unbinned data\n"
17711 "\n"
17712 "DESCRIPTION:\n"
17713 "\n"
17714 " Plots a histogram from n data points stored in the data vector. This\n"
17715 " routine bins the data into nbin bins equally spaced between datmin and\n"
17716 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17717 " opt allows, among other things, the histogram either to be plotted in\n"
17718 " an existing window or causes plhist to call plenv with suitable limits\n"
17719 " before plotting the histogram.\n"
17720 "\n"
17721 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17722 "\n"
17723 " This function is used in example 5.\n"
17724 "\n"
17725 "\n"
17726 "\n"
17727 "SYNOPSIS:\n"
17728 "\n"
17729 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17730 "\n"
17731 "ARGUMENTS:\n"
17732 "\n"
17733 " n (PLINT, input) : Number of data points.\n"
17734 "\n"
17735 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17736 " n data points.\n"
17737 "\n"
17738 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17739 "\n"
17740 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17741 "\n"
17742 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17743 " divide the interval xmin to xmax.\n"
17744 "\n"
17745 " opt (PLINT, input) : Is a combination of several flags:\n"
17746 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17747 " the histogram data, the outer bins are expanded to fill up the\n"
17748 " entire x-axis, data outside the given extremes are assigned to the\n"
17749 " outer bins and bins of zero height are simply drawn.\n"
17750 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17751 " to fit the histogram data, without this flag, plenv is called\n"
17752 " to set the world coordinates.\n"
17753 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17754 " extremes are not taken into account. This option should\n"
17755 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17756 " properly present the data.\n"
17757 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17758 " size as the ones inside.\n"
17759 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17760 " (there is a gap for such bins).\n"
17761 "\n"
17762 ""},
17763 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17764 "Convert HLS color to RGB\n"
17765 "\n"
17766 "DESCRIPTION:\n"
17767 "\n"
17768 " Convert HLS color coordinates to RGB.\n"
17769 "\n"
17770 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17771 "\n"
17772 "\n"
17773 " This function is used in example 2.\n"
17774 "\n"
17775 "\n"
17776 "\n"
17777 "SYNOPSIS:\n"
17778 "\n"
17779 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17780 "\n"
17781 "ARGUMENTS:\n"
17782 "\n"
17783 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17784 " cylinder.\n"
17785 "\n"
17786 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17787 " the axis of the color cylinder.\n"
17788 "\n"
17789 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17790 " the radius of the color cylinder.\n"
17791 "\n"
17792 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17793 " (0.0-1.0) of the color.\n"
17794 "\n"
17795 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17796 " intensity (0.0-1.0) of the color.\n"
17797 "\n"
17798 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17799 " intensity (0.0-1.0) of the color.\n"
17800 "\n"
17801 ""},
17802 { "plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17803 "Initialize PLplot\n"
17804 "\n"
17805 "DESCRIPTION:\n"
17806 "\n"
17807 " Initializing the plotting package. The program prompts for the device\n"
17808 " keyword or number of the desired output device. Hitting a RETURN in\n"
17809 " response to the prompt is the same as selecting the first device.\n"
17810 " plinit will issue no prompt if either the device was specified\n"
17811 " previously (via command line flag, the plsetopt function, or the\n"
17812 " plsdev function), or if only one device is enabled when PLplot is\n"
17813 " installed. If subpages have been specified, the output device is\n"
17814 " divided into nx by ny subpages, each of which may be used\n"
17815 " independently. If plinit is called again during a program, the\n"
17816 " previously opened file will be closed. The subroutine pladv is used\n"
17817 " to advance from one subpage to the next.\n"
17818 "\n"
17819 " Redacted form: plinit()\n"
17820 "\n"
17821 " This function is used in all of the examples.\n"
17822 "\n"
17823 "\n"
17824 "\n"
17825 "SYNOPSIS:\n"
17826 "\n"
17827 "plinit()\n"
17828 "\n"
17829 ""},
17830 { "pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17831 "Draw a line between two points\n"
17832 "\n"
17833 "DESCRIPTION:\n"
17834 "\n"
17835 " Joins the point (\n"
17836 " x1,\n"
17837 " y1) to (\n"
17838 " x2,\n"
17839 " y2).\n"
17840 "\n"
17841 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17842 "\n"
17843 " This function is used in examples 3 and 14.\n"
17844 "\n"
17845 "\n"
17846 "\n"
17847 "SYNOPSIS:\n"
17848 "\n"
17849 "pljoin(x1, y1, x2, y2)\n"
17850 "\n"
17851 "ARGUMENTS:\n"
17852 "\n"
17853 " x1 (PLFLT, input) : x coordinate of first point.\n"
17854 "\n"
17855 " y1 (PLFLT, input) : y coordinate of first point.\n"
17856 "\n"
17857 " x2 (PLFLT, input) : x coordinate of second point.\n"
17858 "\n"
17859 " y2 (PLFLT, input) : y coordinate of second point.\n"
17860 "\n"
17861 ""},
17862 { "pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17863 "Simple routine to write labels\n"
17864 "\n"
17865 "DESCRIPTION:\n"
17866 "\n"
17867 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17868 "\n"
17869 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17870 "\n"
17871 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17872 "\n"
17873 "\n"
17874 "\n"
17875 "SYNOPSIS:\n"
17876 "\n"
17877 "pllab(xlabel, ylabel, tlabel)\n"
17878 "\n"
17879 "ARGUMENTS:\n"
17880 "\n"
17881 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17882 " the label for the x axis.\n"
17883 "\n"
17884 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17885 " the label for the y axis.\n"
17886 "\n"
17887 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17888 " the title of the plot.\n"
17889 "\n"
17890 ""},
17891 { "pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17892 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17893 "\n"
17894 "DESCRIPTION:\n"
17895 "\n"
17896 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17897 " line, and/or line of symbols for each annotated legend entry. (See\n"
17898 " plcolorbar for similar functionality for creating continuous color\n"
17899 " bars.) The arguments of pllegend provide control over the location\n"
17900 " and size of the legend as well as the location and characteristics of\n"
17901 " the elements (most of which are optional) within that legend. The\n"
17902 " resulting legend is clipped at the boundaries of the current subpage.\n"
17903 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17904 " defined in the documentation of the position parameter.)\n"
17905 "\n"
17906 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17907 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17908 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17909 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17910 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17911 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17912 "\n"
17913 " This function is used in examples 4, 26, and 33.\n"
17914 "\n"
17915 "\n"
17916 "\n"
17917 "SYNOPSIS:\n"
17918 "\n"
17919 "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"
17920 "\n"
17921 "ARGUMENTS:\n"
17922 "\n"
17923 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17924 " legend width in adopted coordinates. This quantity is calculated\n"
17925 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17926 " the routine depending on nlegend and nrow), and the length\n"
17927 " (calculated internally) of the longest text string.\n"
17928 "\n"
17929 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17930 " legend height in adopted coordinates. This quantity is calculated\n"
17931 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17932 " the routine depending on nlegend and nrow).\n"
17933 "\n"
17934 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17935 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17936 " on the left of the legend and the plotted area on the right.\n"
17937 " Otherwise, put the text area on the right of the legend and the\n"
17938 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17939 " plot a (semitransparent) background for the legend. If the\n"
17940 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17941 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17942 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17943 " plot the resulting array of legend entries in row-major order.\n"
17944 " Otherwise, plot the legend entries in column-major order.\n"
17945 "\n"
17946 " position (PLINT, input) : position contains bits which control the\n"
17947 " overall position of the legend and the definition of the adopted\n"
17948 " coordinates used for positions just like what is done for the\n"
17949 " position argument for plcolorbar. However, note that the defaults\n"
17950 " for the position bits (see below) are different than the\n"
17951 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17952 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17953 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17954 " the 16 possible standard positions (the 4 corners and centers of\n"
17955 " the 4 sides for both the inside and outside cases) of the legend\n"
17956 " relative to the adopted coordinate system. The corner positions\n"
17957 " are specified by the appropriate combination of two of the\n"
17958 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17959 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17960 " value of one of those bits. The adopted coordinates are\n"
17961 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17962 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17963 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17964 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17965 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17966 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17967 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17968 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17969 "\n"
17970 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17971 " coordinates from the specified standard position of the legend.\n"
17972 " For positive x, the direction of motion away from the standard\n"
17973 " position is inward/outward from the standard corner positions or\n"
17974 " standard left or right positions if the\n"
17975 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17976 " For the standard top or bottom positions, the direction of motion\n"
17977 " is toward positive X.\n"
17978 "\n"
17979 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17980 " coordinates from the specified standard position of the legend.\n"
17981 " For positive y, the direction of motion away from the standard\n"
17982 " position is inward/outward from the standard corner positions or\n"
17983 " standard top or bottom positions if the\n"
17984 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17985 " the standard left or right positions, the direction of motion is\n"
17986 " toward positive Y.\n"
17987 "\n"
17988 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17989 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17990 " symbols are drawn) of the legend.\n"
17991 "\n"
17992 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17993 " legend (PL_LEGEND_BACKGROUND).\n"
17994 "\n"
17995 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17996 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17997 "\n"
17998 " bb_style (PLINT, input) : The pllsty style number for the\n"
17999 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
18000 "\n"
18001 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
18002 " render the\n"
18003 " nlegend legend entries. For internal transformations of\n"
18004 " nrow, see further remarks under\n"
18005 " nlegend.\n"
18006 "\n"
18007 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18008 " to render the\n"
18009 " nlegend legend entries. For internal transformations of\n"
18010 " ncolumn, see further remarks under\n"
18011 " nlegend.\n"
18012 "\n"
18013 " nlegend (PLINT, input) : Number of legend entries. The above\n"
18014 " nrow and\n"
18015 " ncolumn values are transformed internally to be consistent with\n"
18016 " nlegend. If either\n"
18017 " nrow or\n"
18018 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18019 " of\n"
18020 " nrow and\n"
18021 " ncolumn is less than\n"
18022 " nlegend, the smaller of the two (or\n"
18023 " nrow, if\n"
18024 " nrow ==\n"
18025 " ncolumn) is increased so the product is >=\n"
18026 " nlegend. Thus, for example, the common\n"
18027 " nrow = 0,\n"
18028 " ncolumn = 0 case is transformed internally to\n"
18029 " nrow =\n"
18030 " nlegend,\n"
18031 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18032 " column.\n"
18033 "\n"
18034 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18035 " nlegend values of options to control each individual plotted area\n"
18036 " corresponding to a legend entry. If the\n"
18037 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18038 " area. If the\n"
18039 " PL_LEGEND_COLOR_BOX,\n"
18040 " PL_LEGEND_LINE, and/or\n"
18041 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18042 " entry is plotted with a colored box; a line; and/or a line of\n"
18043 " symbols.\n"
18044 "\n"
18045 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18046 " area in units of character width.\n"
18047 "\n"
18048 " text_scale (PLFLT, input) : Character height scale for text\n"
18049 " annotations.\n"
18050 "\n"
18051 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18052 " character height from one legend entry to the next.\n"
18053 "\n"
18054 " text_justification (PLFLT, input) : Justification parameter used\n"
18055 " for text justification. The most common values of\n"
18056 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18057 " is left justified, centred, or right justified within the text\n"
18058 " area, but other values are allowed as well.\n"
18059 "\n"
18060 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18061 " nlegend cmap0 text colors.\n"
18062 "\n"
18063 " text (PLCHAR_MATRIX, input) : A vector of\n"
18064 " nlegend UTF-8 character strings containing the legend annotations.\n"
18065 "\n"
18066 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18067 " nlegend cmap0 colors for the discrete colored boxes (\n"
18068 " PL_LEGEND_COLOR_BOX).\n"
18069 "\n"
18070 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18071 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18072 " PL_LEGEND_COLOR_BOX).\n"
18073 "\n"
18074 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18075 " nlegend scales (units of fraction of character height) for the height\n"
18076 " of the discrete colored boxes (\n"
18077 " PL_LEGEND_COLOR_BOX).\n"
18078 "\n"
18079 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18080 " nlegend line widths for the patterns specified by box_patterns (\n"
18081 " PL_LEGEND_COLOR_BOX).\n"
18082 "\n"
18083 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18084 " nlegend cmap0 line colors (\n"
18085 " PL_LEGEND_LINE).\n"
18086 "\n"
18087 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18088 " nlegend line styles (plsty indices) (\n"
18089 " PL_LEGEND_LINE).\n"
18090 "\n"
18091 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18092 " nlegend line widths (\n"
18093 " PL_LEGEND_LINE).\n"
18094 "\n"
18095 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18096 " nlegend cmap0 symbol colors (\n"
18097 " PL_LEGEND_SYMBOL).\n"
18098 "\n"
18099 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18100 " nlegend scale values for the symbol height (\n"
18101 " PL_LEGEND_SYMBOL).\n"
18102 "\n"
18103 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18104 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18105 " area (\n"
18106 " PL_LEGEND_SYMBOL).\n"
18107 "\n"
18108 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18109 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18110 " PL_LEGEND_SYMBOL).\n"
18111 "\n"
18112 ""},
18113 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
18114 "Plot color bar for image, shade or gradient plots\n"
18115 "\n"
18116 "DESCRIPTION:\n"
18117 "\n"
18118 " Routine for creating a continuous color bar for image, shade, or\n"
18119 " gradient plots. (See pllegend for similar functionality for creating\n"
18120 " legends with discrete elements). The arguments of plcolorbar provide\n"
18121 " control over the location and size of the color bar as well as the\n"
18122 " location and characteristics of the elements (most of which are\n"
18123 " optional) within that color bar. The resulting color bar is clipped\n"
18124 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18125 " system used for some of the parameters is defined in the documentation\n"
18126 " of the position parameter.)\n"
18127 "\n"
18128 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18129 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18130 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18131 " labels, axis_opts, ticks, sub_ticks, values)\n"
18132 "\n"
18133 " This function is used in examples 16 and 33.\n"
18134 "\n"
18135 "\n"
18136 "\n"
18137 "SYNOPSIS:\n"
18138 "\n"
18139 "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"
18140 "\n"
18141 "ARGUMENTS:\n"
18142 "\n"
18143 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18144 " labelled and decorated color bar width in adopted coordinates.\n"
18145 "\n"
18146 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18147 " labelled and decorated color bar height in adopted coordinates.\n"
18148 "\n"
18149 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18150 " color bar. The orientation (direction of the maximum value) of\n"
18151 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18152 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18153 " specified, the default orientation is toward the top if the\n"
18154 " colorbar is placed on the left or right of the viewport or toward\n"
18155 " the right if the colorbar is placed on the top or bottom of the\n"
18156 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18157 " (semitransparent) background for the color bar. If the\n"
18158 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18159 " color bar. The type of color bar must be specified with one of\n"
18160 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18161 " more than one of those bits is set only the first one in the above\n"
18162 " list is honored. The position of the (optional) label/title can be\n"
18163 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18164 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18165 " will be drawn. If more than one of this list of bits is specified,\n"
18166 " only the first one on the list is honored. End-caps for the color\n"
18167 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18168 " If a particular color bar cap option is not specified then no cap\n"
18169 " will be drawn for that end. As a special case for\n"
18170 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18171 " specified. If this option is provided then any tick marks and tick\n"
18172 " labels will be placed at the breaks between shaded segments. TODO:\n"
18173 " This should be expanded to support custom placement of tick marks\n"
18174 " and tick labels at custom value locations for any color bar type.\n"
18175 "\n"
18176 " position (PLINT, input) : position contains bits which control the\n"
18177 " overall position of the color bar and the definition of the\n"
18178 " adopted coordinates used for positions just like what is done for\n"
18179 " the position argument for pllegend. However, note that the\n"
18180 " defaults for the position bits (see below) are different than the\n"
18181 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18182 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18183 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18184 " the 16 possible standard positions (the 4 corners and centers of\n"
18185 " the 4 sides for both the inside and outside cases) of the color\n"
18186 " bar relative to the adopted coordinate system. The corner\n"
18187 " positions are specified by the appropriate combination of two of\n"
18188 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18189 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18190 " value of one of those bits. The adopted coordinates are\n"
18191 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18192 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18193 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18194 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18195 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18196 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18197 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18198 " PL_POSITION_VIEWPORT.\n"
18199 "\n"
18200 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18201 " coordinates from the specified standard position of the color bar.\n"
18202 " For positive x, the direction of motion away from the standard\n"
18203 " position is inward/outward from the standard corner positions or\n"
18204 " standard left or right positions if the\n"
18205 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18206 " For the standard top or bottom positions, the direction of motion\n"
18207 " is toward positive X.\n"
18208 "\n"
18209 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18210 " coordinates from the specified standard position of the color bar.\n"
18211 " For positive y, the direction of motion away from the standard\n"
18212 " position is inward/outward from the standard corner positions or\n"
18213 " standard top or bottom positions if the\n"
18214 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18215 " For the standard left or right positions, the direction of motion\n"
18216 " is toward positive Y.\n"
18217 "\n"
18218 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18219 " the X direction in adopted coordinates.\n"
18220 "\n"
18221 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18222 " the Y direction in adopted coordinates.\n"
18223 "\n"
18224 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18225 " color bar (PL_COLORBAR_BACKGROUND).\n"
18226 "\n"
18227 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18228 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18229 "\n"
18230 " bb_style (PLINT, input) : The pllsty style number for the\n"
18231 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18232 "\n"
18233 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18234 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18235 "\n"
18236 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18237 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18238 "\n"
18239 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18240 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18241 " it will be interpreted according to the design of plshades.\n"
18242 "\n"
18243 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18244 " plots. This is passed directly to plshades, so it will be\n"
18245 " interpreted according to the design of plshades.\n"
18246 "\n"
18247 " n_labels (PLINT, input) : Number of labels to place around the\n"
18248 " color bar.\n"
18249 "\n"
18250 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18251 " n_labels labels.\n"
18252 "\n"
18253 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18254 " n_labels UTF-8 character strings containing the labels for the color\n"
18255 " bar. Ignored if no label position is specified with one of the\n"
18256 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18257 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18258 " corresponding label_opts field.\n"
18259 "\n"
18260 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18261 " value must be greater than 0. It is typically 1 (numerical axis\n"
18262 " labels are provided for one of the long edges of the color bar),\n"
18263 " but it can be larger if multiple numerical axis labels for the\n"
18264 " long edges of the color bar are desired.\n"
18265 "\n"
18266 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18267 " n_axes ascii character strings containing options (interpreted as for\n"
18268 " plbox) for the color bar's axis definitions.\n"
18269 "\n"
18270 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18271 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18272 " color bar's axis definitions.\n"
18273 "\n"
18274 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18275 " number of subticks (interpreted as for plbox) for the color bar's\n"
18276 " axis definitions.\n"
18277 "\n"
18278 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18279 " elements in each of the n_axes rows of the values matrix.\n"
18280 "\n"
18281 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18282 " values for the data range represented by the color bar. For a row\n"
18283 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18284 " elements in the row is specified by n_values[i_axis]. For\n"
18285 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18286 " is 2, and the corresponding row elements of the values matrix are\n"
18287 " the minimum and maximum value represented by the colorbar. For\n"
18288 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18289 " of the values matrix is interpreted the same as the nlevel and\n"
18290 " clevel arguments of plshades.\n"
18291 "\n"
18292 ""},
18293 { "pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
18294 "Sets the 3D position of the light source\n"
18295 "\n"
18296 "DESCRIPTION:\n"
18297 "\n"
18298 " Sets the 3D position of the light source for use with plsurf3d and\n"
18299 " plsurf3dl\n"
18300 "\n"
18301 " Redacted form: pllightsource(x, y, z)\n"
18302 "\n"
18303 " This function is used in example 8.\n"
18304 "\n"
18305 "\n"
18306 "\n"
18307 "SYNOPSIS:\n"
18308 "\n"
18309 "pllightsource(x, y, z)\n"
18310 "\n"
18311 "ARGUMENTS:\n"
18312 "\n"
18313 " x (PLFLT, input) : X-coordinate of the light source.\n"
18314 "\n"
18315 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18316 "\n"
18317 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18318 "\n"
18319 ""},
18320 { "plline", _wrap_plline, METH_VARARGS, (char *)"\n"
18321 "Draw a line\n"
18322 "\n"
18323 "DESCRIPTION:\n"
18324 "\n"
18325 " Draws line defined by n points in x and y.\n"
18326 "\n"
18327 " Redacted form: plline(x, y)\n"
18328 "\n"
18329 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18330 " 25-27, and 29.\n"
18331 "\n"
18332 "\n"
18333 "\n"
18334 "SYNOPSIS:\n"
18335 "\n"
18336 "plline(n, x, y)\n"
18337 "\n"
18338 "ARGUMENTS:\n"
18339 "\n"
18340 " n (PLINT, input) : Number of points defining line.\n"
18341 "\n"
18342 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18343 " points.\n"
18344 "\n"
18345 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18346 " points.\n"
18347 "\n"
18348 ""},
18349 { "plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
18350 "Draw a line in 3 space\n"
18351 "\n"
18352 "DESCRIPTION:\n"
18353 "\n"
18354 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18355 " first set up the viewport, the 2d viewing window (in world\n"
18356 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18357 " more info.\n"
18358 "\n"
18359 " Redacted form: plline3(x, y, z)\n"
18360 "\n"
18361 " This function is used in example 18.\n"
18362 "\n"
18363 "\n"
18364 "\n"
18365 "SYNOPSIS:\n"
18366 "\n"
18367 "plline3(n, x, y, z)\n"
18368 "\n"
18369 "ARGUMENTS:\n"
18370 "\n"
18371 " n (PLINT, input) : Number of points defining line.\n"
18372 "\n"
18373 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18374 " points.\n"
18375 "\n"
18376 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18377 " points.\n"
18378 "\n"
18379 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18380 " points.\n"
18381 "\n"
18382 ""},
18383 { "pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
18384 "Select line style\n"
18385 "\n"
18386 "DESCRIPTION:\n"
18387 "\n"
18388 " This sets the line style according to one of eight predefined patterns\n"
18389 " (also see plstyl).\n"
18390 "\n"
18391 " Redacted form: pllsty(lin)\n"
18392 "\n"
18393 " This function is used in examples 9, 12, 22, and 25.\n"
18394 "\n"
18395 "\n"
18396 "\n"
18397 "SYNOPSIS:\n"
18398 "\n"
18399 "pllsty(lin)\n"
18400 "\n"
18401 "ARGUMENTS:\n"
18402 "\n"
18403 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18404 " a continuous line, line style 2 is a line with short dashes and\n"
18405 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18406 " 4 has long dashes and short gaps and so on.\n"
18407 "\n"
18408 ""},
18409 { "plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
18410 "Plot surface mesh\n"
18411 "\n"
18412 "DESCRIPTION:\n"
18413 "\n"
18414 " Plots a surface mesh within the environment set up by plw3d. The\n"
18415 " surface is defined by the matrix z[\n"
18416 " nx][\n"
18417 " ny] , the point z[i][j] being the value of the function at (\n"
18418 " x[i],\n"
18419 " y[j]). Note that the points in vectors x and y do not need to be\n"
18420 " equally spaced, but must be stored in ascending order. The parameter\n"
18421 " opt controls the way in which the surface is displayed. For further\n"
18422 " details see the PLplot documentation.\n"
18423 "\n"
18424 " Redacted form: plmesh(x, y, z, opt)\n"
18425 "\n"
18426 " This function is used in example 11.\n"
18427 "\n"
18428 "\n"
18429 "\n"
18430 "SYNOPSIS:\n"
18431 "\n"
18432 "plmesh(x, y, z, nx, ny, opt)\n"
18433 "\n"
18434 "ARGUMENTS:\n"
18435 "\n"
18436 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18437 " which the function is evaluated.\n"
18438 "\n"
18439 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18440 " which the function is evaluated.\n"
18441 "\n"
18442 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18443 " plot. Should have dimensions of\n"
18444 " nx by\n"
18445 " ny.\n"
18446 "\n"
18447 " nx (PLINT, input) : Number of x values at which function has been\n"
18448 " evaluated.\n"
18449 "\n"
18450 " ny (PLINT, input) : Number of y values at which function has been\n"
18451 " evaluated.\n"
18452 "\n"
18453 " opt (PLINT, input) : Determines the way in which the surface is\n"
18454 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18455 " function of x for each value of y[j] .\n"
18456 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18457 " for each value of x[i] .\n"
18458 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18459 " at which function is defined.\n"
18460 "\n"
18461 ""},
18462 { "plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
18463 "Magnitude colored plot surface mesh with contour\n"
18464 "\n"
18465 "DESCRIPTION:\n"
18466 "\n"
18467 " A more powerful form of plmesh: the surface mesh can be colored\n"
18468 " accordingly to the current z value being plotted, a contour plot can\n"
18469 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18470 " plotted function border and the base XY plane.\n"
18471 "\n"
18472 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18473 "\n"
18474 " This function is used in example 11.\n"
18475 "\n"
18476 "\n"
18477 "\n"
18478 "SYNOPSIS:\n"
18479 "\n"
18480 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18481 "\n"
18482 "ARGUMENTS:\n"
18483 "\n"
18484 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18485 " which the function is evaluated.\n"
18486 "\n"
18487 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18488 " which the function is evaluated.\n"
18489 "\n"
18490 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18491 " plot. Should have dimensions of\n"
18492 " nx by\n"
18493 " ny.\n"
18494 "\n"
18495 " nx (PLINT, input) : Number of x values at which function is\n"
18496 " evaluated.\n"
18497 "\n"
18498 " ny (PLINT, input) : Number of y values at which function is\n"
18499 " evaluated.\n"
18500 "\n"
18501 " opt (PLINT, input) : Determines the way in which the surface is\n"
18502 " represented. To specify more than one option just add the options,\n"
18503 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18504 " showing z as a function of x for each value of y[j] .\n"
18505 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18506 " for each value of x[i] .\n"
18507 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18508 " at which function is defined.\n"
18509 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18510 " the z value being plotted. The color is used from the current\n"
18511 " cmap1.\n"
18512 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18513 " using parameters\n"
18514 " nlevel and\n"
18515 " clevel.\n"
18516 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18517 " the borders of the plotted function.\n"
18518 "\n"
18519 "\n"
18520 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18521 " levels.\n"
18522 "\n"
18523 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18524 "\n"
18525 ""},
18526 { "plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
18527 "Creates a new stream and makes it the default\n"
18528 "\n"
18529 "DESCRIPTION:\n"
18530 "\n"
18531 " Creates a new stream and makes it the default. Differs from using\n"
18532 " plsstrm, in that a free stream number is found, and returned.\n"
18533 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18534 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18535 " that no initial, library-opening call is required. So stream 0 must\n"
18536 " be preallocated, and there is no simple way of determining whether it\n"
18537 " is already in use or not.\n"
18538 "\n"
18539 " Redacted form: plmkstrm(p_strm)\n"
18540 "\n"
18541 " This function is used in examples 1 and 20.\n"
18542 "\n"
18543 "\n"
18544 "\n"
18545 "SYNOPSIS:\n"
18546 "\n"
18547 "plmkstrm(p_strm)\n"
18548 "\n"
18549 "ARGUMENTS:\n"
18550 "\n"
18551 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18552 " number of the created stream.\n"
18553 "\n"
18554 ""},
18555 { "plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
18556 "Write text relative to viewport boundaries\n"
18557 "\n"
18558 "DESCRIPTION:\n"
18559 "\n"
18560 " Writes text at a specified position relative to the viewport\n"
18561 " boundaries. Text may be written inside or outside the viewport, but\n"
18562 " is clipped at the subpage boundaries. The reference point of a string\n"
18563 " lies along a line passing through the string at half the height of a\n"
18564 " capital letter. The position of the reference point along this line\n"
18565 " is determined by just, and the position of the reference point\n"
18566 " relative to the viewport is set by disp and pos.\n"
18567 "\n"
18568 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18569 "\n"
18570 "\n"
18571 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18572 " 26.\n"
18573 "\n"
18574 "\n"
18575 "\n"
18576 "SYNOPSIS:\n"
18577 "\n"
18578 "plmtex(side, disp, pos, just, text)\n"
18579 "\n"
18580 "ARGUMENTS:\n"
18581 "\n"
18582 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18583 " the side of the viewport along which the text is to be written.\n"
18584 " The string must be one of: b: Bottom of viewport, text written\n"
18585 " parallel to edge.\n"
18586 " bv: Bottom of viewport, text written at right angles to edge.\n"
18587 " l: Left of viewport, text written parallel to edge.\n"
18588 " lv: Left of viewport, text written at right angles to edge.\n"
18589 " r: Right of viewport, text written parallel to edge.\n"
18590 " rv: Right of viewport, text written at right angles to edge.\n"
18591 " t: Top of viewport, text written parallel to edge.\n"
18592 " tv: Top of viewport, text written at right angles to edge.\n"
18593 "\n"
18594 "\n"
18595 " disp (PLFLT, input) : Position of the reference point of string,\n"
18596 " measured outwards from the specified viewport edge in units of the\n"
18597 " current character height. Use negative disp to write within the\n"
18598 " viewport.\n"
18599 "\n"
18600 " pos (PLFLT, input) : Position of the reference point of string\n"
18601 " along the specified edge, expressed as a fraction of the length of\n"
18602 " the edge.\n"
18603 "\n"
18604 " just (PLFLT, input) : Specifies the position of the string relative\n"
18605 " to its reference point. If just=0. , the reference point is at\n"
18606 " the left and if just=1. , it is at the right of the string. Other\n"
18607 " values of just give intermediate justifications.\n"
18608 "\n"
18609 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18610 " written out.\n"
18611 "\n"
18612 ""},
18613 { "plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
18614 "Write text relative to viewport boundaries in 3D plots\n"
18615 "\n"
18616 "DESCRIPTION:\n"
18617 "\n"
18618 " Writes text at a specified position relative to the viewport\n"
18619 " boundaries. Text may be written inside or outside the viewport, but\n"
18620 " is clipped at the subpage boundaries. The reference point of a string\n"
18621 " lies along a line passing through the string at half the height of a\n"
18622 " capital letter. The position of the reference point along this line\n"
18623 " is determined by just, and the position of the reference point\n"
18624 " relative to the viewport is set by disp and pos.\n"
18625 "\n"
18626 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18627 "\n"
18628 " This function is used in example 28.\n"
18629 "\n"
18630 "\n"
18631 "\n"
18632 "SYNOPSIS:\n"
18633 "\n"
18634 "plmtex3(side, disp, pos, just, text)\n"
18635 "\n"
18636 "ARGUMENTS:\n"
18637 "\n"
18638 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18639 " the side of the viewport along which the text is to be written.\n"
18640 " The string should contain one or more of the following characters:\n"
18641 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18642 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18643 " axis.\n"
18644 " y: Label the Y axis.\n"
18645 " z: Label the Z axis.\n"
18646 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18647 " For X it is the axis that starts at y-min. For Y it is the\n"
18648 " axis that starts at x-min.\n"
18649 " s: Label the secondary axis.\n"
18650 " v: Draw the text perpendicular to the axis.\n"
18651 "\n"
18652 "\n"
18653 " disp (PLFLT, input) : Position of the reference point of string,\n"
18654 " measured outwards from the specified viewport edge in units of the\n"
18655 " current character height. Use negative disp to write within the\n"
18656 " viewport.\n"
18657 "\n"
18658 " pos (PLFLT, input) : Position of the reference point of string\n"
18659 " along the specified edge, expressed as a fraction of the length of\n"
18660 " the edge.\n"
18661 "\n"
18662 " just (PLFLT, input) : Specifies the position of the string relative\n"
18663 " to its reference point. If just=0. , the reference point is at\n"
18664 " the left and if just=1. , it is at the right of the string. Other\n"
18665 " values of just give intermediate justifications.\n"
18666 "\n"
18667 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18668 " written out.\n"
18669 "\n"
18670 ""},
18671 { "plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
18672 "Plot 3-d surface plot\n"
18673 "\n"
18674 "DESCRIPTION:\n"
18675 "\n"
18676 " Plots a three-dimensional surface plot within the environment set up\n"
18677 " by plw3d. The surface is defined by the matrix z[\n"
18678 " nx][\n"
18679 " ny] , the point z[i][j] being the value of the function at (\n"
18680 " x[i],\n"
18681 " y[j]). Note that the points in vectors x and y do not need to be\n"
18682 " equally spaced, but must be stored in ascending order. The parameter\n"
18683 " opt controls the way in which the surface is displayed. For further\n"
18684 " details see the PLplot documentation. The only difference between\n"
18685 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18686 " while plot3d only draws the surface as viewed from the top.\n"
18687 "\n"
18688 " Redacted form: plot3d(x, y, z, opt, side)\n"
18689 "\n"
18690 " This function is used in examples 11 and 21.\n"
18691 "\n"
18692 "\n"
18693 "\n"
18694 "SYNOPSIS:\n"
18695 "\n"
18696 "plot3d(x, y, z, nx, ny, opt, side)\n"
18697 "\n"
18698 "ARGUMENTS:\n"
18699 "\n"
18700 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18701 " which the function is evaluated.\n"
18702 "\n"
18703 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18704 " which the function is evaluated.\n"
18705 "\n"
18706 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18707 " plot. Should have dimensions of\n"
18708 " nx by\n"
18709 " ny.\n"
18710 "\n"
18711 " nx (PLINT, input) : Number of x values at which function is\n"
18712 " evaluated.\n"
18713 "\n"
18714 " ny (PLINT, input) : Number of y values at which function is\n"
18715 " evaluated.\n"
18716 "\n"
18717 " opt (PLINT, input) : Determines the way in which the surface is\n"
18718 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18719 " function of x for each value of y[j] .\n"
18720 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18721 " for each value of x[i] .\n"
18722 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18723 " at which function is defined.\n"
18724 "\n"
18725 "\n"
18726 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18727 " should be draw on the figure. If side is true sides are drawn,\n"
18728 " otherwise no sides are drawn.\n"
18729 "\n"
18730 ""},
18731 { "plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18732 "Magnitude colored plot surface with contour\n"
18733 "\n"
18734 "DESCRIPTION:\n"
18735 "\n"
18736 " Aside from dropping the\n"
18737 " side functionality this is a more powerful form of plot3d: the surface\n"
18738 " mesh can be colored accordingly to the current z value being plotted,\n"
18739 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18740 " drawn between the plotted function border and the base XY plane. The\n"
18741 " arguments are identical to those of plmeshc. The only difference\n"
18742 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18743 " the surface, while plot3dc only draws the surface as viewed from the\n"
18744 " top.\n"
18745 "\n"
18746 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18747 "\n"
18748 "\n"
18749 " This function is used in example 21.\n"
18750 "\n"
18751 "\n"
18752 "\n"
18753 "SYNOPSIS:\n"
18754 "\n"
18755 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18756 "\n"
18757 "ARGUMENTS:\n"
18758 "\n"
18759 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18760 " which the function is evaluated.\n"
18761 "\n"
18762 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18763 " which the function is evaluated.\n"
18764 "\n"
18765 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18766 " plot. Should have dimensions of\n"
18767 " nx by\n"
18768 " ny.\n"
18769 "\n"
18770 " nx (PLINT, input) : Number of x values at which function is\n"
18771 " evaluated.\n"
18772 "\n"
18773 " ny (PLINT, input) : Number of y values at which function is\n"
18774 " evaluated.\n"
18775 "\n"
18776 " opt (PLINT, input) : Determines the way in which the surface is\n"
18777 " represented. To specify more than one option just add the options,\n"
18778 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18779 " showing z as a function of x for each value of y[j] .\n"
18780 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18781 " for each value of x[i] .\n"
18782 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18783 " at which function is defined.\n"
18784 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18785 " the z value being plotted. The color is used from the current\n"
18786 " cmap1.\n"
18787 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18788 " using parameters\n"
18789 " nlevel and\n"
18790 " clevel.\n"
18791 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18792 " the borders of the plotted function.\n"
18793 "\n"
18794 "\n"
18795 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18796 " levels.\n"
18797 "\n"
18798 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18799 "\n"
18800 ""},
18801 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18802 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18803 "\n"
18804 "DESCRIPTION:\n"
18805 "\n"
18806 " When the implementation is completed this variant of plot3dc (see that\n"
18807 " function's documentation for more details) should be suitable for the\n"
18808 " case where the area of the x, y coordinate grid where z is defined can\n"
18809 " be non-rectangular. The implementation is incomplete so the last 4\n"
18810 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18811 " indexymax; are currently ignored and the functionality is otherwise\n"
18812 " identical to that of plot3dc.\n"
18813 "\n"
18814 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18815 " indexymin, indexymax)\n"
18816 "\n"
18817 "\n"
18818 " This function is not used in any example.\n"
18819 "\n"
18820 "\n"
18821 "\n"
18822 "SYNOPSIS:\n"
18823 "\n"
18824 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18825 "\n"
18826 "ARGUMENTS:\n"
18827 "\n"
18828 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18829 " which the function is evaluated.\n"
18830 "\n"
18831 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18832 " which the function is evaluated.\n"
18833 "\n"
18834 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18835 " plot. Should have dimensions of\n"
18836 " nx by\n"
18837 " ny.\n"
18838 "\n"
18839 " nx (PLINT, input) : Number of x values at which the function is\n"
18840 " evaluated.\n"
18841 "\n"
18842 " ny (PLINT, input) : Number of y values at which the function is\n"
18843 " evaluated.\n"
18844 "\n"
18845 " opt (PLINT, input) : Determines the way in which the surface is\n"
18846 " represented. To specify more than one option just add the options,\n"
18847 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18848 " showing z as a function of x for each value of y[j] .\n"
18849 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18850 " for each value of x[i] .\n"
18851 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18852 " at which function is defined.\n"
18853 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18854 " the z value being plotted. The color is used from the current\n"
18855 " cmap1.\n"
18856 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18857 " using parameters\n"
18858 " nlevel and\n"
18859 " clevel.\n"
18860 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18861 " the borders of the plotted function.\n"
18862 "\n"
18863 "\n"
18864 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18865 " levels.\n"
18866 "\n"
18867 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18868 "\n"
18869 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18870 " corresponds to the first x index where z is defined.\n"
18871 "\n"
18872 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18873 " which corresponds (by convention) to one more than the last x\n"
18874 " index value where z is defined.\n"
18875 "\n"
18876 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18877 " values which all must be ≥ 0. These values are the first y index\n"
18878 " where z is defined for a particular x index in the range from\n"
18879 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18880 " indexxmax.\n"
18881 "\n"
18882 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18883 " values which all must be ≤ ny. These values correspond (by\n"
18884 " convention) to one more than the last y index where z is defined\n"
18885 " for a particular x index in the range from indexxmin to indexxmax\n"
18886 " - 1. The dimension of indexymax is indexxmax.\n"
18887 "\n"
18888 ""},
18889 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18890 "Plot shaded 3-d surface plot\n"
18891 "\n"
18892 "DESCRIPTION:\n"
18893 "\n"
18894 " Plots a three-dimensional shaded surface plot within the environment\n"
18895 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18896 " z[\n"
18897 " nx][\n"
18898 " ny], the point z[i][j] being the value of the function at (\n"
18899 " x[i],\n"
18900 " y[j]). Note that the points in vectors x and y do not need to be\n"
18901 " equally spaced, but must be stored in ascending order. For further\n"
18902 " details see the PLplot documentation.\n"
18903 "\n"
18904 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18905 "\n"
18906 " This function is not used in any examples.\n"
18907 "\n"
18908 "\n"
18909 "\n"
18910 "SYNOPSIS:\n"
18911 "\n"
18912 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18913 "\n"
18914 "ARGUMENTS:\n"
18915 "\n"
18916 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18917 " which the function is evaluated.\n"
18918 "\n"
18919 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18920 " which the function is evaluated.\n"
18921 "\n"
18922 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18923 " plot. Should have dimensions of\n"
18924 " nx by\n"
18925 " ny.\n"
18926 "\n"
18927 " nx (PLINT, input) : Number of x values at which function is\n"
18928 " evaluated.\n"
18929 "\n"
18930 " ny (PLINT, input) : Number of y values at which function is\n"
18931 " evaluated.\n"
18932 "\n"
18933 " opt (PLINT, input) : Determines the way in which the surface is\n"
18934 " represented. To specify more than one option just add the options,\n"
18935 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18936 " connecting points at which function is defined.\n"
18937 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18938 " using parameters\n"
18939 " nlevel and\n"
18940 " clevel.\n"
18941 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18942 " using parameters\n"
18943 " nlevel and\n"
18944 " clevel.\n"
18945 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18946 " the borders of the plotted function.\n"
18947 " opt=MAG_COLOR : the surface is colored according to the value\n"
18948 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18949 " according to the intensity of the reflected light in the\n"
18950 " surface from a light source whose position is set using\n"
18951 " pllightsource.\n"
18952 "\n"
18953 "\n"
18954 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18955 " levels.\n"
18956 "\n"
18957 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18958 "\n"
18959 ""},
18960 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18961 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18962 "\n"
18963 "DESCRIPTION:\n"
18964 "\n"
18965 " This variant of plsurf3d (see that function's documentation for more\n"
18966 " details) should be suitable for the case where the area of the x, y\n"
18967 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18968 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18969 " indexymin, and indexymax.\n"
18970 "\n"
18971 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18972 " indexymax)\n"
18973 "\n"
18974 " This function is used in example 8.\n"
18975 "\n"
18976 "\n"
18977 "\n"
18978 "SYNOPSIS:\n"
18979 "\n"
18980 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18981 "\n"
18982 "ARGUMENTS:\n"
18983 "\n"
18984 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18985 " which the function is evaluated.\n"
18986 "\n"
18987 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18988 " which the function is evaluated.\n"
18989 "\n"
18990 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18991 " plot. Should have dimensions of\n"
18992 " nx by\n"
18993 " ny.\n"
18994 "\n"
18995 " nx (PLINT, input) : Number of x values at which function is\n"
18996 " evaluated.\n"
18997 "\n"
18998 " ny (PLINT, input) : Number of y values at which function is\n"
18999 " evaluated.\n"
19000 "\n"
19001 " opt (PLINT, input) : Determines the way in which the surface is\n"
19002 " represented. To specify more than one option just add the options,\n"
19003 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19004 " connecting points at which function is defined.\n"
19005 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19006 " using parameters\n"
19007 " nlevel and\n"
19008 " clevel.\n"
19009 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19010 " using parameters\n"
19011 " nlevel and\n"
19012 " clevel.\n"
19013 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19014 " the borders of the plotted function.\n"
19015 " opt=MAG_COLOR : the surface is colored according to the value\n"
19016 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19017 " according to the intensity of the reflected light in the\n"
19018 " surface from a light source whose position is set using\n"
19019 " pllightsource.\n"
19020 "\n"
19021 "\n"
19022 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19023 " levels.\n"
19024 "\n"
19025 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19026 "\n"
19027 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19028 " corresponds to the first x index where z is defined.\n"
19029 "\n"
19030 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19031 " which corresponds (by convention) to one more than the last x\n"
19032 " index value where z is defined.\n"
19033 "\n"
19034 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19035 " values which all must be ≥ 0. These values are the first y index\n"
19036 " where z is defined for a particular x index in the range from\n"
19037 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19038 " indexxmax.\n"
19039 "\n"
19040 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19041 " values which all must be ≤ ny. These values correspond (by\n"
19042 " convention) to one more than the last y index where z is defined\n"
19043 " for a particular x index in the range from indexxmin to indexxmax\n"
19044 " - 1. The dimension of indexymax is indexxmax.\n"
19045 "\n"
19046 ""},
19047 { "plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
19048 "Parse command-line arguments\n"
19049 "\n"
19050 "DESCRIPTION:\n"
19051 "\n"
19052 " Parse command-line arguments.\n"
19053 "\n"
19054 " plparseopts removes all recognized flags (decreasing argc\n"
19055 " accordingly), so that invalid input may be readily detected. It can\n"
19056 " also be used to process user command line flags. The user can merge\n"
19057 " an option table of type PLOptionTable into the internal option table\n"
19058 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19059 " the external table(s) be parsed by calling plClearOpts before\n"
19060 " plMergeOpts.\n"
19061 "\n"
19062 " The default action taken by plparseopts is as follows:\n"
19063 " Returns with an error if an unrecognized option or badly formed\n"
19064 " option-value pair are encountered.\n"
19065 " Returns immediately (return code 0) when the first non-option command\n"
19066 " line argument is found.\n"
19067 " Returns with the return code of the option handler, if one was called.\n"
19068 "\n"
19069 " Deletes command line arguments from argv list as they are found, and\n"
19070 " decrements argc accordingly.\n"
19071 " Does not show \"invisible\" options in usage or help messages.\n"
19072 " Assumes the program name is contained in argv[0].\n"
19073 "\n"
19074 " These behaviors may be controlled through the\n"
19075 " mode argument.\n"
19076 "\n"
19077 " Redacted form: General: plparseopts(argv, mode)\n"
19078 "\n"
19079 "\n"
19080 " This function is used in all of the examples.\n"
19081 "\n"
19082 "\n"
19083 "\n"
19084 "SYNOPSIS:\n"
19085 "\n"
19086 "PLINT plparseopts(p_argc, argv, mode)\n"
19087 "\n"
19088 "ARGUMENTS:\n"
19089 "\n"
19090 " p_argc (int *, input/output) : Number of arguments.\n"
19091 "\n"
19092 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19093 " strings containing *p_argc command-line arguments.\n"
19094 "\n"
19095 " mode (PLINT, input) : Parsing mode with the following\n"
19096 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19097 " and all error messages enabled, including program exit when an\n"
19098 " error occurs. Anything on the command line that isn't recognized\n"
19099 " as a valid option or option argument is flagged as an error.\n"
19100 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19101 " of errors.\n"
19102 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19103 " arguments.\n"
19104 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19105 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19106 " pointer to the program name.\n"
19107 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19108 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19109 " unrecognized arguments.\n"
19110 "\n"
19111 ""},
19112 { "plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
19113 "Set area line fill pattern\n"
19114 "\n"
19115 "DESCRIPTION:\n"
19116 "\n"
19117 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19118 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19119 " inclinations and spacings. The arguments to this routine are the\n"
19120 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19121 " elements) specifying the inclinations in tenths of a degree and the\n"
19122 " spacing in micrometers. (See also plpsty)\n"
19123 "\n"
19124 " Redacted form: General: plpat(inc, del)\n"
19125 "\n"
19126 "\n"
19127 " This function is used in example 15.\n"
19128 "\n"
19129 "\n"
19130 "\n"
19131 "SYNOPSIS:\n"
19132 "\n"
19133 "plpat(nlin, inc, del)\n"
19134 "\n"
19135 "ARGUMENTS:\n"
19136 "\n"
19137 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19138 " pattern, either 1 or 2.\n"
19139 "\n"
19140 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19141 " inclination in tenths of a degree. (Should be between -900 and\n"
19142 " 900).\n"
19143 "\n"
19144 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19145 " spacing in micrometers between the lines making up the pattern.\n"
19146 "\n"
19147 ""},
19148 { "plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
19149 "Draw a line between two points, accounting for coordinate transforms\n"
19150 "\n"
19151 "DESCRIPTION:\n"
19152 "\n"
19153 " Joins the point (\n"
19154 " x1,\n"
19155 " y1) to (\n"
19156 " x2,\n"
19157 " y2) . If a global coordinate transform is defined then the line is\n"
19158 " broken in to n segments to approximate the path. If no transform is\n"
19159 " defined then this simply acts like a call to pljoin.\n"
19160 "\n"
19161 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19162 "\n"
19163 " This function is used in example 22.\n"
19164 "\n"
19165 "\n"
19166 "\n"
19167 "SYNOPSIS:\n"
19168 "\n"
19169 "plpath(n, x1, y1, x2, y2)\n"
19170 "\n"
19171 "ARGUMENTS:\n"
19172 "\n"
19173 " n (PLINT, input) : number of points to use to approximate the path.\n"
19174 "\n"
19175 " x1 (PLFLT, input) : x coordinate of first point.\n"
19176 "\n"
19177 " y1 (PLFLT, input) : y coordinate of first point.\n"
19178 "\n"
19179 " x2 (PLFLT, input) : x coordinate of second point.\n"
19180 "\n"
19181 " y2 (PLFLT, input) : y coordinate of second point.\n"
19182 "\n"
19183 ""},
19184 { "plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
19185 "Plot a glyph at the specified points\n"
19186 "\n"
19187 "DESCRIPTION:\n"
19188 "\n"
19189 " Plot a glyph at the specified points. (This function is largely\n"
19190 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19191 " code=-1 means try to just draw a point. Right now it's just a move\n"
19192 " and a draw at the same place. Not ideal, since a sufficiently\n"
19193 " intelligent output device may optimize it away, or there may be faster\n"
19194 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19195 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19196 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19197 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19198 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19199 "\n"
19200 " Redacted form: plpoin(x, y, code)\n"
19201 "\n"
19202 " This function is used in examples 1, 6, 14, and 29.\n"
19203 "\n"
19204 "\n"
19205 "\n"
19206 "SYNOPSIS:\n"
19207 "\n"
19208 "plpoin(n, x, y, code)\n"
19209 "\n"
19210 "ARGUMENTS:\n"
19211 "\n"
19212 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19213 "\n"
19214 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19215 " points.\n"
19216 "\n"
19217 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19218 " points.\n"
19219 "\n"
19220 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19221 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19222 " each of the n points.\n"
19223 "\n"
19224 ""},
19225 { "plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
19226 "Plot a glyph at the specified 3D points\n"
19227 "\n"
19228 "DESCRIPTION:\n"
19229 "\n"
19230 " Plot a glyph at the specified 3D points. (This function is largely\n"
19231 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19232 " Set up the call to this function similar to what is done for plline3.\n"
19233 " code=-1 means try to just draw a point. Right now it's just a move\n"
19234 " and a draw at the same place. Not ideal, since a sufficiently\n"
19235 " intelligent output device may optimize it away, or there may be faster\n"
19236 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19237 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19238 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19239 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19240 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19241 "\n"
19242 " Redacted form: plpoin3(x, y, z, code)\n"
19243 "\n"
19244 " This function is not used in any example.\n"
19245 "\n"
19246 "\n"
19247 "\n"
19248 "SYNOPSIS:\n"
19249 "\n"
19250 "plpoin3(n, x, y, z, code)\n"
19251 "\n"
19252 "ARGUMENTS:\n"
19253 "\n"
19254 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19255 "\n"
19256 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19257 " points.\n"
19258 "\n"
19259 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19260 " points.\n"
19261 "\n"
19262 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19263 " points.\n"
19264 "\n"
19265 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19266 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19267 " each of the n points.\n"
19268 "\n"
19269 ""},
19270 { "plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
19271 "Draw a polygon in 3 space\n"
19272 "\n"
19273 "DESCRIPTION:\n"
19274 "\n"
19275 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19276 " like plline3, but differs from that function in that plpoly3 attempts\n"
19277 " to determine if the polygon is viewable depending on the order of the\n"
19278 " points within the vector and the value of ifcc. If the back of\n"
19279 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19280 " you want, then use plline3 instead.\n"
19281 "\n"
19282 " The points are assumed to be in a plane, and the directionality of the\n"
19283 " plane is determined from the first three points. Additional points do\n"
19284 " not have to lie on the plane defined by the first three, but if they\n"
19285 " do not, then the determination of visibility obviously can't be 100%\n"
19286 " accurate... So if you're 3 space polygons are too far from planar,\n"
19287 " consider breaking them into smaller polygons. 3 points define a plane\n"
19288 " :-).\n"
19289 "\n"
19290 " Bugs: If one of the first two segments is of zero length, or if they\n"
19291 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19292 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19293 " of this problem. (Search for 20.1).\n"
19294 "\n"
19295 " Redacted form: plpoly3(x, y, z, code)\n"
19296 "\n"
19297 " This function is used in example 18.\n"
19298 "\n"
19299 "\n"
19300 "\n"
19301 "SYNOPSIS:\n"
19302 "\n"
19303 "plpoly3(n, x, y, z, draw, ifcc)\n"
19304 "\n"
19305 "ARGUMENTS:\n"
19306 "\n"
19307 " n (PLINT, input) : Number of points defining line.\n"
19308 "\n"
19309 " x (PLFLT_VECTOR, input) : A vector containing\n"
19310 " n x coordinates of points.\n"
19311 "\n"
19312 " y (PLFLT_VECTOR, input) : A vector containing\n"
19313 " n y coordinates of points.\n"
19314 "\n"
19315 " z (PLFLT_VECTOR, input) : A vector containing\n"
19316 " n z coordinates of points.\n"
19317 "\n"
19318 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19319 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19320 " If draw[i] is true, then the polygon segment from index [i] to\n"
19321 " [i+1] is drawn, otherwise, not.\n"
19322 "\n"
19323 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19324 " polygon is determined by assuming the points are laid out in a\n"
19325 " counter-clockwise order. Otherwise, the directionality of the\n"
19326 " polygon is determined by assuming the points are laid out in a\n"
19327 " clockwise order.\n"
19328 "\n"
19329 ""},
19330 { "plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
19331 "Set precision in numeric labels\n"
19332 "\n"
19333 "DESCRIPTION:\n"
19334 "\n"
19335 " Sets the number of places after the decimal point in numeric labels.\n"
19336 "\n"
19337 " Redacted form: plprec(setp, prec)\n"
19338 "\n"
19339 " This function is used in example 29.\n"
19340 "\n"
19341 "\n"
19342 "\n"
19343 "SYNOPSIS:\n"
19344 "\n"
19345 "plprec(setp, prec)\n"
19346 "\n"
19347 "ARGUMENTS:\n"
19348 "\n"
19349 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19350 " automatically determines the number of places to use after the\n"
19351 " decimal point in numeric labels (like those used to label axes).\n"
19352 " If setp is 1 then prec sets the number of places.\n"
19353 "\n"
19354 " prec (PLINT, input) : The number of characters to draw after the\n"
19355 " decimal point in numeric labels.\n"
19356 "\n"
19357 ""},
19358 { "plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
19359 "Select area fill pattern\n"
19360 "\n"
19361 "DESCRIPTION:\n"
19362 "\n"
19363 " If\n"
19364 " patt is zero or less use either a hardware solid fill if the drivers\n"
19365 " have that capability (virtually all do) or fall back to a software\n"
19366 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19367 " 0 <\n"
19368 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19369 " to use (see plpat if you desire other patterns).\n"
19370 "\n"
19371 " Redacted form: plpsty(patt)\n"
19372 "\n"
19373 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19374 "\n"
19375 "\n"
19376 "\n"
19377 "SYNOPSIS:\n"
19378 "\n"
19379 "plpsty(patt)\n"
19380 "\n"
19381 "ARGUMENTS:\n"
19382 "\n"
19383 " patt (PLINT, input) : The desired pattern index. If\n"
19384 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19385 " above) used. For\n"
19386 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19387 " line fill capability itself (most deliberately do not so that line\n"
19388 " fill patterns look identical for those drivers), the patterns\n"
19389 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19390 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19391 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19392 " (8) lines at both 45 degrees and -45 degrees.\n"
19393 "\n"
19394 ""},
19395 { "plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
19396 "Write text inside the viewport\n"
19397 "\n"
19398 "DESCRIPTION:\n"
19399 "\n"
19400 " Writes text at a specified position and inclination within the\n"
19401 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19402 " point of a string lies along a line passing through the string at half\n"
19403 " the height of a capital letter. The position of the reference point\n"
19404 " along this line is determined by just, the reference point is placed\n"
19405 " at world coordinates (\n"
19406 " x,\n"
19407 " y) within the viewport. The inclination of the string is specified\n"
19408 " in terms of differences of world coordinates making it easy to write\n"
19409 " text parallel to a line in a graph.\n"
19410 "\n"
19411 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19412 "\n"
19413 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19414 "\n"
19415 "\n"
19416 "\n"
19417 "SYNOPSIS:\n"
19418 "\n"
19419 "plptex(x, y, dx, dy, just, text)\n"
19420 "\n"
19421 "ARGUMENTS:\n"
19422 "\n"
19423 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19424 "\n"
19425 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19426 "\n"
19427 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19428 " inclination of the string. The baseline of the string is parallel\n"
19429 " to a line joining (\n"
19430 " x,\n"
19431 " y) to (\n"
19432 " x+\n"
19433 " dx,\n"
19434 " y+\n"
19435 " dy) .\n"
19436 "\n"
19437 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19438 " inclination of the string.\n"
19439 "\n"
19440 " just (PLFLT, input) : Specifies the position of the string relative\n"
19441 " to its reference point. If just=0. , the reference point is at\n"
19442 " the left and if just=1. , it is at the right of the string. Other\n"
19443 " values of just give intermediate justifications.\n"
19444 "\n"
19445 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19446 " written out.\n"
19447 "\n"
19448 ""},
19449 { "plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
19450 "Write text inside the viewport of a 3D plot\n"
19451 "\n"
19452 "DESCRIPTION:\n"
19453 "\n"
19454 " Writes text at a specified position and inclination and with a\n"
19455 " specified shear within the viewport. Text is clipped at the viewport\n"
19456 " boundaries. The reference point of a string lies along a line passing\n"
19457 " through the string at half the height of a capital letter. The\n"
19458 " position of the reference point along this line is determined by just,\n"
19459 " and the reference point is placed at world coordinates (\n"
19460 " wx,\n"
19461 " wy,\n"
19462 " wz) within the viewport. The inclination and shear of the string is\n"
19463 " specified in terms of differences of world coordinates making it easy\n"
19464 " to write text parallel to a line in a graph.\n"
19465 "\n"
19466 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19467 "\n"
19468 " This function is used in example 28.\n"
19469 "\n"
19470 "\n"
19471 "\n"
19472 "SYNOPSIS:\n"
19473 "\n"
19474 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19475 "\n"
19476 "ARGUMENTS:\n"
19477 "\n"
19478 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19479 " string.\n"
19480 "\n"
19481 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19482 " string.\n"
19483 "\n"
19484 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19485 " string.\n"
19486 "\n"
19487 " dx (PLFLT, input) : Together with dy and\n"
19488 " dz , this specifies the inclination of the string. The baseline of\n"
19489 " the string is parallel to a line joining (\n"
19490 " x,\n"
19491 " y,\n"
19492 " z) to (\n"
19493 " x+\n"
19494 " dx,\n"
19495 " y+\n"
19496 " dy,\n"
19497 " z+\n"
19498 " dz) .\n"
19499 "\n"
19500 " dy (PLFLT, input) : Together with dx and\n"
19501 " dz, this specifies the inclination of the string.\n"
19502 "\n"
19503 " dz (PLFLT, input) : Together with dx and\n"
19504 " dy, this specifies the inclination of the string.\n"
19505 "\n"
19506 " sx (PLFLT, input) : Together with sy and\n"
19507 " sz , this specifies the shear of the string. The string is sheared so\n"
19508 " that the characters are vertically parallel to a line joining (\n"
19509 " x,\n"
19510 " y,\n"
19511 " z) to (\n"
19512 " x+\n"
19513 " sx,\n"
19514 " y+\n"
19515 " sy,\n"
19516 " z+\n"
19517 " sz) . If sx =\n"
19518 " sy =\n"
19519 " sz = 0.) then the text is not sheared.\n"
19520 "\n"
19521 " sy (PLFLT, input) : Together with sx and\n"
19522 " sz, this specifies shear of the string.\n"
19523 "\n"
19524 " sz (PLFLT, input) : Together with sx and\n"
19525 " sy, this specifies shear of the string.\n"
19526 "\n"
19527 " just (PLFLT, input) : Specifies the position of the string relative\n"
19528 " to its reference point. If just=0. , the reference point is at\n"
19529 " the left and if just=1. , it is at the right of the string. Other\n"
19530 " values of just give intermediate justifications.\n"
19531 "\n"
19532 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19533 " written out.\n"
19534 "\n"
19535 ""},
19536 { "plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
19537 "Random number generator returning a real random number in the range [0,1]\n"
19538 "\n"
19539 "DESCRIPTION:\n"
19540 "\n"
19541 " Random number generator returning a real random number in the range\n"
19542 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19543 " / compilers provide their own random number generator, and so this is\n"
19544 " provided purely for convenience and to give a consistent random number\n"
19545 " generator across all languages supported by PLplot. This is\n"
19546 " particularly useful for comparing results from the test suite of\n"
19547 " examples.\n"
19548 "\n"
19549 " Redacted form: plrandd()\n"
19550 "\n"
19551 " This function is used in examples 17 and 21.\n"
19552 "\n"
19553 "\n"
19554 "\n"
19555 "SYNOPSIS:\n"
19556 "\n"
19557 "plrandd()\n"
19558 "\n"
19559 ""},
19560 { "plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
19561 "Replays contents of plot buffer to current device/file\n"
19562 "\n"
19563 "DESCRIPTION:\n"
19564 "\n"
19565 " Replays contents of plot buffer to current device/file.\n"
19566 "\n"
19567 " Redacted form: plreplot()\n"
19568 "\n"
19569 " This function is used in example 1,20.\n"
19570 "\n"
19571 "\n"
19572 "\n"
19573 "SYNOPSIS:\n"
19574 "\n"
19575 "plreplot()\n"
19576 "\n"
19577 ""},
19578 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
19579 "Convert RGB color to HLS\n"
19580 "\n"
19581 "DESCRIPTION:\n"
19582 "\n"
19583 " Convert RGB color coordinates to HLS\n"
19584 "\n"
19585 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19586 "\n"
19587 "\n"
19588 " This function is used in example 2.\n"
19589 "\n"
19590 "\n"
19591 "\n"
19592 "SYNOPSIS:\n"
19593 "\n"
19594 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19595 "\n"
19596 "ARGUMENTS:\n"
19597 "\n"
19598 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19599 "\n"
19600 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19601 "\n"
19602 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19603 "\n"
19604 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19605 " degrees (0.0-360.0) on the color cylinder.\n"
19606 "\n"
19607 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19608 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19609 " cylinder.\n"
19610 "\n"
19611 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19612 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19613 " cylinder.\n"
19614 "\n"
19615 ""},
19616 { "plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
19617 "Set character size\n"
19618 "\n"
19619 "DESCRIPTION:\n"
19620 "\n"
19621 " This sets up the size of all subsequent characters drawn. The actual\n"
19622 " height of a character is the product of the default character size and\n"
19623 " a scaling factor.\n"
19624 "\n"
19625 " Redacted form: plschr(def, scale)\n"
19626 "\n"
19627 " This function is used in examples 2, 13, 23, and 24.\n"
19628 "\n"
19629 "\n"
19630 "\n"
19631 "SYNOPSIS:\n"
19632 "\n"
19633 "plschr(def, scale)\n"
19634 "\n"
19635 "ARGUMENTS:\n"
19636 "\n"
19637 " def (PLFLT, input) : The default height of a character in\n"
19638 " millimeters, should be set to zero if the default height is to\n"
19639 " remain unchanged. For rasterized drivers the dx and dy values\n"
19640 " specified in plspage are used to convert from mm to pixels (note\n"
19641 " the different unit systems used). This dpi aware scaling is not\n"
19642 " implemented for all drivers yet.\n"
19643 "\n"
19644 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19645 " actual character height.\n"
19646 "\n"
19647 ""},
19648 { "plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
19649 "Set cmap0 colors by 8-bit RGB values\n"
19650 "\n"
19651 "DESCRIPTION:\n"
19652 "\n"
19653 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19654 " documentation). This sets the entire color map -- only as many colors\n"
19655 " as specified will be allocated.\n"
19656 "\n"
19657 " Redacted form: plscmap0(r, g, b)\n"
19658 "\n"
19659 " This function is used in examples 2 and 24.\n"
19660 "\n"
19661 "\n"
19662 "\n"
19663 "SYNOPSIS:\n"
19664 "\n"
19665 "plscmap0(r, g, b, ncol0)\n"
19666 "\n"
19667 "ARGUMENTS:\n"
19668 "\n"
19669 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19670 " integers (0-255) representing the degree of red in the color.\n"
19671 "\n"
19672 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19673 " integers (0-255) representing the degree of green in the color.\n"
19674 "\n"
19675 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19676 " integers (0-255) representing the degree of blue in the color.\n"
19677 "\n"
19678 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19679 "\n"
19680 ""},
19681 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
19682 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19683 "\n"
19684 "DESCRIPTION:\n"
19685 "\n"
19686 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19687 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19688 " only as many colors as specified will be allocated.\n"
19689 "\n"
19690 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19691 "\n"
19692 " This function is used in examples 30.\n"
19693 "\n"
19694 "\n"
19695 "\n"
19696 "SYNOPSIS:\n"
19697 "\n"
19698 "plscmap0a(r, g, b, alpha, ncol0)\n"
19699 "\n"
19700 "ARGUMENTS:\n"
19701 "\n"
19702 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19703 " integers (0-255) representing the degree of red in the color.\n"
19704 "\n"
19705 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19706 " integers (0-255) representing the degree of green in the color.\n"
19707 "\n"
19708 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19709 " integers (0-255) representing the degree of blue in the color.\n"
19710 "\n"
19711 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19712 " representing the alpha transparency of the color.\n"
19713 "\n"
19714 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19715 " vectors.\n"
19716 "\n"
19717 ""},
19718 { "plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
19719 "Set number of colors in cmap0\n"
19720 "\n"
19721 "DESCRIPTION:\n"
19722 "\n"
19723 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19724 " (or reallocate) cmap0, and fill with default values for those colors\n"
19725 " not previously allocated. The first 16 default colors are given in\n"
19726 " the plcol0 documentation. For larger indices the default color is\n"
19727 " red.\n"
19728 "\n"
19729 " The drivers are not guaranteed to support more than 16 colors.\n"
19730 "\n"
19731 " Redacted form: plscmap0n(ncol0)\n"
19732 "\n"
19733 " This function is used in examples 15, 16, and 24.\n"
19734 "\n"
19735 "\n"
19736 "\n"
19737 "SYNOPSIS:\n"
19738 "\n"
19739 "plscmap0n(ncol0)\n"
19740 "\n"
19741 "ARGUMENTS:\n"
19742 "\n"
19743 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19744 " the cmap0 palette. If this number is zero or less, then the value\n"
19745 " from the previous call to plscmap0n is used and if there is no\n"
19746 " previous call, then a default value is used.\n"
19747 "\n"
19748 ""},
19749 { "plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19750 "Set opaque RGB cmap1 colors values\n"
19751 "\n"
19752 "DESCRIPTION:\n"
19753 "\n"
19754 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19755 " vector values. This function also sets the number of cmap1 colors.\n"
19756 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19757 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19758 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19759 " to\n"
19760 " ncol1-1. So in order for this continuous color model to work\n"
19761 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19762 " that these RGB vectors are continuous functions of their integer\n"
19763 " indices.\n"
19764 "\n"
19765 " Redacted form: plscmap1(r, g, b)\n"
19766 "\n"
19767 " This function is used in example 31.\n"
19768 "\n"
19769 "\n"
19770 "\n"
19771 "SYNOPSIS:\n"
19772 "\n"
19773 "plscmap1(r, g, b, ncol1)\n"
19774 "\n"
19775 "ARGUMENTS:\n"
19776 "\n"
19777 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19778 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19779 " color as a continuous function of the integer index of the vector.\n"
19780 "\n"
19781 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19782 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19783 " color as a continuous function of the integer index of the vector.\n"
19784 "\n"
19785 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19786 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19787 " color as a continuous function of the integer index of the vector.\n"
19788 "\n"
19789 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19790 "\n"
19791 ""},
19792 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19793 "Set semitransparent cmap1 RGBA colors.\n"
19794 "\n"
19795 "DESCRIPTION:\n"
19796 "\n"
19797 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19798 " RGBA vector values. This function also sets the number of cmap1\n"
19799 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19800 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19801 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19802 " vectors in the range from 0 to\n"
19803 " ncol1-1. So in order for this continuous color model to work\n"
19804 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19805 " that these RGBA vectors are continuous functions of their integer\n"
19806 " indices.\n"
19807 "\n"
19808 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19809 "\n"
19810 " This function is used in example 31.\n"
19811 "\n"
19812 "\n"
19813 "\n"
19814 "SYNOPSIS:\n"
19815 "\n"
19816 "plscmap1a(r, g, b, alpha, ncol1)\n"
19817 "\n"
19818 "ARGUMENTS:\n"
19819 "\n"
19820 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19821 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19822 " color as a continuous function of the integer index of the vector.\n"
19823 "\n"
19824 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19825 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19826 " color as a continuous function of the integer index of the vector.\n"
19827 "\n"
19828 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19829 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19830 " color as a continuous function of the integer index of the vector.\n"
19831 "\n"
19832 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19833 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19834 " completely transparent and 1.0 corresponds to completely opaque)\n"
19835 " the alpha transparency of the color as a continuous function of\n"
19836 " the integer index of the vector.\n"
19837 "\n"
19838 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19839 " vectors.\n"
19840 "\n"
19841 ""},
19842 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19843 "Set cmap1 colors using a piece-wise linear relationship\n"
19844 "\n"
19845 "DESCRIPTION:\n"
19846 "\n"
19847 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19848 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19849 " (see the PLplot documentation). May be called at any time.\n"
19850 "\n"
19851 " The idea here is to specify a number of control points that define the\n"
19852 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19853 " these points, linear interpolation is used which gives a smooth\n"
19854 " variation of color with intensity index. Any number of control points\n"
19855 " may be specified, located at arbitrary positions, although typically 2\n"
19856 " - 4 are enough. Another way of stating this is that we are traversing\n"
19857 " a given number of lines through HLS or RGB space as we move through\n"
19858 " cmap1 intensity indices. The control points at the minimum and\n"
19859 " maximum position (0 and 1) must always be specified. By adding more\n"
19860 " control points you can get more variation. One good technique for\n"
19861 " plotting functions that vary about some expected average is to use an\n"
19862 " additional 2 control points in the center (position ~= 0.5) that are\n"
19863 " the same lightness as the background (typically white for paper\n"
19864 " output, black for crt), and same hue as the boundary control points.\n"
19865 " This allows the highs and lows to be very easily distinguished.\n"
19866 "\n"
19867 " Each control point must specify the cmap1 intensity index and the\n"
19868 " associated three coordinates in HLS or RGB space. The first point\n"
19869 " must correspond to position = 0, and the last to position = 1.\n"
19870 "\n"
19871 " If RGB colors are provided then the interpolation takes place in RGB\n"
19872 " space and is trivial. However if HLS colors are provided then, because\n"
19873 " of the circular nature of the color wheel for the hue coordinate, the\n"
19874 " interpolation could be performed in either direction around the color\n"
19875 " wheel. The default behaviour is for the hue to be linearly\n"
19876 " interpolated ignoring this circular property of hue. So for example,\n"
19877 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19878 " green and cyan. If instead you wish to interpolate the other way\n"
19879 " around the color wheel you have two options. You may provide hues\n"
19880 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19881 " for red the interpolation will proceed via magenta. Alternatively you\n"
19882 " can utilise the alt_hue_path variable to reverse the direction of\n"
19883 " interpolation if you need to provide hues within the [0-360) range.\n"
19884 "\n"
19885 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19886 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19887 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19888 " 480]falseblue-magenta-red-yellow-green[120\n"
19889 " 240]truegreen-yellow-red-magenta-blue[240\n"
19890 " 120]trueblue-magenta-red-yellow-green\n"
19891 "\n"
19892 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19893 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19894 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19895 "\n"
19896 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19897 " alt_hue_path)\n"
19898 "\n"
19899 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19900 "\n"
19901 "\n"
19902 "\n"
19903 "SYNOPSIS:\n"
19904 "\n"
19905 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19906 "\n"
19907 "ARGUMENTS:\n"
19908 "\n"
19909 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19910 "\n"
19911 " npts (PLINT, input) : number of control points\n"
19912 "\n"
19913 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19914 " intensity index (0.0-1.0) in ascending order for each control\n"
19915 " point.\n"
19916 "\n"
19917 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19918 " coordinate (H or R) for each control point.\n"
19919 "\n"
19920 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19921 " coordinate (L or G) for each control point.\n"
19922 "\n"
19923 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19924 " coordinate (S or B) for each control point.\n"
19925 "\n"
19926 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19927 " npts - 1 elements), each containing either true to use the reversed\n"
19928 " HLS interpolation or false to use the regular HLS interpolation.\n"
19929 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19930 " i and i + 1 control points). This parameter is not used for RGB\n"
19931 " colors (\n"
19932 " itype = true).\n"
19933 "\n"
19934 ""},
19935 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19936 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19937 "\n"
19938 "DESCRIPTION:\n"
19939 "\n"
19940 " This is a variant of plscmap1l that supports alpha channel\n"
19941 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19942 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19943 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19944 " transparency value (0.0-1.0). It may be called at any time.\n"
19945 "\n"
19946 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19947 " alpha, alt_hue_path)\n"
19948 "\n"
19949 " This function is used in example 30.\n"
19950 "\n"
19951 "\n"
19952 "\n"
19953 "SYNOPSIS:\n"
19954 "\n"
19955 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19956 "\n"
19957 "ARGUMENTS:\n"
19958 "\n"
19959 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19960 "\n"
19961 " npts (PLINT, input) : number of control points.\n"
19962 "\n"
19963 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19964 " intensity index (0.0-1.0) in ascending order for each control\n"
19965 " point.\n"
19966 "\n"
19967 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19968 " coordinate (H or R) for each control point.\n"
19969 "\n"
19970 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19971 " coordinate (L or G) for each control point.\n"
19972 "\n"
19973 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19974 " coordinate (S or B) for each control point.\n"
19975 "\n"
19976 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19977 " transparency value (0.0-1.0) for each control point.\n"
19978 "\n"
19979 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19980 " npts - 1 elements) containing the alternative interpolation method\n"
19981 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19982 " refers to the interpolation interval between the i and i + 1\n"
19983 " control points).\n"
19984 "\n"
19985 ""},
19986 { "plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19987 "Set number of colors in cmap1\n"
19988 "\n"
19989 "DESCRIPTION:\n"
19990 "\n"
19991 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19992 " values if this is the first allocation (see the PLplot documentation).\n"
19993 "\n"
19994 " Redacted form: plscmap1n(ncol1)\n"
19995 "\n"
19996 " This function is used in examples 8, 11, 20, and 21.\n"
19997 "\n"
19998 "\n"
19999 "\n"
20000 "SYNOPSIS:\n"
20001 "\n"
20002 "plscmap1n(ncol1)\n"
20003 "\n"
20004 "ARGUMENTS:\n"
20005 "\n"
20006 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20007 " the cmap1 palette. If this number is zero or less, then the value\n"
20008 " from the previous call to plscmap1n is used and if there is no\n"
20009 " previous call, then a default value is used.\n"
20010 "\n"
20011 ""},
20012 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
20013 "Set the cmap1 argument range for continuous color plots\n"
20014 "\n"
20015 "DESCRIPTION:\n"
20016 "\n"
20017 " Set the cmap1 argument range for continuous color plots that\n"
20018 " corresponds to the range of data values. The maximum range\n"
20019 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20020 " the cmap1 argument range that is specified with this routine, the\n"
20021 " smaller the subset of the cmap1 color palette that is used to\n"
20022 " represent the continuous data being plotted. If\n"
20023 " min_color is greater than\n"
20024 " max_color or\n"
20025 " max_color is greater than 1.0 or\n"
20026 " min_color is less than 0.0 then no change is made to the cmap1\n"
20027 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20028 "\n"
20029 " Redacted form: plscmap1_range(min_color, max_color)\n"
20030 "\n"
20031 " This function is currently used in example 33.\n"
20032 "\n"
20033 "\n"
20034 "\n"
20035 "SYNOPSIS:\n"
20036 "\n"
20037 "plscmap1_range(min_color, max_color)\n"
20038 "\n"
20039 "ARGUMENTS:\n"
20040 "\n"
20041 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20042 " than 0.0, then 0.0 is used instead.\n"
20043 "\n"
20044 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20045 " than 1.0, then 1.0 is used instead.\n"
20046 "\n"
20047 ""},
20048 { "plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
20049 "Get the cmap1 argument range for continuous color plots\n"
20050 "\n"
20051 "DESCRIPTION:\n"
20052 "\n"
20053 " Get the cmap1 argument range for continuous color plots. (Use\n"
20054 " plscmap1_range to set the cmap1 argument range.)\n"
20055 "\n"
20056 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20057 "\n"
20058 " This function is currently not used in any example.\n"
20059 "\n"
20060 "\n"
20061 "\n"
20062 "SYNOPSIS:\n"
20063 "\n"
20064 "plgcmap1_range(min_color, max_color)\n"
20065 "\n"
20066 "ARGUMENTS:\n"
20067 "\n"
20068 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20069 " minimum cmap1 argument.\n"
20070 "\n"
20071 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20072 " maximum cmap1 argument.\n"
20073 "\n"
20074 ""},
20075 { "plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
20076 "Set 8-bit RGB values for given cmap0 color index\n"
20077 "\n"
20078 "DESCRIPTION:\n"
20079 "\n"
20080 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20081 " index. Overwrites the previous color value for the given index and,\n"
20082 " thus, does not result in any additional allocation of space for\n"
20083 " colors.\n"
20084 "\n"
20085 " Redacted form: plscol0(icol0, r, g, b)\n"
20086 "\n"
20087 " This function is used in any example 31.\n"
20088 "\n"
20089 "\n"
20090 "\n"
20091 "SYNOPSIS:\n"
20092 "\n"
20093 "plscol0(icol0, r, g, b)\n"
20094 "\n"
20095 "ARGUMENTS:\n"
20096 "\n"
20097 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20098 " number of colors (which is set by default, by plscmap0n, or even\n"
20099 " by plscmap0).\n"
20100 "\n"
20101 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20102 " degree of red in the color.\n"
20103 "\n"
20104 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20105 " degree of green in the color.\n"
20106 "\n"
20107 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20108 " degree of blue in the color.\n"
20109 "\n"
20110 ""},
20111 { "plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
20112 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20113 "\n"
20114 "DESCRIPTION:\n"
20115 "\n"
20116 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20117 " (see the PLplot documentation) index. Overwrites the previous color\n"
20118 " value for the given index and, thus, does not result in any additional\n"
20119 " allocation of space for colors.\n"
20120 "\n"
20121 " This function is used in example 30.\n"
20122 "\n"
20123 "\n"
20124 "\n"
20125 "SYNOPSIS:\n"
20126 "\n"
20127 "plscol0a(icol0, r, g, b, alpha)\n"
20128 "\n"
20129 "ARGUMENTS:\n"
20130 "\n"
20131 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20132 " number of colors (which is set by default, by plscmap0n, or even\n"
20133 " by plscmap0).\n"
20134 "\n"
20135 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20136 " degree of red in the color.\n"
20137 "\n"
20138 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20139 " degree of green in the color.\n"
20140 "\n"
20141 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20142 " degree of blue in the color.\n"
20143 "\n"
20144 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20145 " (0.0-1.0).\n"
20146 "\n"
20147 ""},
20148 { "plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
20149 "Set the background color by 8-bit RGB value\n"
20150 "\n"
20151 "DESCRIPTION:\n"
20152 "\n"
20153 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20154 " the PLplot documentation).\n"
20155 "\n"
20156 " Redacted form: plscolbg(r, g, b)\n"
20157 "\n"
20158 " This function is used in examples 15 and 31.\n"
20159 "\n"
20160 "\n"
20161 "\n"
20162 "SYNOPSIS:\n"
20163 "\n"
20164 "plscolbg(r, g, b)\n"
20165 "\n"
20166 "ARGUMENTS:\n"
20167 "\n"
20168 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20169 " degree of red in the color.\n"
20170 "\n"
20171 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20172 " degree of green in the color.\n"
20173 "\n"
20174 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20175 " degree of blue in the color.\n"
20176 "\n"
20177 ""},
20178 { "plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
20179 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20180 "\n"
20181 "DESCRIPTION:\n"
20182 "\n"
20183 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20184 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20185 "\n"
20186 " This function is used in example 31.\n"
20187 "\n"
20188 "\n"
20189 "\n"
20190 "SYNOPSIS:\n"
20191 "\n"
20192 "plscolbga(r, g, b, alpha)\n"
20193 "\n"
20194 "ARGUMENTS:\n"
20195 "\n"
20196 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20197 " degree of red in the color.\n"
20198 "\n"
20199 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20200 " degree of green in the color.\n"
20201 "\n"
20202 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20203 " degree of blue in the color.\n"
20204 "\n"
20205 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20206 " (0.0-1.0).\n"
20207 "\n"
20208 ""},
20209 { "plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
20210 "Used to globally turn color output on/off\n"
20211 "\n"
20212 "DESCRIPTION:\n"
20213 "\n"
20214 " Used to globally turn color output on/off for those drivers/devices\n"
20215 " that support it.\n"
20216 "\n"
20217 " Redacted form: plscolor(color)\n"
20218 "\n"
20219 " This function is used in example 31.\n"
20220 "\n"
20221 "\n"
20222 "\n"
20223 "SYNOPSIS:\n"
20224 "\n"
20225 "plscolor(color)\n"
20226 "\n"
20227 "ARGUMENTS:\n"
20228 "\n"
20229 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20230 " turned off. If non-zero, color is turned on.\n"
20231 "\n"
20232 ""},
20233 { "plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
20234 "Set device-compression level\n"
20235 "\n"
20236 "DESCRIPTION:\n"
20237 "\n"
20238 " Set device-compression level. Only used for drivers that provide\n"
20239 " compression. This function, if used, should be invoked before a call\n"
20240 " to plinit.\n"
20241 "\n"
20242 " Redacted form: plscompression(compression)\n"
20243 "\n"
20244 " This function is used in example 31.\n"
20245 "\n"
20246 "\n"
20247 "\n"
20248 "SYNOPSIS:\n"
20249 "\n"
20250 "plscompression(compression)\n"
20251 "\n"
20252 "ARGUMENTS:\n"
20253 "\n"
20254 " compression (PLINT, input) : The desired compression level. This is\n"
20255 " a device-dependent value. Currently only the jpeg and png devices\n"
20256 " use these values. For jpeg value is the jpeg quality which should\n"
20257 " normally be in the range 0-95. Higher values denote higher quality\n"
20258 " and hence larger image sizes. For png values are in the range -1\n"
20259 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20260 " A value of -1 denotes the default zlib compression level. Values\n"
20261 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20262 " compression level. Higher compression levels correspond to greater\n"
20263 " compression and small file sizes at the expense of more\n"
20264 " computation.\n"
20265 "\n"
20266 ""},
20267 { "plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
20268 "Set the device (keyword) name\n"
20269 "\n"
20270 "DESCRIPTION:\n"
20271 "\n"
20272 " Set the device (keyword) name.\n"
20273 "\n"
20274 " Redacted form: plsdev(devname)\n"
20275 "\n"
20276 " This function is used in examples 1, 14, and 20.\n"
20277 "\n"
20278 "\n"
20279 "\n"
20280 "SYNOPSIS:\n"
20281 "\n"
20282 "plsdev(devname)\n"
20283 "\n"
20284 "ARGUMENTS:\n"
20285 "\n"
20286 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20287 " containing the device name keyword of the required output device.\n"
20288 " If\n"
20289 " devname is NULL or if the first character of the string is a ``?'',\n"
20290 " the normal (prompted) start up is used.\n"
20291 "\n"
20292 ""},
20293 { "plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
20294 "Set parameters that define current device-space window\n"
20295 "\n"
20296 "DESCRIPTION:\n"
20297 "\n"
20298 " Set relative margin width, aspect ratio, and relative justification\n"
20299 " that define current device-space window. If you want to just use the\n"
20300 " previous value for any of these, just pass in the magic value\n"
20301 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20302 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20303 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20304 " to a device-specific value.\n"
20305 "\n"
20306 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20307 "\n"
20308 " This function is used in example 31.\n"
20309 "\n"
20310 "\n"
20311 "\n"
20312 "SYNOPSIS:\n"
20313 "\n"
20314 "plsdidev(mar, aspect, jx, jy)\n"
20315 "\n"
20316 "ARGUMENTS:\n"
20317 "\n"
20318 " mar (PLFLT, input) : Relative margin width.\n"
20319 "\n"
20320 " aspect (PLFLT, input) : Aspect ratio.\n"
20321 "\n"
20322 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20323 " the range -0.5 to 0.5.\n"
20324 "\n"
20325 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20326 " the range -0.5 to 0.5.\n"
20327 "\n"
20328 ""},
20329 { "plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
20330 "Set up transformation from metafile coordinates\n"
20331 "\n"
20332 "DESCRIPTION:\n"
20333 "\n"
20334 " Set up transformation from metafile coordinates. The size of the plot\n"
20335 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20336 " general-purpose facility just yet (not sure why the user would need\n"
20337 " it, for one).\n"
20338 "\n"
20339 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20340 " dimypmm)\n"
20341 "\n"
20342 " This function is not used in any examples.\n"
20343 "\n"
20344 "\n"
20345 "\n"
20346 "SYNOPSIS:\n"
20347 "\n"
20348 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20349 "\n"
20350 "ARGUMENTS:\n"
20351 "\n"
20352 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20353 "\n"
20354 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20355 "\n"
20356 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20357 "\n"
20358 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20359 "\n"
20360 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20361 "\n"
20362 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20363 "\n"
20364 ""},
20365 { "plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
20366 "Set plot orientation\n"
20367 "\n"
20368 "DESCRIPTION:\n"
20369 "\n"
20370 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20371 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20372 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20373 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20374 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20375 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20376 " not called the default value of rot is 0.\n"
20377 "\n"
20378 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20379 " probably want to change the aspect ratio to a value suitable for the\n"
20380 " plot orientation using a call to plsdidev or the command-line options\n"
20381 " -a or -freeaspect. For more documentation of those options see the\n"
20382 " PLplot documentation. Such command-line options can be set internally\n"
20383 " using plsetopt or set directly using the command line and parsed using\n"
20384 " a call to plparseopts.\n"
20385 "\n"
20386 " Redacted form: plsdiori(rot)\n"
20387 "\n"
20388 " This function is not used in any examples.\n"
20389 "\n"
20390 "\n"
20391 "\n"
20392 "SYNOPSIS:\n"
20393 "\n"
20394 "plsdiori(rot)\n"
20395 "\n"
20396 "ARGUMENTS:\n"
20397 "\n"
20398 " rot (PLFLT, input) : Plot orientation parameter.\n"
20399 "\n"
20400 ""},
20401 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
20402 "Set parameters that define current plot-space window\n"
20403 "\n"
20404 "DESCRIPTION:\n"
20405 "\n"
20406 " Set relative minima and maxima that define the current plot-space\n"
20407 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20408 " xmax, and ymax are 0., 0., 1., and 1.\n"
20409 "\n"
20410 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20411 "\n"
20412 " This function is used in example 31.\n"
20413 "\n"
20414 "\n"
20415 "\n"
20416 "SYNOPSIS:\n"
20417 "\n"
20418 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20419 "\n"
20420 "ARGUMENTS:\n"
20421 "\n"
20422 " xmin (PLFLT, input) : Relative minimum in x.\n"
20423 "\n"
20424 " ymin (PLFLT, input) : Relative minimum in y.\n"
20425 "\n"
20426 " xmax (PLFLT, input) : Relative maximum in x.\n"
20427 "\n"
20428 " ymax (PLFLT, input) : Relative maximum in y.\n"
20429 "\n"
20430 ""},
20431 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
20432 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20433 "\n"
20434 "DESCRIPTION:\n"
20435 "\n"
20436 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20437 " the current plot-space window. This function has the same effect as\n"
20438 " plsdiplt if that function has not been previously called. Otherwise,\n"
20439 " this function implements zoom mode using the transformation min_used =\n"
20440 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20441 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20442 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20443 "\n"
20444 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20445 "\n"
20446 " This function is used in example 31.\n"
20447 "\n"
20448 "\n"
20449 "\n"
20450 "SYNOPSIS:\n"
20451 "\n"
20452 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20453 "\n"
20454 "ARGUMENTS:\n"
20455 "\n"
20456 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20457 "\n"
20458 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20459 "\n"
20460 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20461 "\n"
20462 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20463 "\n"
20464 ""},
20465 { "plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
20466 "Set seed for internal random number generator.\n"
20467 "\n"
20468 "DESCRIPTION:\n"
20469 "\n"
20470 " Set the seed for the internal random number generator. See plrandd for\n"
20471 " further details.\n"
20472 "\n"
20473 " Redacted form: plseed(seed)\n"
20474 "\n"
20475 " This function is used in example 21.\n"
20476 "\n"
20477 "\n"
20478 "\n"
20479 "SYNOPSIS:\n"
20480 "\n"
20481 "plseed(seed)\n"
20482 "\n"
20483 "ARGUMENTS:\n"
20484 "\n"
20485 " seed (unsigned int, input) : Seed for random number generator.\n"
20486 "\n"
20487 ""},
20488 { "plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
20489 "Set the escape character for text strings\n"
20490 "\n"
20491 "DESCRIPTION:\n"
20492 "\n"
20493 " Set the escape character for text strings. From C (in contrast to\n"
20494 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20495 " characters are allowed to prevent the user from shooting himself in\n"
20496 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20497 " use of backslash as a character escape). Here are the allowed escape\n"
20498 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20499 " #, ASCII 35\n"
20500 " $, ASCII 36\n"
20501 " %, ASCII 37\n"
20502 " &, ASCII 38\n"
20503 " *, ASCII 42\n"
20504 " @, ASCII 64\n"
20505 " ^, ASCII 94\n"
20506 " ~, ASCII 126\n"
20507 "\n"
20508 "\n"
20509 " Redacted form: General: plsesc(esc)\n"
20510 "\n"
20511 "\n"
20512 " This function is used in example 29.\n"
20513 "\n"
20514 "\n"
20515 "\n"
20516 "SYNOPSIS:\n"
20517 "\n"
20518 "plsesc(esc)\n"
20519 "\n"
20520 "ARGUMENTS:\n"
20521 "\n"
20522 " esc (char, input) : Escape character.\n"
20523 "\n"
20524 ""},
20525 { "plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
20526 "Set any command-line option\n"
20527 "\n"
20528 "DESCRIPTION:\n"
20529 "\n"
20530 " Set any command-line option internally from a program before it\n"
20531 " invokes plinit. opt is the name of the command-line option and optarg\n"
20532 " is the corresponding command-line option argument.\n"
20533 "\n"
20534 " This function returns 0 on success.\n"
20535 "\n"
20536 " Redacted form: plsetopt(opt, optarg)\n"
20537 "\n"
20538 " This function is used in example 14.\n"
20539 "\n"
20540 "\n"
20541 "\n"
20542 "SYNOPSIS:\n"
20543 "\n"
20544 "PLINT plsetopt(opt, optarg)\n"
20545 "\n"
20546 "ARGUMENTS:\n"
20547 "\n"
20548 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20549 " the command-line option.\n"
20550 "\n"
20551 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20552 " containing the argument of the command-line option.\n"
20553 "\n"
20554 ""},
20555 { "plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
20556 "Set family file parameters\n"
20557 "\n"
20558 "DESCRIPTION:\n"
20559 "\n"
20560 " Sets variables dealing with output file familying. Does nothing if\n"
20561 " familying not supported by the driver. This routine, if used, must be\n"
20562 " called before initializing PLplot. See the PLplot documentation for\n"
20563 " more information.\n"
20564 "\n"
20565 " Redacted form: plsfam(fam, num, bmax)\n"
20566 "\n"
20567 " This function is used in examples 14 and 31.\n"
20568 "\n"
20569 "\n"
20570 "\n"
20571 "SYNOPSIS:\n"
20572 "\n"
20573 "plsfam(fam, num, bmax)\n"
20574 "\n"
20575 "ARGUMENTS:\n"
20576 "\n"
20577 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20578 " is enabled.\n"
20579 "\n"
20580 " num (PLINT, input) : Current family file number.\n"
20581 "\n"
20582 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20583 " file.\n"
20584 "\n"
20585 ""},
20586 { "plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
20587 "Set FCI (font characterization integer)\n"
20588 "\n"
20589 "DESCRIPTION:\n"
20590 "\n"
20591 " Sets font characteristics to be used at the start of the next string\n"
20592 " using the FCI approach. See the PLplot documentation for more\n"
20593 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20594 " more user-friendly API for setting the font characterisitics.\n"
20595 "\n"
20596 " Redacted form: General: plsfci(fci)\n"
20597 "\n"
20598 "\n"
20599 " This function is used in example 23.\n"
20600 "\n"
20601 "\n"
20602 "\n"
20603 "SYNOPSIS:\n"
20604 "\n"
20605 "plsfci(fci)\n"
20606 "\n"
20607 "ARGUMENTS:\n"
20608 "\n"
20609 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20610 " of FCI.\n"
20611 "\n"
20612 ""},
20613 { "plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
20614 "Set output file name\n"
20615 "\n"
20616 "DESCRIPTION:\n"
20617 "\n"
20618 " Sets the current output file name, if applicable. If the file name\n"
20619 " has not been specified and is required by the driver, the user will be\n"
20620 " prompted for it. If using the X-windows output driver, this sets the\n"
20621 " display name. This routine, if used, must be called before\n"
20622 " initializing PLplot.\n"
20623 "\n"
20624 " Redacted form: plsfnam(fnam)\n"
20625 "\n"
20626 " This function is used in examples 1 and 20.\n"
20627 "\n"
20628 "\n"
20629 "\n"
20630 "SYNOPSIS:\n"
20631 "\n"
20632 "plsfnam(fnam)\n"
20633 "\n"
20634 "ARGUMENTS:\n"
20635 "\n"
20636 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20637 " the file name.\n"
20638 "\n"
20639 ""},
20640 { "plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
20641 "Set family, style and weight of the current font\n"
20642 "\n"
20643 "DESCRIPTION:\n"
20644 "\n"
20645 " Sets the current font. See the PLplot documentation for more\n"
20646 " information on font selection.\n"
20647 "\n"
20648 " Redacted form: plsfont(family, style, weight)\n"
20649 "\n"
20650 " This function is used in example 23.\n"
20651 "\n"
20652 "\n"
20653 "\n"
20654 "SYNOPSIS:\n"
20655 "\n"
20656 "plsfont(family, style, weight)\n"
20657 "\n"
20658 "ARGUMENTS:\n"
20659 "\n"
20660 " family (PLINT, input) : Font family to select for the current font.\n"
20661 " The available values are given by the PL_FCI_* constants in\n"
20662 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20663 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20664 " signifies that the font family should not be altered.\n"
20665 "\n"
20666 " style (PLINT, input) : Font style to select for the current font.\n"
20667 " The available values are given by the PL_FCI_* constants in\n"
20668 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20669 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20670 " should not be altered.\n"
20671 "\n"
20672 " weight (PLINT, input) : Font weight to select for the current font.\n"
20673 " The available values are given by the PL_FCI_* constants in\n"
20674 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20675 " negative value signifies that the font weight should not be\n"
20676 " altered.\n"
20677 "\n"
20678 ""},
20679 { "plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
20680 "Shade regions on the basis of value\n"
20681 "\n"
20682 "DESCRIPTION:\n"
20683 "\n"
20684 " Shade regions on the basis of value. This is the high-level routine\n"
20685 " for making continuous color shaded plots with cmap1 while plshade\n"
20686 " should be used to plot individual shaded regions using either cmap0 or\n"
20687 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20688 " our supported languages.\n"
20689 "\n"
20690 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20691 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20692 " pltr_data)\n"
20693 "\n"
20694 "\n"
20695 " This function is used in examples 16, 21, and 22.\n"
20696 "\n"
20697 "\n"
20698 "\n"
20699 "SYNOPSIS:\n"
20700 "\n"
20701 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20702 "\n"
20703 "ARGUMENTS:\n"
20704 "\n"
20705 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20706 " plot. Should have dimensions of\n"
20707 " nx by\n"
20708 " ny.\n"
20709 "\n"
20710 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20711 "\n"
20712 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20713 "\n"
20714 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20715 " the region that should be plotted in the shade plot. This\n"
20716 " function accepts x and y coordinates as input arguments and must\n"
20717 " return 1 if the point is to be included in the shade plot and 0\n"
20718 " otherwise. If you want to plot the entire shade plot (the usual\n"
20719 " case), this argument should be set to NULL.\n"
20720 "\n"
20721 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20722 " pltr below for how these arguments are used (only for the special case\n"
20723 " when the callback function\n"
20724 " pltr is not supplied).\n"
20725 "\n"
20726 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20727 " corresponding to the edges of each shaded region that will be\n"
20728 " plotted by this function. To work properly the levels should be\n"
20729 " monotonic.\n"
20730 "\n"
20731 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20732 " of shade edge values in clevel).\n"
20733 "\n"
20734 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20735 " pattern.\n"
20736 "\n"
20737 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20738 " contours defining edges of shaded regions. The pen color is only\n"
20739 " temporary set for the contour drawing. Set this value to zero or\n"
20740 " less if no shade edge contours are wanted.\n"
20741 "\n"
20742 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20743 " defining edges of shaded regions. This value may not be honored\n"
20744 " by all drivers. The pen width is only temporary set for the\n"
20745 " contour drawing. Set this value to zero or less if no shade edge\n"
20746 " contours are wanted.\n"
20747 "\n"
20748 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20749 " region. Use plfill for this purpose.\n"
20750 "\n"
20751 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20752 " map to rectangles after coordinate transformation with pltrl.\n"
20753 " Otherwise, set rectangular to false. If rectangular is set to\n"
20754 " true, plshade tries to save time by filling large rectangles.\n"
20755 " This optimization fails if the coordinate transformation distorts\n"
20756 " the shape of rectangles. For example a plot in polar coordinates\n"
20757 " has to have rectangular set to false.\n"
20758 "\n"
20759 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20760 " defines the transformation between the zero-based indices of the\n"
20761 " matrix a and world coordinates. If\n"
20762 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20763 " indices of a are mapped to the range\n"
20764 " xmin through\n"
20765 " xmax and the y indices of a are mapped to the range\n"
20766 " ymin through\n"
20767 " ymax.For the C case, transformation functions are provided in the\n"
20768 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20769 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20770 " matrices. In addition, C callback routines for the transformation\n"
20771 " can be supplied by the user such as the mypltr function in\n"
20772 " examples/c/x09c.c which provides a general linear transformation\n"
20773 " between index coordinates and world coordinates.For languages\n"
20774 " other than C you should consult the PLplot documentation for the\n"
20775 " details concerning how PLTRANSFORM_callback arguments are\n"
20776 " interfaced. However, in general, a particular pattern of\n"
20777 " callback-associated arguments such as a tr vector with 6 elements;\n"
20778 " xg and yg vectors; or xg and yg matrices are respectively\n"
20779 " interfaced to a linear-transformation routine similar to the above\n"
20780 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20781 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20782 " support native language callbacks for handling index to\n"
20783 " world-coordinate transformations. Examples of these various\n"
20784 " approaches are given in examples/<language>x09*,\n"
20785 " examples/<language>x16*, examples/<language>x20*,\n"
20786 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20787 " supported languages.\n"
20788 "\n"
20789 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20790 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20791 " externally supplied.\n"
20792 "\n"
20793 ""},
20794 { "plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20795 "Shade individual region on the basis of value\n"
20796 "\n"
20797 "DESCRIPTION:\n"
20798 "\n"
20799 " Shade individual region on the basis of value. Use plshades if you\n"
20800 " want to shade a number of contiguous regions using continuous colors.\n"
20801 " In particular the edge contours are treated properly in plshades. If\n"
20802 " you attempt to do contiguous regions with plshade the contours at the\n"
20803 " edge of the shade are partially obliterated by subsequent plots of\n"
20804 " contiguous shaded regions.\n"
20805 "\n"
20806 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20807 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20808 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20809 "\n"
20810 "\n"
20811 " This function is used in example 15.\n"
20812 "\n"
20813 "\n"
20814 "\n"
20815 "SYNOPSIS:\n"
20816 "\n"
20817 "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"
20818 "\n"
20819 "ARGUMENTS:\n"
20820 "\n"
20821 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20822 " plot. Should have dimensions of\n"
20823 " nx by\n"
20824 " ny.\n"
20825 "\n"
20826 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20827 "\n"
20828 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20829 "\n"
20830 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20831 " the region that should be plotted in the shade plot. This\n"
20832 " function accepts x and y coordinates as input arguments and must\n"
20833 " return 1 if the point is to be included in the shade plot and 0\n"
20834 " otherwise. If you want to plot the entire shade plot (the usual\n"
20835 " case), this argument should be set to NULL.\n"
20836 "\n"
20837 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20838 " pltr below for how these arguments are used (only for the special case\n"
20839 " when the callback function\n"
20840 " pltr is not supplied).\n"
20841 "\n"
20842 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20843 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20844 "\n"
20845 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20846 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20847 "\n"
20848 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20849 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20850 " then sh_color is interpreted as a cmap1 argument in the range\n"
20851 " (0.0-1.0).\n"
20852 "\n"
20853 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20854 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20855 "\n"
20856 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20857 "\n"
20858 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20859 " boundary of shaded region. The min values are used for the\n"
20860 " shade_min boundary, and the max values are used on the shade_max\n"
20861 " boundary. Set color and width to zero for no plotted boundaries.\n"
20862 "\n"
20863 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20864 " boundary of shaded region. The min values are used for the\n"
20865 " shade_min boundary, and the max values are used on the shade_max\n"
20866 " boundary. Set color and width to zero for no plotted boundaries.\n"
20867 "\n"
20868 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20869 " boundary of shaded region. The min values are used for the\n"
20870 " shade_min boundary, and the max values are used on the shade_max\n"
20871 " boundary. Set color and width to zero for no plotted boundaries.\n"
20872 "\n"
20873 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20874 " boundary of shaded region. The min values are used for the\n"
20875 " shade_min boundary, and the max values are used on the shade_max\n"
20876 " boundary. Set color and width to zero for no plotted boundaries.\n"
20877 "\n"
20878 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20879 " Use plfill. Future version of PLplot may have other fill\n"
20880 " routines.\n"
20881 "\n"
20882 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20883 " map to rectangles after coordinate transformation with pltrl.\n"
20884 " Otherwise, set rectangular to false. If rectangular is set to\n"
20885 " true, plshade tries to save time by filling large rectangles.\n"
20886 " This optimization fails if the coordinate transformation distorts\n"
20887 " the shape of rectangles. For example a plot in polar coordinates\n"
20888 " has to have rectangular set to false.\n"
20889 "\n"
20890 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20891 " defines the transformation between the zero-based indices of the\n"
20892 " matrix a and world coordinates. If\n"
20893 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20894 " indices of a are mapped to the range\n"
20895 " xmin through\n"
20896 " xmax and the y indices of a are mapped to the range\n"
20897 " ymin through\n"
20898 " ymax.For the C case, transformation functions are provided in the\n"
20899 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20900 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20901 " matrices. In addition, C callback routines for the transformation\n"
20902 " can be supplied by the user such as the mypltr function in\n"
20903 " examples/c/x09c.c which provides a general linear transformation\n"
20904 " between index coordinates and world coordinates.For languages\n"
20905 " other than C you should consult the PLplot documentation for the\n"
20906 " details concerning how PLTRANSFORM_callback arguments are\n"
20907 " interfaced. However, in general, a particular pattern of\n"
20908 " callback-associated arguments such as a tr vector with 6 elements;\n"
20909 " xg and yg vectors; or xg and yg matrices are respectively\n"
20910 " interfaced to a linear-transformation routine similar to the above\n"
20911 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20912 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20913 " support native language callbacks for handling index to\n"
20914 " world-coordinate transformations. Examples of these various\n"
20915 " approaches are given in examples/<language>x09*,\n"
20916 " examples/<language>x16*, examples/<language>x20*,\n"
20917 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20918 " supported languages.\n"
20919 "\n"
20920 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20921 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20922 " externally supplied.\n"
20923 "\n"
20924 ""},
20925 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20926 "Assign a function to use for generating custom axis labels\n"
20927 "\n"
20928 "DESCRIPTION:\n"
20929 "\n"
20930 " This function allows a user to provide their own function to provide\n"
20931 " axis label text. The user function is given the numeric value for a\n"
20932 " point on an axis and returns a string label to correspond with that\n"
20933 " value. Custom axis labels can be enabled by passing appropriate\n"
20934 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20935 "\n"
20936 " This function is used in example 19.\n"
20937 "\n"
20938 "\n"
20939 "\n"
20940 "SYNOPSIS:\n"
20941 "\n"
20942 "plslabelfunc(label_func, label_data)\n"
20943 "\n"
20944 "ARGUMENTS:\n"
20945 "\n"
20946 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20947 " label function. In order to reset to the default labelling, set\n"
20948 " this to NULL. The labelling function parameters are, in order:\n"
20949 " axis: This indicates which axis a label is being requested for.\n"
20950 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20951 "\n"
20952 " value: This is the value along the axis which is being labelled.\n"
20953 "\n"
20954 " label_text: The string representation of the label value.\n"
20955 "\n"
20956 " length: The maximum length in characters allowed for label_text.\n"
20957 "\n"
20958 "\n"
20959 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20960 " data to the label_func function.\n"
20961 "\n"
20962 ""},
20963 { "plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20964 "Set length of major ticks\n"
20965 "\n"
20966 "DESCRIPTION:\n"
20967 "\n"
20968 " This sets up the length of the major ticks. The actual length is the\n"
20969 " product of the default length and a scaling factor as for character\n"
20970 " height.\n"
20971 "\n"
20972 " Redacted form: plsmaj(def, scale)\n"
20973 "\n"
20974 " This function is used in example 29.\n"
20975 "\n"
20976 "\n"
20977 "\n"
20978 "SYNOPSIS:\n"
20979 "\n"
20980 "plsmaj(def, scale)\n"
20981 "\n"
20982 "ARGUMENTS:\n"
20983 "\n"
20984 " def (PLFLT, input) : The default length of a major tick in\n"
20985 " millimeters, should be set to zero if the default length is to\n"
20986 " remain unchanged.\n"
20987 "\n"
20988 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20989 " actual tick length.\n"
20990 "\n"
20991 ""},
20992 { "plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20993 "Set the memory area to be plotted (RGB)\n"
20994 "\n"
20995 "DESCRIPTION:\n"
20996 "\n"
20997 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20998 " the dev member of the stream structure. Also set the number of pixels\n"
20999 " in the memory passed in\n"
21000 " plotmem, which is a block of memory\n"
21001 " maxy by\n"
21002 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
21003 "\n"
21004 " This memory will have to be freed by the user!\n"
21005 "\n"
21006 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21007 "\n"
21008 " This function is not used in any examples.\n"
21009 "\n"
21010 "\n"
21011 "\n"
21012 "SYNOPSIS:\n"
21013 "\n"
21014 "plsmem(maxx, maxy, plotmem)\n"
21015 "\n"
21016 "ARGUMENTS:\n"
21017 "\n"
21018 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21019 "\n"
21020 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21021 "\n"
21022 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21023 " user-supplied writeable memory area.\n"
21024 "\n"
21025 ""},
21026 { "plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
21027 "Set the memory area to be plotted (RGBA)\n"
21028 "\n"
21029 "DESCRIPTION:\n"
21030 "\n"
21031 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21032 " dev member of the stream structure. Also set the number of pixels in\n"
21033 " the memory passed in\n"
21034 " plotmem, which is a block of memory\n"
21035 " maxy by\n"
21036 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21037 "\n"
21038 " This memory will have to be freed by the user!\n"
21039 "\n"
21040 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21041 "\n"
21042 " This function is not used in any examples.\n"
21043 "\n"
21044 "\n"
21045 "\n"
21046 "SYNOPSIS:\n"
21047 "\n"
21048 "plsmema(maxx, maxy, plotmem)\n"
21049 "\n"
21050 "ARGUMENTS:\n"
21051 "\n"
21052 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21053 "\n"
21054 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21055 "\n"
21056 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21057 " user-supplied writeable memory area.\n"
21058 "\n"
21059 ""},
21060 { "plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
21061 "Set length of minor ticks\n"
21062 "\n"
21063 "DESCRIPTION:\n"
21064 "\n"
21065 " This sets up the length of the minor ticks and the length of the\n"
21066 " terminals on error bars. The actual length is the product of the\n"
21067 " default length and a scaling factor as for character height.\n"
21068 "\n"
21069 " Redacted form: plsmin(def, scale)\n"
21070 "\n"
21071 " This function is used in example 29.\n"
21072 "\n"
21073 "\n"
21074 "\n"
21075 "SYNOPSIS:\n"
21076 "\n"
21077 "plsmin(def, scale)\n"
21078 "\n"
21079 "ARGUMENTS:\n"
21080 "\n"
21081 " def (PLFLT, input) : The default length of a minor tick in\n"
21082 " millimeters, should be set to zero if the default length is to\n"
21083 " remain unchanged.\n"
21084 "\n"
21085 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21086 " actual tick length.\n"
21087 "\n"
21088 ""},
21089 { "plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
21090 "Set orientation\n"
21091 "\n"
21092 "DESCRIPTION:\n"
21093 "\n"
21094 " Set integer plot orientation parameter. This function is identical to\n"
21095 " plsdiori except for the type of the argument, and should be used in\n"
21096 " the same way. See the documentation of plsdiori for details.\n"
21097 "\n"
21098 " Redacted form: plsori(ori)\n"
21099 "\n"
21100 " This function is used in example 3.\n"
21101 "\n"
21102 "\n"
21103 "\n"
21104 "SYNOPSIS:\n"
21105 "\n"
21106 "plsori(ori)\n"
21107 "\n"
21108 "ARGUMENTS:\n"
21109 "\n"
21110 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21111 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21112 " angle.\n"
21113 "\n"
21114 ""},
21115 { "plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
21116 "Set page parameters\n"
21117 "\n"
21118 "DESCRIPTION:\n"
21119 "\n"
21120 " Sets the page configuration (optional). If an individual parameter is\n"
21121 " zero then that parameter value is not updated. Not all parameters are\n"
21122 " recognized by all drivers and the interpretation is device-dependent.\n"
21123 " The X-window driver uses the length and offset parameters to determine\n"
21124 " the window size and location. The length and offset values are\n"
21125 " expressed in units that are specific to the current driver. For\n"
21126 " instance: screen drivers will usually interpret them as number of\n"
21127 " pixels, whereas printer drivers will usually use mm.\n"
21128 "\n"
21129 " This routine, if used, must be called before initializing PLplot. It\n"
21130 " may be called at later times for interactive drivers to change only\n"
21131 " the dpi for subsequent redraws which you can force via a call to\n"
21132 " plreplot. If this function is not called then the page size defaults\n"
21133 " to landscape A4 for drivers which use real world page sizes and 744\n"
21134 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21135 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21136 "\n"
21137 "\n"
21138 "\n"
21139 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21140 "\n"
21141 " This function is used in examples 14 and 31.\n"
21142 "\n"
21143 "\n"
21144 "\n"
21145 "SYNOPSIS:\n"
21146 "\n"
21147 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21148 "\n"
21149 "ARGUMENTS:\n"
21150 "\n"
21151 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21152 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21153 " (e.g. mm).\n"
21154 "\n"
21155 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21156 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21157 " (e.g. mm).\n"
21158 "\n"
21159 " xleng (PLINT, input) : Page length, x.\n"
21160 "\n"
21161 " yleng (PLINT, input) : Page length, y.\n"
21162 "\n"
21163 " xoff (PLINT, input) : Page offset, x.\n"
21164 "\n"
21165 " yoff (PLINT, input) : Page offset, y.\n"
21166 "\n"
21167 ""},
21168 { "plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
21169 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21170 "\n"
21171 "DESCRIPTION:\n"
21172 "\n"
21173 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21174 "\n"
21175 " Redacted form: plspal0(filename)\n"
21176 "\n"
21177 " This function is in example 16.\n"
21178 "\n"
21179 "\n"
21180 "\n"
21181 "SYNOPSIS:\n"
21182 "\n"
21183 "plspal0(filename)\n"
21184 "\n"
21185 "ARGUMENTS:\n"
21186 "\n"
21187 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21188 " containing the name of the cmap0*.pal file. If this string is\n"
21189 " empty, use the default cmap0*.pal file.\n"
21190 "\n"
21191 ""},
21192 { "plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
21193 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21194 "\n"
21195 "DESCRIPTION:\n"
21196 "\n"
21197 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21198 "\n"
21199 " Redacted form: plspal1(filename, interpolate)\n"
21200 "\n"
21201 " This function is used in example 16.\n"
21202 "\n"
21203 "\n"
21204 "\n"
21205 "SYNOPSIS:\n"
21206 "\n"
21207 "plspal1(filename, interpolate)\n"
21208 "\n"
21209 "ARGUMENTS:\n"
21210 "\n"
21211 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21212 " containing the name of the cmap1*.pal file. If this string is\n"
21213 " empty, use the default cmap1*.pal file.\n"
21214 "\n"
21215 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21216 " columns containing the intensity index, r, g, b, alpha and\n"
21217 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21218 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21219 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21220 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21221 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21222 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21223 " are used instead to set the cmap1 palette directly with a call to\n"
21224 " plscmap1a.\n"
21225 "\n"
21226 ""},
21227 { "plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
21228 "Set the pause (on end-of-page) status\n"
21229 "\n"
21230 "DESCRIPTION:\n"
21231 "\n"
21232 " Set the pause (on end-of-page) status.\n"
21233 "\n"
21234 " Redacted form: plspause(pause)\n"
21235 "\n"
21236 " This function is in examples 14,20.\n"
21237 "\n"
21238 "\n"
21239 "\n"
21240 "SYNOPSIS:\n"
21241 "\n"
21242 "plspause(pause)\n"
21243 "\n"
21244 "ARGUMENTS:\n"
21245 "\n"
21246 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21247 " end-of-page for those drivers which support this. Otherwise there\n"
21248 " is no pause.\n"
21249 "\n"
21250 ""},
21251 { "plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
21252 "Set current output stream\n"
21253 "\n"
21254 "DESCRIPTION:\n"
21255 "\n"
21256 " Sets the number of the current output stream. The stream number\n"
21257 " defaults to 0 unless changed by this routine. The first use of this\n"
21258 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21259 "\n"
21260 " Redacted form: plsstrm(strm)\n"
21261 "\n"
21262 " This function is examples 1,14,20.\n"
21263 "\n"
21264 "\n"
21265 "\n"
21266 "SYNOPSIS:\n"
21267 "\n"
21268 "plsstrm(strm)\n"
21269 "\n"
21270 "ARGUMENTS:\n"
21271 "\n"
21272 " strm (PLINT, input) : The current stream number.\n"
21273 "\n"
21274 ""},
21275 { "plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
21276 "Set the number of subpages in x and y\n"
21277 "\n"
21278 "DESCRIPTION:\n"
21279 "\n"
21280 " Set the number of subpages in x and y.\n"
21281 "\n"
21282 " Redacted form: plssub(nx, ny)\n"
21283 "\n"
21284 " This function is examples 1,2,14,21,25,27.\n"
21285 "\n"
21286 "\n"
21287 "\n"
21288 "SYNOPSIS:\n"
21289 "\n"
21290 "plssub(nx, ny)\n"
21291 "\n"
21292 "ARGUMENTS:\n"
21293 "\n"
21294 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21295 " of window columns).\n"
21296 "\n"
21297 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21298 " of window rows).\n"
21299 "\n"
21300 ""},
21301 { "plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
21302 "Set symbol size\n"
21303 "\n"
21304 "DESCRIPTION:\n"
21305 "\n"
21306 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21307 " plsym. The actual height of a symbol is the product of the default\n"
21308 " symbol size and a scaling factor as for the character height.\n"
21309 "\n"
21310 " Redacted form: plssym(def, scale)\n"
21311 "\n"
21312 " This function is used in example 29.\n"
21313 "\n"
21314 "\n"
21315 "\n"
21316 "SYNOPSIS:\n"
21317 "\n"
21318 "plssym(def, scale)\n"
21319 "\n"
21320 "ARGUMENTS:\n"
21321 "\n"
21322 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21323 " should be set to zero if the default height is to remain\n"
21324 " unchanged.\n"
21325 "\n"
21326 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21327 " actual symbol height.\n"
21328 "\n"
21329 ""},
21330 { "plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
21331 "Initialization\n"
21332 "\n"
21333 "DESCRIPTION:\n"
21334 "\n"
21335 " Initializing the plotting package. The program prompts for the device\n"
21336 " keyword or number of the desired output device. Hitting a RETURN in\n"
21337 " response to the prompt is the same as selecting the first device. If\n"
21338 " only one device is enabled when PLplot is installed, plstar will issue\n"
21339 " no prompt. The output device is divided into nx by ny subpages, each\n"
21340 " of which may be used independently. The subroutine pladv is used to\n"
21341 " advance from one subpage to the next.\n"
21342 "\n"
21343 " Redacted form: plstar(nx, ny)\n"
21344 "\n"
21345 " This function is used in example 1.\n"
21346 "\n"
21347 "\n"
21348 "\n"
21349 "SYNOPSIS:\n"
21350 "\n"
21351 "plstar(nx, ny)\n"
21352 "\n"
21353 "ARGUMENTS:\n"
21354 "\n"
21355 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21356 " x direction.\n"
21357 "\n"
21358 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21359 " y direction.\n"
21360 "\n"
21361 ""},
21362 { "plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
21363 "Initialization\n"
21364 "\n"
21365 "DESCRIPTION:\n"
21366 "\n"
21367 " Alternative to plstar for initializing the plotting package. The\n"
21368 " device name keyword for the desired output device must be supplied as\n"
21369 " an argument. These keywords are the same as those printed out by\n"
21370 " plstar. If the requested device is not available, or if the input\n"
21371 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21372 " is used. This routine also divides the output device page into nx by\n"
21373 " ny subpages, each of which may be used independently. The subroutine\n"
21374 " pladv is used to advance from one subpage to the next.\n"
21375 "\n"
21376 " Redacted form: General: plstart(devname, nx, ny)\n"
21377 "\n"
21378 "\n"
21379 " This function is not used in any examples.\n"
21380 "\n"
21381 "\n"
21382 "\n"
21383 "SYNOPSIS:\n"
21384 "\n"
21385 "plstart(devname, nx, ny)\n"
21386 "\n"
21387 "ARGUMENTS:\n"
21388 "\n"
21389 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21390 " containing the device name keyword of the required output device.\n"
21391 " If\n"
21392 " devname is NULL or if the first character of the string is a ``?'',\n"
21393 " the normal (prompted) start up is used.\n"
21394 "\n"
21395 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21396 " x direction.\n"
21397 "\n"
21398 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21399 " y direction.\n"
21400 "\n"
21401 ""},
21402 { "plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
21403 "Set a global coordinate transform function\n"
21404 "\n"
21405 "DESCRIPTION:\n"
21406 "\n"
21407 " This function can be used to define a coordinate transformation which\n"
21408 " affects all elements drawn within the current plot window. The\n"
21409 " coordinate_transform callback function is similar to that provided for\n"
21410 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21411 " parameter may be used to pass extra data to coordinate_transform.\n"
21412 "\n"
21413 " Redacted form: General: plstransform(coordinate_transform,\n"
21414 " coordinate_transform_data)\n"
21415 "\n"
21416 "\n"
21417 " This function is used in examples 19 and 22.\n"
21418 "\n"
21419 "\n"
21420 "\n"
21421 "SYNOPSIS:\n"
21422 "\n"
21423 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21424 "\n"
21425 "ARGUMENTS:\n"
21426 "\n"
21427 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21428 " function that defines the transformation from the input (x, y)\n"
21429 " world coordinates to new PLplot world coordinates. If\n"
21430 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21431 " case), then no transform is applied.\n"
21432 "\n"
21433 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21434 " for\n"
21435 " coordinate_transform.\n"
21436 "\n"
21437 ""},
21438 { "plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
21439 "Plot a glyph at the specified points\n"
21440 "\n"
21441 "DESCRIPTION:\n"
21442 "\n"
21443 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21444 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21445 " is specified with a PLplot user string. Note that the user string is\n"
21446 " not actually limited to one glyph so it is possible (but not normally\n"
21447 " useful) to plot more than one glyph at the specified points with this\n"
21448 " function. As with plmtex and plptex, the user string can contain FCI\n"
21449 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21450 " else PLplot escapes for Hershey or unicode text to determine the\n"
21451 " glyph.\n"
21452 "\n"
21453 " Redacted form: plstring(x, y, string)\n"
21454 "\n"
21455 " This function is used in examples 4, 21 and 26.\n"
21456 "\n"
21457 "\n"
21458 "\n"
21459 "SYNOPSIS:\n"
21460 "\n"
21461 "plstring(n, x, y, string)\n"
21462 "\n"
21463 "ARGUMENTS:\n"
21464 "\n"
21465 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21466 "\n"
21467 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21468 " the points.\n"
21469 "\n"
21470 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21471 " the points.\n"
21472 "\n"
21473 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21474 " the glyph(s) to be plotted at each of the n points.\n"
21475 "\n"
21476 ""},
21477 { "plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
21478 "Plot a glyph at the specified 3D points\n"
21479 "\n"
21480 "DESCRIPTION:\n"
21481 "\n"
21482 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21483 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21484 " this function similar to what is done for plline3. The glyph is\n"
21485 " specified with a PLplot user string. Note that the user string is not\n"
21486 " actually limited to one glyph so it is possible (but not normally\n"
21487 " useful) to plot more than one glyph at the specified points with this\n"
21488 " function. As with plmtex and plptex, the user string can contain FCI\n"
21489 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21490 " else PLplot escapes for Hershey or unicode text to determine the\n"
21491 " glyph.\n"
21492 "\n"
21493 " Redacted form: plstring3(x, y, z, string)\n"
21494 "\n"
21495 " This function is used in example 18.\n"
21496 "\n"
21497 "\n"
21498 "\n"
21499 "SYNOPSIS:\n"
21500 "\n"
21501 "plstring3(n, x, y, z, string)\n"
21502 "\n"
21503 "ARGUMENTS:\n"
21504 "\n"
21505 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21506 "\n"
21507 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21508 " the points.\n"
21509 "\n"
21510 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21511 " the points.\n"
21512 "\n"
21513 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21514 " the points.\n"
21515 "\n"
21516 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21517 " the glyph(s) to be plotted at each of the n points. points.\n"
21518 "\n"
21519 ""},
21520 { "plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
21521 "Add a point to a strip chart\n"
21522 "\n"
21523 "DESCRIPTION:\n"
21524 "\n"
21525 " Add a point to a given pen of a given strip chart. There is no need\n"
21526 " for all pens to have the same number of points or to be equally\n"
21527 " sampled in the x coordinate. Allocates memory and rescales as\n"
21528 " necessary.\n"
21529 "\n"
21530 " Redacted form: plstripa(id, pen, x, y)\n"
21531 "\n"
21532 " This function is used in example 17.\n"
21533 "\n"
21534 "\n"
21535 "\n"
21536 "SYNOPSIS:\n"
21537 "\n"
21538 "plstripa(id, pen, x, y)\n"
21539 "\n"
21540 "ARGUMENTS:\n"
21541 "\n"
21542 " id (PLINT, input) : Identification number of the strip chart (set\n"
21543 " up in plstripc).\n"
21544 "\n"
21545 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21546 "\n"
21547 " x (PLFLT, input) : X coordinate of point to plot.\n"
21548 "\n"
21549 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21550 "\n"
21551 ""},
21552 { "plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
21553 "Create a 4-pen strip chart\n"
21554 "\n"
21555 "DESCRIPTION:\n"
21556 "\n"
21557 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21558 "\n"
21559 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21560 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21561 " styline, legline, labx, laby, labz)\n"
21562 "\n"
21563 "\n"
21564 " This function is used in example 17.\n"
21565 "\n"
21566 "\n"
21567 "\n"
21568 "SYNOPSIS:\n"
21569 "\n"
21570 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21571 "\n"
21572 "ARGUMENTS:\n"
21573 "\n"
21574 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21575 " number of the strip chart to use on plstripa and plstripd.\n"
21576 "\n"
21577 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21578 " the x-axis specification as in plbox.\n"
21579 "\n"
21580 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21581 " the y-axis specification as in plbox.\n"
21582 "\n"
21583 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21584 " change as data are added.\n"
21585 "\n"
21586 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21587 " change as data are added.\n"
21588 "\n"
21589 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21590 " is multiplied by the factor (1 +\n"
21591 " xjump) .\n"
21592 "\n"
21593 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21594 " change as data are added.\n"
21595 "\n"
21596 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21597 " change as data are added.\n"
21598 "\n"
21599 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21600 "\n"
21601 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21602 "\n"
21603 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21604 " true, otherwise not.\n"
21605 "\n"
21606 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21607 " otherwise slide display.\n"
21608 "\n"
21609 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21610 "\n"
21611 " collab (PLINT, input) : Legend color index (cmap0).\n"
21612 "\n"
21613 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21614 " indices for the 4 pens.\n"
21615 "\n"
21616 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21617 " indices for the 4 pens.\n"
21618 "\n"
21619 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21620 " strings containing legends for the 4 pens.\n"
21621 "\n"
21622 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21623 " the label for the x axis.\n"
21624 "\n"
21625 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21626 " the label for the y axis.\n"
21627 "\n"
21628 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21629 " the plot title.\n"
21630 "\n"
21631 ""},
21632 { "plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
21633 "Deletes and releases memory used by a strip chart\n"
21634 "\n"
21635 "DESCRIPTION:\n"
21636 "\n"
21637 " Deletes and releases memory used by a strip chart.\n"
21638 "\n"
21639 " Redacted form: plstripd(id)\n"
21640 "\n"
21641 " This function is used in example 17.\n"
21642 "\n"
21643 "\n"
21644 "\n"
21645 "SYNOPSIS:\n"
21646 "\n"
21647 "plstripd(id)\n"
21648 "\n"
21649 "ARGUMENTS:\n"
21650 "\n"
21651 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21652 "\n"
21653 ""},
21654 { "plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
21655 "Set line style\n"
21656 "\n"
21657 "DESCRIPTION:\n"
21658 "\n"
21659 " This sets up the line style for all lines subsequently drawn. A line\n"
21660 " consists of segments in which the pen is alternately down and up. The\n"
21661 " lengths of these segments are passed in the vectors mark and space\n"
21662 " respectively. The number of mark-space pairs is specified by nms. In\n"
21663 " order to return the line style to the default continuous line, plstyl\n"
21664 " should be called with nms =0 .(see also pllsty)\n"
21665 "\n"
21666 " Redacted form: plstyl(mark, space)\n"
21667 "\n"
21668 " This function is used in examples 1, 9, and 14.\n"
21669 "\n"
21670 "\n"
21671 "\n"
21672 "SYNOPSIS:\n"
21673 "\n"
21674 "plstyl(nms, mark, space)\n"
21675 "\n"
21676 "ARGUMENTS:\n"
21677 "\n"
21678 " nms (PLINT, input) : The number of mark and space elements in a\n"
21679 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21680 " . A continuous line is specified by setting nms=0 .\n"
21681 "\n"
21682 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21683 " segments during which the pen is down, measured in micrometers.\n"
21684 "\n"
21685 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21686 " the segments during which the pen is up, measured in micrometers.\n"
21687 "\n"
21688 ""},
21689 { "plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
21690 "Set arrow style for vector plots\n"
21691 "\n"
21692 "DESCRIPTION:\n"
21693 "\n"
21694 " Set the style for the arrow used by plvect to plot vectors.\n"
21695 "\n"
21696 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21697 "\n"
21698 " This function is used in example 22.\n"
21699 "\n"
21700 "\n"
21701 "\n"
21702 "SYNOPSIS:\n"
21703 "\n"
21704 "plsvect(arrowx, arrowy, npts, fill)\n"
21705 "\n"
21706 "ARGUMENTS:\n"
21707 "\n"
21708 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21709 " the x and y points which make up the arrow. The arrow is plotted\n"
21710 " by joining these points to form a polygon. The scaling assumes\n"
21711 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21712 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21713 " will be reset to its default.\n"
21714 "\n"
21715 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21716 " arrowy.\n"
21717 "\n"
21718 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21719 " fill is false then the arrow is open.\n"
21720 "\n"
21721 ""},
21722 { "plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
21723 "Specify viewport in absolute coordinates\n"
21724 "\n"
21725 "DESCRIPTION:\n"
21726 "\n"
21727 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21728 " should be used only if the viewport is required to have a definite\n"
21729 " size in millimeters. The routine plgspa is useful for finding out the\n"
21730 " size of the current subpage.\n"
21731 "\n"
21732 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21733 "\n"
21734 " This function is used in example 10.\n"
21735 "\n"
21736 "\n"
21737 "\n"
21738 "SYNOPSIS:\n"
21739 "\n"
21740 "plsvpa(xmin, xmax, ymin, ymax)\n"
21741 "\n"
21742 "ARGUMENTS:\n"
21743 "\n"
21744 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21745 " viewport from the left-hand edge of the subpage in millimeters.\n"
21746 "\n"
21747 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21748 " viewport from the left-hand edge of the subpage in millimeters.\n"
21749 "\n"
21750 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21751 " viewport from the bottom edge of the subpage in millimeters.\n"
21752 "\n"
21753 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21754 " from the bottom edge of the subpage in millimeters.\n"
21755 "\n"
21756 ""},
21757 { "plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
21758 "Set x axis parameters\n"
21759 "\n"
21760 "DESCRIPTION:\n"
21761 "\n"
21762 " Sets values of the digmax and digits flags for the x axis. See the\n"
21763 " PLplot documentation for more information.\n"
21764 "\n"
21765 " Redacted form: plsxax(digmax, digits)\n"
21766 "\n"
21767 " This function is used in example 31.\n"
21768 "\n"
21769 "\n"
21770 "\n"
21771 "SYNOPSIS:\n"
21772 "\n"
21773 "plsxax(digmax, digits)\n"
21774 "\n"
21775 "ARGUMENTS:\n"
21776 "\n"
21777 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21778 " digits for the x axis. If nonzero, the printed label will be\n"
21779 " switched to a floating-point representation when the number of\n"
21780 " digits exceeds digmax.\n"
21781 "\n"
21782 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21783 " its value here has no effect since it is set only by plbox or\n"
21784 " plbox3. However, the user may obtain its value after a call to\n"
21785 " either of these functions by calling plgxax.\n"
21786 "\n"
21787 ""},
21788 { "plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
21789 "Set y axis parameters\n"
21790 "\n"
21791 "DESCRIPTION:\n"
21792 "\n"
21793 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21794 " the description of plsxax for more detail.\n"
21795 "\n"
21796 " Redacted form: plsyax(digmax, digits)\n"
21797 "\n"
21798 " This function is used in examples 1, 14, and 31.\n"
21799 "\n"
21800 "\n"
21801 "\n"
21802 "SYNOPSIS:\n"
21803 "\n"
21804 "plsyax(digmax, digits)\n"
21805 "\n"
21806 "ARGUMENTS:\n"
21807 "\n"
21808 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21809 " digits for the y axis. If nonzero, the printed label will be\n"
21810 " switched to a floating-point representation when the number of\n"
21811 " digits exceeds digmax.\n"
21812 "\n"
21813 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21814 " its value here has no effect since it is set only by plbox or\n"
21815 " plbox3. However, the user may obtain its value after a call to\n"
21816 " either of these functions by calling plgyax.\n"
21817 "\n"
21818 ""},
21819 { "plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
21820 "Plot a glyph at the specified points\n"
21821 "\n"
21822 "DESCRIPTION:\n"
21823 "\n"
21824 " Plot a glyph at the specified points. (This function is largely\n"
21825 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21826 "\n"
21827 " Redacted form: plsym(x, y, code)\n"
21828 "\n"
21829 " This function is used in example 7.\n"
21830 "\n"
21831 "\n"
21832 "\n"
21833 "SYNOPSIS:\n"
21834 "\n"
21835 "plsym(n, x, y, code)\n"
21836 "\n"
21837 "ARGUMENTS:\n"
21838 "\n"
21839 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21840 "\n"
21841 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21842 " the points.\n"
21843 "\n"
21844 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21845 " the points.\n"
21846 "\n"
21847 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21848 " to be plotted at each of the n points.\n"
21849 "\n"
21850 ""},
21851 { "plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21852 "Set z axis parameters\n"
21853 "\n"
21854 "DESCRIPTION:\n"
21855 "\n"
21856 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21857 " the description of plsxax for more detail.\n"
21858 "\n"
21859 " Redacted form: plszax(digmax, digits)\n"
21860 "\n"
21861 " This function is used in example 31.\n"
21862 "\n"
21863 "\n"
21864 "\n"
21865 "SYNOPSIS:\n"
21866 "\n"
21867 "plszax(digmax, digits)\n"
21868 "\n"
21869 "ARGUMENTS:\n"
21870 "\n"
21871 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21872 " digits for the z axis. If nonzero, the printed label will be\n"
21873 " switched to a floating-point representation when the number of\n"
21874 " digits exceeds digmax.\n"
21875 "\n"
21876 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21877 " its value here has no effect since it is set only by plbox or\n"
21878 " plbox3. However, the user may obtain its value after a call to\n"
21879 " either of these functions by calling plgzax.\n"
21880 "\n"
21881 ""},
21882 { "pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21883 "Switch to text screen\n"
21884 "\n"
21885 "DESCRIPTION:\n"
21886 "\n"
21887 " Sets an interactive device to text mode, used in conjunction with\n"
21888 " plgra to allow graphics and text to be interspersed. On a device\n"
21889 " which supports separate text and graphics windows, this command causes\n"
21890 " control to be switched to the text window. This can be useful for\n"
21891 " printing diagnostic messages or getting user input, which would\n"
21892 " otherwise interfere with the plots. The program must switch back to\n"
21893 " the graphics window before issuing plot commands, as the text (or\n"
21894 " console) device will probably become quite confused otherwise. If\n"
21895 " already in text mode, this command is ignored. It is also ignored on\n"
21896 " devices which only support a single window or use a different method\n"
21897 " for shifting focus (see also plgra).\n"
21898 "\n"
21899 " Redacted form: pltext()\n"
21900 "\n"
21901 " This function is used in example 1.\n"
21902 "\n"
21903 "\n"
21904 "\n"
21905 "SYNOPSIS:\n"
21906 "\n"
21907 "pltext()\n"
21908 "\n"
21909 ""},
21910 { "pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21911 "Set format for date / time labels\n"
21912 "\n"
21913 "DESCRIPTION:\n"
21914 "\n"
21915 " Sets the format for date / time labels. To enable date / time format\n"
21916 " labels see the options to plbox, plbox3, and plenv.\n"
21917 "\n"
21918 " Redacted form: pltimefmt(fmt)\n"
21919 "\n"
21920 " This function is used in example 29.\n"
21921 "\n"
21922 "\n"
21923 "\n"
21924 "SYNOPSIS:\n"
21925 "\n"
21926 "pltimefmt(fmt)\n"
21927 "\n"
21928 "ARGUMENTS:\n"
21929 "\n"
21930 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21931 " interpreted similarly to the format specifier of typical system\n"
21932 " strftime routines except that PLplot ignores locale and also\n"
21933 " supplies some useful extensions in the context of plotting. All\n"
21934 " text in the string is printed as-is other than conversion\n"
21935 " specifications which take the form of a '%' character followed by\n"
21936 " further conversion specification character. The conversion\n"
21937 " specifications which are similar to those provided by system\n"
21938 " strftime routines are the following: %a: The abbreviated (English)\n"
21939 " weekday name.\n"
21940 " %A: The full (English) weekday name.\n"
21941 " %b: The abbreviated (English) month name.\n"
21942 " %B: The full (English) month name.\n"
21943 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21944 " %C: The century number (year/100) as a 2-digit integer.\n"
21945 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21946 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21947 " %e: Like %d, but a leading zero is replaced by a space.\n"
21948 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21949 " %h: Equivalent to %b.\n"
21950 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21951 " 00 to 23).\n"
21952 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21953 " 01 to 12).\n"
21954 " %j: The day of the year as a decimal number (range 001 to\n"
21955 " 366).\n"
21956 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21957 " 23); single digits are preceded by a blank. (See also %H.)\n"
21958 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21959 " 12); single digits are preceded by a blank. (See also %I.)\n"
21960 " %m: The month as a decimal number (range 01 to 12).\n"
21961 " %M: The minute as a decimal number (range 00 to 59).\n"
21962 " %n: A newline character.\n"
21963 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21964 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21965 " %r: Equivalent to %I:%M:%S %p.\n"
21966 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21967 " including the seconds, see %T below.\n"
21968 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21969 " +0000 (UTC).\n"
21970 " %S: The second as a decimal number (range 00 to 60). (The\n"
21971 " range is up to 60 to allow for occasional leap seconds.)\n"
21972 " %t: A tab character.\n"
21973 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21974 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21975 " being 1. See also %w.\n"
21976 " %U: The week number of the current year as a decimal number,\n"
21977 " range 00 to 53, starting with the first Sunday as the first\n"
21978 " day of week 01. See also %V and %W.\n"
21979 " %v: Equivalent to %e-%b-%Y.\n"
21980 " %V: The ISO 8601 week number of the current year as a decimal\n"
21981 " number, range 01 to 53, where week 1 is the first week that\n"
21982 " has at least 4 days in the new year. See also %U and %W.\n"
21983 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21984 " being 0. See also %u.\n"
21985 " %W: The week number of the current year as a decimal number,\n"
21986 " range 00 to 53, starting with the first Monday as the first\n"
21987 " day of week 01.\n"
21988 " %x: Equivalent to %a %b %d %Y.\n"
21989 " %X: Equivalent to %T.\n"
21990 " %y: The year as a decimal number without a century (range 00\n"
21991 " to 99).\n"
21992 " %Y: The year as a decimal number including a century.\n"
21993 " %z: The UTC time-zone string = \"+0000\".\n"
21994 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21995 " %+: The UTC date and time in default format of the Unix date\n"
21996 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21997 " %%: A literal \"%\" character.\n"
21998 " The conversion specifications which are extensions to those normally\n"
21999 " provided by system strftime routines are the following: %(0-9):\n"
22000 " The fractional part of the seconds field (including leading\n"
22001 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
22002 " seconds to millisecond accuracy (00.000).\n"
22003 " %.: The fractional part of the seconds field (including\n"
22004 " leading decimal point) to the maximum available accuracy. Thus\n"
22005 " %S%. would give seconds with fractional part up to 9 decimal\n"
22006 " places if available.\n"
22007 "\n"
22008 ""},
22009 { "plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
22010 "Specify viewport using aspect ratio only\n"
22011 "\n"
22012 "DESCRIPTION:\n"
22013 "\n"
22014 " Selects the largest viewport with the given aspect ratio within the\n"
22015 " subpage that leaves a standard margin (left-hand margin of eight\n"
22016 " character heights, and a margin around the other three sides of five\n"
22017 " character heights).\n"
22018 "\n"
22019 " Redacted form: plvasp(aspect)\n"
22020 "\n"
22021 " This function is used in example 13.\n"
22022 "\n"
22023 "\n"
22024 "\n"
22025 "SYNOPSIS:\n"
22026 "\n"
22027 "plvasp(aspect)\n"
22028 "\n"
22029 "ARGUMENTS:\n"
22030 "\n"
22031 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22032 " axis of resulting viewport.\n"
22033 "\n"
22034 ""},
22035 { "plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
22036 "Vector plot\n"
22037 "\n"
22038 "DESCRIPTION:\n"
22039 "\n"
22040 " Draws a plot of vector data contained in the matrices (\n"
22041 " u[\n"
22042 " nx][\n"
22043 " ny],\n"
22044 " v[\n"
22045 " nx][\n"
22046 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22047 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22048 " additional data required by the transformation routine to map indices\n"
22049 " within the matrices to the world coordinates. The style of the vector\n"
22050 " arrow may be set using plsvect.\n"
22051 "\n"
22052 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22053 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22054 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22055 " with either one or two dimensions.\n"
22056 "\n"
22057 " This function is used in example 22.\n"
22058 "\n"
22059 "\n"
22060 "\n"
22061 "SYNOPSIS:\n"
22062 "\n"
22063 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22064 "\n"
22065 "ARGUMENTS:\n"
22066 "\n"
22067 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22068 " and y components of the vector data to be plotted.\n"
22069 "\n"
22070 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22071 "\n"
22072 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22073 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22074 " automatically calculated for the data. If scale < 0 then the\n"
22075 " scaling factor is automatically calculated for the data and then\n"
22076 " multiplied by -\n"
22077 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22078 "\n"
22079 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22080 " defines the transformation between the zero-based indices of the\n"
22081 " matrices u and v and world coordinates.For the C case,\n"
22082 " transformation functions are provided in the PLplot library: pltr0\n"
22083 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22084 " mappings respectively defined by vectors and matrices. In\n"
22085 " addition, C callback routines for the transformation can be\n"
22086 " supplied by the user such as the mypltr function in\n"
22087 " examples/c/x09c.c which provides a general linear transformation\n"
22088 " between index coordinates and world coordinates.For languages\n"
22089 " other than C you should consult the PLplot documentation for the\n"
22090 " details concerning how PLTRANSFORM_callback arguments are\n"
22091 " interfaced. However, in general, a particular pattern of\n"
22092 " callback-associated arguments such as a tr vector with 6 elements;\n"
22093 " xg and yg vectors; or xg and yg matrices are respectively\n"
22094 " interfaced to a linear-transformation routine similar to the above\n"
22095 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22096 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22097 " support native language callbacks for handling index to\n"
22098 " world-coordinate transformations. Examples of these various\n"
22099 " approaches are given in examples/<language>x09*,\n"
22100 " examples/<language>x16*, examples/<language>x20*,\n"
22101 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22102 " supported languages.\n"
22103 "\n"
22104 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22105 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22106 " that is externally supplied.\n"
22107 "\n"
22108 ""},
22109 { "plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
22110 "Specify viewport using coordinates and aspect ratio\n"
22111 "\n"
22112 "DESCRIPTION:\n"
22113 "\n"
22114 " Device-independent routine for setting up the viewport. The viewport\n"
22115 " is chosen to be the largest with the given aspect ratio that fits\n"
22116 " within the specified region (in terms of normalized subpage\n"
22117 " coordinates). This routine is functionally equivalent to plvpor when\n"
22118 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22119 " routine reserves no extra space at the edges for labels.\n"
22120 "\n"
22121 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22122 "\n"
22123 " This function is used in example 9.\n"
22124 "\n"
22125 "\n"
22126 "\n"
22127 "SYNOPSIS:\n"
22128 "\n"
22129 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22130 "\n"
22131 "ARGUMENTS:\n"
22132 "\n"
22133 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22134 " left-hand edge of the viewport.\n"
22135 "\n"
22136 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22137 " right-hand edge of the viewport.\n"
22138 "\n"
22139 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22140 " bottom edge of the viewport.\n"
22141 "\n"
22142 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22143 " edge of the viewport.\n"
22144 "\n"
22145 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22146 " axis.\n"
22147 "\n"
22148 ""},
22149 { "plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
22150 "Specify viewport using normalized subpage coordinates\n"
22151 "\n"
22152 "DESCRIPTION:\n"
22153 "\n"
22154 " Device-independent routine for setting up the viewport. This defines\n"
22155 " the viewport in terms of normalized subpage coordinates which run from\n"
22156 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22157 " current subpage. Use the alternate routine plsvpa in order to create\n"
22158 " a viewport of a definite size.\n"
22159 "\n"
22160 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22161 "\n"
22162 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22163 " 24, 26, 27, and 31.\n"
22164 "\n"
22165 "\n"
22166 "\n"
22167 "SYNOPSIS:\n"
22168 "\n"
22169 "plvpor(xmin, xmax, ymin, ymax)\n"
22170 "\n"
22171 "ARGUMENTS:\n"
22172 "\n"
22173 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22174 " left-hand edge of the viewport.\n"
22175 "\n"
22176 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22177 " right-hand edge of the viewport.\n"
22178 "\n"
22179 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22180 " bottom edge of the viewport.\n"
22181 "\n"
22182 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22183 " edge of the viewport.\n"
22184 "\n"
22185 ""},
22186 { "plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
22187 "Select standard viewport\n"
22188 "\n"
22189 "DESCRIPTION:\n"
22190 "\n"
22191 " Selects the largest viewport within the subpage that leaves a standard\n"
22192 " margin (left-hand margin of eight character heights, and a margin\n"
22193 " around the other three sides of five character heights).\n"
22194 "\n"
22195 " Redacted form: plvsta()\n"
22196 "\n"
22197 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22198 "\n"
22199 "\n"
22200 "\n"
22201 "SYNOPSIS:\n"
22202 "\n"
22203 "plvsta()\n"
22204 "\n"
22205 ""},
22206 { "plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
22207 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22208 "\n"
22209 "DESCRIPTION:\n"
22210 "\n"
22211 " Configure the transformations required for projecting a 3D surface on\n"
22212 " an existing 2D window. Those transformations (see the PLplot\n"
22213 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22214 " surface which has its limits expressed in 3D world coordinates and\n"
22215 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22216 " azimuth of the viewing angle). The transformations consist of the\n"
22217 " linear transform from 3D world coordinates to normalized 3D\n"
22218 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22219 " align the pole of the new 3D coordinate system with the viewing\n"
22220 " direction specified by altitude and azimuth so that x and y of the\n"
22221 " surface elements in that transformed coordinate system are the\n"
22222 " projection of the 3D surface with given viewing direction on the 2D\n"
22223 " window.\n"
22224 "\n"
22225 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22226 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22227 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22228 " sizes of basex by basey by height so that xmin maps to -\n"
22229 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22230 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22231 " The resulting rectangular cuboid in normalized coordinates is then\n"
22232 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22233 " must be called before plbox3 or any of the 3D surface plotting\n"
22234 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22235 " plsurf3dl or plfill3.\n"
22236 "\n"
22237 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22238 " zmin, zmax, alt, az)\n"
22239 "\n"
22240 " This function is examples 8, 11, 18, and 21.\n"
22241 "\n"
22242 "\n"
22243 "\n"
22244 "SYNOPSIS:\n"
22245 "\n"
22246 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22247 "\n"
22248 "ARGUMENTS:\n"
22249 "\n"
22250 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22251 " rectangular cuboid.\n"
22252 "\n"
22253 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22254 " rectangular cuboid.\n"
22255 "\n"
22256 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22257 " rectangular cuboid.\n"
22258 "\n"
22259 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22260 " rectangular cuboid.\n"
22261 "\n"
22262 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22263 " rectangular cuboid.\n"
22264 "\n"
22265 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22266 " rectangular cuboid.\n"
22267 "\n"
22268 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22269 " rectangular cuboid.\n"
22270 "\n"
22271 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22272 " rectangular cuboid.\n"
22273 "\n"
22274 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22275 " rectangular cuboid.\n"
22276 "\n"
22277 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22278 " plane of the rectangular cuboid in normalized coordinates.\n"
22279 "\n"
22280 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22281 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22282 " observer is looking face onto the zx plane of the rectangular\n"
22283 " cuboid in normalized coordinates, and as az is increased, the\n"
22284 " observer moves clockwise around that cuboid when viewed from above\n"
22285 " the xy plane.\n"
22286 "\n"
22287 ""},
22288 { "plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
22289 "Set pen width\n"
22290 "\n"
22291 "DESCRIPTION:\n"
22292 "\n"
22293 " Sets the pen width.\n"
22294 "\n"
22295 " Redacted form: plwidth(width)\n"
22296 "\n"
22297 " This function is used in examples 1 and 2.\n"
22298 "\n"
22299 "\n"
22300 "\n"
22301 "SYNOPSIS:\n"
22302 "\n"
22303 "plwidth(width)\n"
22304 "\n"
22305 "ARGUMENTS:\n"
22306 "\n"
22307 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22308 " or the same as the previous value no action is taken. width = 0.\n"
22309 " should be interpreted as as the minimum valid pen width for the\n"
22310 " device. The interpretation of positive width values is also\n"
22311 " device dependent.\n"
22312 "\n"
22313 ""},
22314 { "plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
22315 "Specify window\n"
22316 "\n"
22317 "DESCRIPTION:\n"
22318 "\n"
22319 " Specify the window, i.e., the world coordinates of the edges of the\n"
22320 " viewport.\n"
22321 "\n"
22322 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22323 "\n"
22324 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22325 " 29, and 31.\n"
22326 "\n"
22327 "\n"
22328 "\n"
22329 "SYNOPSIS:\n"
22330 "\n"
22331 "plwind(xmin, xmax, ymin, ymax)\n"
22332 "\n"
22333 "ARGUMENTS:\n"
22334 "\n"
22335 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22336 " of the viewport.\n"
22337 "\n"
22338 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22339 " of the viewport.\n"
22340 "\n"
22341 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22342 " the viewport.\n"
22343 "\n"
22344 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22345 " viewport.\n"
22346 "\n"
22347 ""},
22348 { "plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
22349 "Enter or leave xor mode\n"
22350 "\n"
22351 "DESCRIPTION:\n"
22352 "\n"
22353 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22354 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22355 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22356 " is not capable of xor operation it returns a status of false.\n"
22357 "\n"
22358 " Redacted form: plxormod(mode, status)\n"
22359 "\n"
22360 " This function is used in examples 1 and 20.\n"
22361 "\n"
22362 "\n"
22363 "\n"
22364 "SYNOPSIS:\n"
22365 "\n"
22366 "plxormod(mode, status)\n"
22367 "\n"
22368 "ARGUMENTS:\n"
22369 "\n"
22370 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22371 " is false means leave xor mode.\n"
22372 "\n"
22373 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22374 " modestatus of true (false) means driver is capable (incapable) of\n"
22375 " xor mode.\n"
22376 "\n"
22377 ""},
22378 { "plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
22379 "Plot continental outline or shapefile data in world coordinates\n"
22380 "\n"
22381 "DESCRIPTION:\n"
22382 "\n"
22383 " Plots continental outlines or shapefile data in world coordinates. A\n"
22384 " demonstration of how to use this function to create different\n"
22385 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22386 " basic coastal outlines and USA state borders. To use the map\n"
22387 " functionality PLplot must be compiled with the shapelib library.\n"
22388 " Shapefiles have become a popular standard for geographical data and\n"
22389 " data in this format can be easily found from a number of online\n"
22390 " sources. Shapefile data is actually provided as three or more files\n"
22391 " with the same filename, but different extensions. The .shp and .shx\n"
22392 " files are required for plotting Shapefile data with PLplot.\n"
22393 "\n"
22394 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22395 " objects within shapefiles. However holes in polygons are not\n"
22396 " supported. When plmap is used the type of object is derived from the\n"
22397 " shapefile, if you wish to override the type then use one of the other\n"
22398 " plmap variants. The built in maps have line data only.\n"
22399 "\n"
22400 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22401 "\n"
22402 " This function is used in example 19.\n"
22403 "\n"
22404 "\n"
22405 "\n"
22406 "SYNOPSIS:\n"
22407 "\n"
22408 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22409 "\n"
22410 "ARGUMENTS:\n"
22411 "\n"
22412 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22413 " transform the original map data coordinates to a new coordinate\n"
22414 " system. The PLplot-supplied map data is provided as latitudes and\n"
22415 " longitudes; other Shapefile data may be provided in other\n"
22416 " coordinate systems as can be found in their .prj plain text files.\n"
22417 " For example, by using this transform we can change from a\n"
22418 " longitude, latitude coordinate to a polar stereographic\n"
22419 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22420 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22421 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22422 " data). After the call to mapform(), x[] and y[] should be\n"
22423 " replaced by the corresponding plot coordinates. If no transform is\n"
22424 " desired, mapform can be replaced by NULL.\n"
22425 "\n"
22426 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22427 " the type of map plotted. This is either one of the PLplot built-in\n"
22428 " maps or the file name of a set of Shapefile files without the file\n"
22429 " extensions. For the PLplot built-in maps the possible values are:\n"
22430 " \"globe\" -- continental outlines\n"
22431 " \"usa\" -- USA and state boundaries\n"
22432 " \"cglobe\" -- continental outlines and countries\n"
22433 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22434 "\n"
22435 "\n"
22436 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22437 " drawn. The units must match the shapefile (built in maps are\n"
22438 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22439 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22440 " note this is simply an optimisation, not a clipping so for objects\n"
22441 " with some points inside the box and some points outside the box\n"
22442 " all the points will be rendered. These parameters also define\n"
22443 " latitude and longitude wrapping for shapefiles using these units.\n"
22444 " Longitude points will be wrapped by integer multiples of 360\n"
22445 " degrees to place them in the box. This allows the same data to be\n"
22446 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22447 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22448 " value of minx must be less than the value of maxx. Passing in a\n"
22449 " nan, max/-max floating point number or +/-infinity will case the\n"
22450 " bounding box from the shapefile to be used.\n"
22451 "\n"
22452 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22453 " drawn - see minx.\n"
22454 "\n"
22455 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22456 " drawn - see minx.\n"
22457 "\n"
22458 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22459 " drawn - see minx.\n"
22460 "\n"
22461 ""},
22462 { "plmapline", _wrap_plmapline, METH_VARARGS, (char *)"\n"
22463 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22464 "\n"
22465 "DESCRIPTION:\n"
22466 "\n"
22467 " Plot all or a subset of Shapefile data using lines in world\n"
22468 " coordinates. Our 19th standard example demonstrates how to use this\n"
22469 " function. This function plots data from a Shapefile using lines as in\n"
22470 " plmap, however it also has the option of also only drawing specified\n"
22471 " elements from the Shapefile. The vector of indices of the required\n"
22472 " elements are passed as a function argument. The Shapefile data should\n"
22473 " include a metadata file (extension.dbf) listing all items within the\n"
22474 " Shapefile. This file can be opened by most popular spreadsheet\n"
22475 " programs and can be used to decide which indices to pass to this\n"
22476 " function.\n"
22477 "\n"
22478 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22479 " plotentries)\n"
22480 "\n"
22481 " This function is used in example 19.\n"
22482 "\n"
22483 "\n"
22484 "\n"
22485 "SYNOPSIS:\n"
22486 "\n"
22487 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22488 "\n"
22489 "ARGUMENTS:\n"
22490 "\n"
22491 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22492 " transform the coordinates given in the shapefile into a plot\n"
22493 " coordinate system. By using this transform, we can change from a\n"
22494 " longitude, latitude coordinate to a polar stereographic project,\n"
22495 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22496 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22497 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22498 " plot coordinates. If no transform is desired, mapform can be\n"
22499 " replaced by NULL.\n"
22500 "\n"
22501 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22502 " the file name of a set of Shapefile files without the file\n"
22503 " extension.\n"
22504 "\n"
22505 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22506 " be in the same units as used by the Shapefile. You could use a\n"
22507 " very large negative number to plot everything, but you can improve\n"
22508 " performance by limiting the area drawn. The units must match those\n"
22509 " of the Shapefile projection, which may be for example longitude or\n"
22510 " distance. The value of minx must be less than the value of maxx.\n"
22511 "\n"
22512 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22513 " use a very large number to plot everything, but you can improve\n"
22514 " performance by limiting the area drawn.\n"
22515 "\n"
22516 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22517 " be in the same units as used by the Shapefile. You could use a\n"
22518 " very large negative number to plot everything, but you can improve\n"
22519 " performance by limiting the area drawn. The units must match those\n"
22520 " of the Shapefile projection, which may be for example latitude or\n"
22521 " distance. The value of miny must be less than the value of maxy.\n"
22522 "\n"
22523 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22524 " use a very large number to plot everything, but you can improve\n"
22525 " performance by limiting the area drawn.\n"
22526 "\n"
22527 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22528 " zero-based indices of the Shapefile elements which will be drawn.\n"
22529 " Setting\n"
22530 " plotentries to NULL will plot all elements of the Shapefile.\n"
22531 "\n"
22532 " nplotentries (PLINT, input) : The number of items in\n"
22533 " plotentries. Ignored if\n"
22534 " plotentries is NULL.\n"
22535 "\n"
22536 ""},
22537 { "plmapstring", _wrap_plmapstring, METH_VARARGS, (char *)"\n"
22538 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22539 "\n"
22540 "DESCRIPTION:\n"
22541 "\n"
22542 " As per plmapline, however the items are plotted as strings or points\n"
22543 " in the same way as plstring.\n"
22544 "\n"
22545 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22546 " maxy, plotentries)\n"
22547 "\n"
22548 " This function is not used in any examples.\n"
22549 "\n"
22550 "\n"
22551 "\n"
22552 "SYNOPSIS:\n"
22553 "\n"
22554 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22555 "\n"
22556 "ARGUMENTS:\n"
22557 "\n"
22558 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22559 " transform the coordinates given in the shapefile into a plot\n"
22560 " coordinate system. By using this transform, we can change from a\n"
22561 " longitude, latitude coordinate to a polar stereographic project,\n"
22562 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22563 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22564 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22565 " plot coordinates. If no transform is desired, mapform can be\n"
22566 " replaced by NULL.\n"
22567 "\n"
22568 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22569 " the file name of a set of Shapefile files without the file\n"
22570 " extension.\n"
22571 "\n"
22572 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22573 " drawn.\n"
22574 "\n"
22575 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22576 " be in the same units as used by the Shapefile. You could use a\n"
22577 " very large negative number to plot everything, but you can improve\n"
22578 " performance by limiting the area drawn. The units must match those\n"
22579 " of the Shapefile projection, which may be for example longitude or\n"
22580 " distance. The value of minx must be less than the value of maxx.\n"
22581 "\n"
22582 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22583 " use a very large number to plot everything, but you can improve\n"
22584 " performance by limiting the area drawn.\n"
22585 "\n"
22586 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22587 " be in the same units as used by the Shapefile. You could use a\n"
22588 " very large negative number to plot everything, but you can improve\n"
22589 " performance by limiting the area drawn. The units must match those\n"
22590 " of the Shapefile projection, which may be for example latitude or\n"
22591 " distance. The value of miny must be less than the value of maxy.\n"
22592 "\n"
22593 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22594 " use a very large number to plot everything, but you can improve\n"
22595 " performance by limiting the area drawn.\n"
22596 "\n"
22597 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22598 " zero-based indices of the Shapefile elements which will be drawn.\n"
22599 " Setting\n"
22600 " plotentries to NULL will plot all elements of the Shapefile.\n"
22601 "\n"
22602 " nplotentries (PLINT, input) : The number of items in\n"
22603 " plotentries. Ignored if\n"
22604 " plotentries is NULL.\n"
22605 "\n"
22606 ""},
22607 { "plmaptex", _wrap_plmaptex, METH_VARARGS, (char *)"\n"
22608 "Draw text at points defined by Shapefile data in world coordinates\n"
22609 "\n"
22610 "DESCRIPTION:\n"
22611 "\n"
22612 " As per plmapline, however the items are plotted as text in the same\n"
22613 " way as plptex.\n"
22614 "\n"
22615 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22616 " miny, maxy, plotentry)\n"
22617 "\n"
22618 " This function is used in example 19.\n"
22619 "\n"
22620 "\n"
22621 "\n"
22622 "SYNOPSIS:\n"
22623 "\n"
22624 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22625 "\n"
22626 "ARGUMENTS:\n"
22627 "\n"
22628 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22629 " transform the coordinates given in the shapefile into a plot\n"
22630 " coordinate system. By using this transform, we can change from a\n"
22631 " longitude, latitude coordinate to a polar stereographic project,\n"
22632 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22633 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22634 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22635 " plot coordinates. If no transform is desired, mapform can be\n"
22636 " replaced by NULL.\n"
22637 "\n"
22638 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22639 " the file name of a set of Shapefile files without the file\n"
22640 " extension.\n"
22641 "\n"
22642 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22643 " dy/dx.\n"
22644 "\n"
22645 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22646 " dy/dx.\n"
22647 "\n"
22648 " just (PLFLT, input) : Set the justification of the text. The value\n"
22649 " given will be the fraction of the distance along the string that\n"
22650 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22651 " centralized text and 1.0 gives right aligned text.\n"
22652 "\n"
22653 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22654 "\n"
22655 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22656 " be in the same units as used by the Shapefile. You could use a\n"
22657 " very large negative number to plot everything, but you can improve\n"
22658 " performance by limiting the area drawn. The units must match those\n"
22659 " of the Shapefile projection, which may be for example longitude or\n"
22660 " distance. The value of minx must be less than the value of maxx.\n"
22661 "\n"
22662 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22663 " use a very large number to plot everything, but you can improve\n"
22664 " performance by limiting the area drawn.\n"
22665 "\n"
22666 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22667 " be in the same units as used by the Shapefile. You could use a\n"
22668 " very large negative number to plot everything, but you can improve\n"
22669 " performance by limiting the area drawn. The units must match those\n"
22670 " of the Shapefile projection, which may be for example latitude or\n"
22671 " distance. The value of miny must be less than the value of maxy.\n"
22672 "\n"
22673 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22674 " use a very large number to plot everything, but you can improve\n"
22675 " performance by limiting the area drawn.\n"
22676 "\n"
22677 " plotentry (PLINT, input) : An integer indicating which text string\n"
22678 " of the Shapefile (zero indexed) will be drawn.\n"
22679 "\n"
22680 ""},
22681 { "plmapfill", _wrap_plmapfill, METH_VARARGS, (char *)"\n"
22682 "Plot all or a subset of Shapefile data, filling the polygons\n"
22683 "\n"
22684 "DESCRIPTION:\n"
22685 "\n"
22686 " As per plmapline, however the items are filled in the same way as\n"
22687 " plfill.\n"
22688 "\n"
22689 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22690 " plotentries)\n"
22691 "\n"
22692 " This function is used in example 19.\n"
22693 "\n"
22694 "\n"
22695 "\n"
22696 "SYNOPSIS:\n"
22697 "\n"
22698 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22699 "\n"
22700 "ARGUMENTS:\n"
22701 "\n"
22702 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22703 " transform the coordinates given in the shapefile into a plot\n"
22704 " coordinate system. By using this transform, we can change from a\n"
22705 " longitude, latitude coordinate to a polar stereographic project,\n"
22706 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22707 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22708 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22709 " plot coordinates. If no transform is desired, mapform can be\n"
22710 " replaced by NULL.\n"
22711 "\n"
22712 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22713 " the file name of a set of Shapefile files without the file\n"
22714 " extension.\n"
22715 "\n"
22716 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22717 " be in the same units as used by the Shapefile. You could use a\n"
22718 " very large negative number to plot everything, but you can improve\n"
22719 " performance by limiting the area drawn. The units must match those\n"
22720 " of the Shapefile projection, which may be for example longitude or\n"
22721 " distance. The value of minx must be less than the value of maxx.\n"
22722 "\n"
22723 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22724 " use a very large number to plot everything, but you can improve\n"
22725 " performance by limiting the area drawn.\n"
22726 "\n"
22727 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22728 " be in the same units as used by the Shapefile. You could use a\n"
22729 " very large negative number to plot everything, but you can improve\n"
22730 " performance by limiting the area drawn. The units must match those\n"
22731 " of the Shapefile projection, which may be for example latitude or\n"
22732 " distance. The value of miny must be less than the value of maxy.\n"
22733 "\n"
22734 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22735 " use a very large number to plot everything, but you can improve\n"
22736 " performance by limiting the area drawn.\n"
22737 "\n"
22738 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22739 " zero-based indices of the Shapefile elements which will be drawn.\n"
22740 " Setting\n"
22741 " plotentries to NULL will plot all elements of the Shapefile.\n"
22742 "\n"
22743 " nplotentries (PLINT, input) : The number of items in\n"
22744 " plotentries. Ignored if\n"
22745 " plotentries is NULL.\n"
22746 "\n"
22747 ""},
22748 { "plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
22749 "Plot latitude and longitude lines\n"
22750 "\n"
22751 "DESCRIPTION:\n"
22752 "\n"
22753 " Displays latitude and longitude on the current plot. The lines are\n"
22754 " plotted in the current color and line style.\n"
22755 "\n"
22756 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22757 " minlat, maxlat)\n"
22758 "\n"
22759 " This function is used in example 19.\n"
22760 "\n"
22761 "\n"
22762 "\n"
22763 "SYNOPSIS:\n"
22764 "\n"
22765 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22766 "\n"
22767 "ARGUMENTS:\n"
22768 "\n"
22769 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22770 " transform the coordinate longitudes and latitudes to a plot\n"
22771 " coordinate system. By using this transform, we can change from a\n"
22772 " longitude, latitude coordinate to a polar stereographic project,\n"
22773 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22774 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22775 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22776 " plot coordinates. If no transform is desired, mapform can be\n"
22777 " replaced by NULL.\n"
22778 "\n"
22779 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22780 " longitude lines are to be plotted.\n"
22781 "\n"
22782 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22783 " lines are to be plotted.\n"
22784 "\n"
22785 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22786 " side of the plot. The value of minlong must be less than the value\n"
22787 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22788 " equal to 360.\n"
22789 "\n"
22790 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22791 " side of the plot.\n"
22792 "\n"
22793 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22794 " background. One can always use -90.0 as the boundary outside the\n"
22795 " plot window will be automatically eliminated. However, the\n"
22796 " program will be faster if one can reduce the size of the\n"
22797 " background plotted.\n"
22798 "\n"
22799 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22800 " background. One can always use 90.0 as the boundary outside the\n"
22801 " plot window will be automatically eliminated.\n"
22802 "\n"
22803 ""},
22804 { "plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
22805 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22806 "\n"
22807 "DESCRIPTION:\n"
22808 "\n"
22809 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22810 " automatically adjusted to use the maximum and minimum values in idata\n"
22811 " as valuemin and valuemax in a call to plimagefr.\n"
22812 "\n"
22813 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22814 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22815 "\n"
22816 "\n"
22817 " This function is used in example 20.\n"
22818 "\n"
22819 "\n"
22820 "\n"
22821 "SYNOPSIS:\n"
22822 "\n"
22823 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22824 "\n"
22825 "ARGUMENTS:\n"
22826 "\n"
22827 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22828 " to plot. Should have dimensions of\n"
22829 " nx by\n"
22830 " ny.\n"
22831 "\n"
22832 " nx, ny (PLINT, input) : Dimensions of idata\n"
22833 "\n"
22834 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22835 " are linearly transformed to these world coordinate ranges such\n"
22836 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22837 " - 1] corresponds to (xmax, ymax).\n"
22838 "\n"
22839 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22840 " (inclusive) will be plotted.\n"
22841 "\n"
22842 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22843 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22844 " Dymin) to (Dxmax, Dymax).\n"
22845 "\n"
22846 ""},
22847 { "plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
22848 "Plot a 2D matrix using cmap1\n"
22849 "\n"
22850 "DESCRIPTION:\n"
22851 "\n"
22852 " Plot a 2D matrix using cmap1.\n"
22853 "\n"
22854 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22855 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22856 "\n"
22857 "\n"
22858 " This function is used in example 20.\n"
22859 "\n"
22860 "\n"
22861 "\n"
22862 "SYNOPSIS:\n"
22863 "\n"
22864 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22865 "\n"
22866 "ARGUMENTS:\n"
22867 "\n"
22868 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22869 " plot. Should have dimensions of\n"
22870 " nx by\n"
22871 " ny.\n"
22872 "\n"
22873 " nx, ny (PLINT, input) : Dimensions of idata\n"
22874 "\n"
22875 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22876 " pltr below for how these arguments are used (only for the special case\n"
22877 " when the callback function\n"
22878 " pltr is not supplied).\n"
22879 "\n"
22880 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22881 " (inclusive) will be plotted.\n"
22882 "\n"
22883 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22884 " values to use for value to color mappings. A datum equal to or\n"
22885 " less than valuemin will be plotted with color 0.0, while a datum\n"
22886 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22887 " Data between valuemin and valuemax map linearly to colors in the\n"
22888 " range (0.0-1.0).\n"
22889 "\n"
22890 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22891 " defines the transformation between the zero-based indices of the\n"
22892 " matrix idata and world coordinates. If\n"
22893 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22894 " indices of idata are mapped to the range\n"
22895 " xmin through\n"
22896 " xmax and the y indices of idata are mapped to the range\n"
22897 " ymin through\n"
22898 " ymax.For the C case, transformation functions are provided in the\n"
22899 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22900 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22901 " matrices. In addition, C callback routines for the transformation\n"
22902 " can be supplied by the user such as the mypltr function in\n"
22903 " examples/c/x09c.c which provides a general linear transformation\n"
22904 " between index coordinates and world coordinates.For languages\n"
22905 " other than C you should consult the PLplot documentation for the\n"
22906 " details concerning how PLTRANSFORM_callback arguments are\n"
22907 " interfaced. However, in general, a particular pattern of\n"
22908 " callback-associated arguments such as a tr vector with 6 elements;\n"
22909 " xg and yg vectors; or xg and yg matrices are respectively\n"
22910 " interfaced to a linear-transformation routine similar to the above\n"
22911 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22912 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22913 " support native language callbacks for handling index to\n"
22914 " world-coordinate transformations. Examples of these various\n"
22915 " approaches are given in examples/<language>x09*,\n"
22916 " examples/<language>x16*, examples/<language>x20*,\n"
22917 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22918 " supported languages.\n"
22919 "\n"
22920 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22921 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22922 " externally supplied.\n"
22923 "\n"
22924 ""},
22925 { "plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
22926 { "plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
22927 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22928 { "plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
22929 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
22930 { "plGetCursor", _wrap_plGetCursor, METH_VARARGS, (char *)"\n"
22931 "Wait for graphics input event and translate to world coordinates.\n"
22932 "\n"
22933 "DESCRIPTION:\n"
22934 "\n"
22935 " Wait for graphics input event and translate to world coordinates.\n"
22936 " Returns 0 if no translation to world coordinates is possible.\n"
22937 "\n"
22938 " This function returns 1 on success and 0 if no translation to world\n"
22939 " coordinates is possible.\n"
22940 "\n"
22941 " Redacted form: plGetCursor(gin)\n"
22942 "\n"
22943 " This function is used in examples 1 and 20.\n"
22944 "\n"
22945 "\n"
22946 "\n"
22947 "SYNOPSIS:\n"
22948 "\n"
22949 "PLINT plGetCursor(gin)\n"
22950 "\n"
22951 "ARGUMENTS:\n"
22952 "\n"
22953 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22954 " which will contain the output. The structure is not allocated by\n"
22955 " the routine and must exist before the function is called.\n"
22956 "\n"
22957 ""},
22958 { NULL, NULL, 0, NULL }
22959 };
22960
22961
22962 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22963
22964 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22965 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22966 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22967 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22968 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22969 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22970 static 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};
22971 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
22972 static 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};
22973 static 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", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
22974 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22975 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22976 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22977 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22978
22979 static swig_type_info *swig_type_initial[] = {
22980 &_swigt__p_PLGraphicsIn,
22981 &_swigt__p_PLcGrid,
22982 &_swigt__p_PLcGrid2,
22983 &_swigt__p_char,
22984 &_swigt__p_double,
22985 &_swigt__p_f_double_double__int,
22986 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
22987 &_swigt__p_f_int_double_p_char_int_p_void__void,
22988 &_swigt__p_f_int_p_double_p_double__void,
22989 &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
22990 &_swigt__p_int,
22991 &_swigt__p_p_char,
22992 &_swigt__p_p_double,
22993 &_swigt__p_unsigned_int,
22994 };
22995
22996 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22997 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22998 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22999 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23000 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23001 static swig_cast_info _swigc__p_f_double_double__int[] = { {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
23002 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = { {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
23003 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = { {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
23004 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = { {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
23005 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = { {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}};
23006 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23007 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23008 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23009 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23010
23011 static swig_cast_info *swig_cast_initial[] = {
23012 _swigc__p_PLGraphicsIn,
23013 _swigc__p_PLcGrid,
23014 _swigc__p_PLcGrid2,
23015 _swigc__p_char,
23016 _swigc__p_double,
23017 _swigc__p_f_double_double__int,
23018 _swigc__p_f_double_double_p_double_p_double_p_void__void,
23019 _swigc__p_f_int_double_p_char_int_p_void__void,
23020 _swigc__p_f_int_p_double_p_double__void,
23021 _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
23022 _swigc__p_int,
23023 _swigc__p_p_char,
23024 _swigc__p_p_double,
23025 _swigc__p_unsigned_int,
23026 };
23027
23028
23029 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23030
23031 static swig_const_info swig_const_table[] = {
23032 {0, 0, 0, 0.0, 0, 0}};
23033
23034 #ifdef __cplusplus
23035 }
23036 #endif
23037 /* -----------------------------------------------------------------------------
23038 * Type initialization:
23039 * This problem is tough by the requirement that no dynamic
23040 * memory is used. Also, since swig_type_info structures store pointers to
23041 * swig_cast_info structures and swig_cast_info structures store pointers back
23042 * to swig_type_info structures, we need some lookup code at initialization.
23043 * The idea is that swig generates all the structures that are needed.
23044 * The runtime then collects these partially filled structures.
23045 * The SWIG_InitializeModule function takes these initial arrays out of
23046 * swig_module, and does all the lookup, filling in the swig_module.types
23047 * array with the correct data and linking the correct swig_cast_info
23048 * structures together.
23049 *
23050 * The generated swig_type_info structures are assigned statically to an initial
23051 * array. We just loop through that array, and handle each type individually.
23052 * First we lookup if this type has been already loaded, and if so, use the
23053 * loaded structure instead of the generated one. Then we have to fill in the
23054 * cast linked list. The cast data is initially stored in something like a
23055 * two-dimensional array. Each row corresponds to a type (there are the same
23056 * number of rows as there are in the swig_type_initial array). Each entry in
23057 * a column is one of the swig_cast_info structures for that type.
23058 * The cast_initial array is actually an array of arrays, because each row has
23059 * a variable number of columns. So to actually build the cast linked list,
23060 * we find the array of casts associated with the type, and loop through it
23061 * adding the casts to the list. The one last trick we need to do is making
23062 * sure the type pointer in the swig_cast_info struct is correct.
23063 *
23064 * First off, we lookup the cast->type name to see if it is already loaded.
23065 * There are three cases to handle:
23066 * 1) If the cast->type has already been loaded AND the type we are adding
23067 * casting info to has not been loaded (it is in this module), THEN we
23068 * replace the cast->type pointer with the type pointer that has already
23069 * been loaded.
23070 * 2) If BOTH types (the one we are adding casting info to, and the
23071 * cast->type) are loaded, THEN the cast info has already been loaded by
23072 * the previous module so we just ignore it.
23073 * 3) Finally, if cast->type has not already been loaded, then we add that
23074 * swig_cast_info to the linked list (because the cast->type) pointer will
23075 * be correct.
23076 * ----------------------------------------------------------------------------- */
23077
23078 #ifdef __cplusplus
23079 extern "C" {
23080 #if 0
23081 } /* c-mode */
23082 #endif
23083 #endif
23084
23085 #if 0
23086 #define SWIGRUNTIME_DEBUG
23087 #endif
23088
23089
23090 SWIGRUNTIME void
23091 SWIG_InitializeModule(void *clientdata) {
23092 size_t i;
23093 swig_module_info *module_head, *iter;
23094 int init;
23095
23096 /* check to see if the circular list has been setup, if not, set it up */
23097 if (swig_module.next==0) {
23098 /* Initialize the swig_module */
23099 swig_module.type_initial = swig_type_initial;
23100 swig_module.cast_initial = swig_cast_initial;
23101 swig_module.next = &swig_module;
23102 init = 1;
23103 } else {
23104 init = 0;
23105 }
23106
23107 /* Try and load any already created modules */
23108 module_head = SWIG_GetModule(clientdata);
23109 if (!module_head) {
23110 /* This is the first module loaded for this interpreter */
23111 /* so set the swig module into the interpreter */
23112 SWIG_SetModule(clientdata, &swig_module);
23113 } else {
23114 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23115 iter=module_head;
23116 do {
23117 if (iter==&swig_module) {
23118 /* Our module is already in the list, so there's nothing more to do. */
23119 return;
23120 }
23121 iter=iter->next;
23122 } while (iter!= module_head);
23123
23124 /* otherwise we must add our module into the list */
23125 swig_module.next = module_head->next;
23126 module_head->next = &swig_module;
23127 }
23128
23129 /* When multiple interpreters are used, a module could have already been initialized in
23130 a different interpreter, but not yet have a pointer in this interpreter.
23131 In this case, we do not want to continue adding types... everything should be
23132 set up already */
23133 if (init == 0) return;
23134
23135 /* Now work on filling in swig_module.types */
23136 #ifdef SWIGRUNTIME_DEBUG
23137 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23138 #endif
23139 for (i = 0; i < swig_module.size; ++i) {
23140 swig_type_info *type = 0;
23141 swig_type_info *ret;
23142 swig_cast_info *cast;
23143
23144 #ifdef SWIGRUNTIME_DEBUG
23145 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23146 #endif
23147
23148 /* if there is another module already loaded */
23149 if (swig_module.next != &swig_module) {
23150 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23151 }
23152 if (type) {
23153 /* Overwrite clientdata field */
23154 #ifdef SWIGRUNTIME_DEBUG
23155 printf("SWIG_InitializeModule: found type %s\n", type->name);
23156 #endif
23157 if (swig_module.type_initial[i]->clientdata) {
23158 type->clientdata = swig_module.type_initial[i]->clientdata;
23159 #ifdef SWIGRUNTIME_DEBUG
23160 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23161 #endif
23162 }
23163 } else {
23164 type = swig_module.type_initial[i];
23165 }
23166
23167 /* Insert casting types */
23168 cast = swig_module.cast_initial[i];
23169 while (cast->type) {
23170 /* Don't need to add information already in the list */
23171 ret = 0;
23172 #ifdef SWIGRUNTIME_DEBUG
23173 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23174 #endif
23175 if (swig_module.next != &swig_module) {
23176 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23177 #ifdef SWIGRUNTIME_DEBUG
23178 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23179 #endif
23180 }
23181 if (ret) {
23182 if (type == swig_module.type_initial[i]) {
23183 #ifdef SWIGRUNTIME_DEBUG
23184 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23185 #endif
23186 cast->type = ret;
23187 ret = 0;
23188 } else {
23189 /* Check for casting already in the list */
23190 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23191 #ifdef SWIGRUNTIME_DEBUG
23192 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23193 #endif
23194 if (!ocast) ret = 0;
23195 }
23196 }
23197
23198 if (!ret) {
23199 #ifdef SWIGRUNTIME_DEBUG
23200 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23201 #endif
23202 if (type->cast) {
23203 type->cast->prev = cast;
23204 cast->next = type->cast;
23205 }
23206 type->cast = cast;
23207 }
23208 cast++;
23209 }
23210 /* Set entry in modules->types array equal to the type */
23211 swig_module.types[i] = type;
23212 }
23213 swig_module.types[i] = 0;
23214
23215 #ifdef SWIGRUNTIME_DEBUG
23216 printf("**** SWIG_InitializeModule: Cast List ******\n");
23217 for (i = 0; i < swig_module.size; ++i) {
23218 int j = 0;
23219 swig_cast_info *cast = swig_module.cast_initial[i];
23220 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23221 while (cast->type) {
23222 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23223 cast++;
23224 ++j;
23225 }
23226 printf("---- Total casts: %d\n",j);
23227 }
23228 printf("**** SWIG_InitializeModule: Cast List ******\n");
23229 #endif
23230 }
23231
23232 /* This function will propagate the clientdata field of type to
23233 * any new swig_type_info structures that have been added into the list
23234 * of equivalent types. It is like calling
23235 * SWIG_TypeClientData(type, clientdata) a second time.
23236 */
23237 SWIGRUNTIME void
23238 SWIG_PropagateClientData(void) {
23239 size_t i;
23240 swig_cast_info *equiv;
23241 static int init_run = 0;
23242
23243 if (init_run) return;
23244 init_run = 1;
23245
23246 for (i = 0; i < swig_module.size; i++) {
23247 if (swig_module.types[i]->clientdata) {
23248 equiv = swig_module.types[i]->cast;
23249 while (equiv) {
23250 if (!equiv->converter) {
23251 if (equiv->type && !equiv->type->clientdata)
23252 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23253 }
23254 equiv = equiv->next;
23255 }
23256 }
23257 }
23258 }
23259
23260 #ifdef __cplusplus
23261 #if 0
23262 {
23263 /* c-mode */
23264 #endif
23265 }
23266 #endif
23267
23268
23269
23270 #ifdef __cplusplus
23271 extern "C" {
23272 #endif
23273
23274 /* Python-specific SWIG API */
23275 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23276 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23277 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23278
23279 /* -----------------------------------------------------------------------------
23280 * global variable support code.
23281 * ----------------------------------------------------------------------------- */
23282
23283 typedef struct swig_globalvar {
23284 char *name; /* Name of global variable */
23285 PyObject *(*get_attr)(void); /* Return the current value */
23286 int (*set_attr)(PyObject *); /* Set the value */
23287 struct swig_globalvar *next;
23288 } swig_globalvar;
23289
23290 typedef struct swig_varlinkobject {
23291 PyObject_HEAD
23292 swig_globalvar *vars;
23293 } swig_varlinkobject;
23294
23295 SWIGINTERN PyObject *
23296 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
23297 #if PY_VERSION_HEX >= 0x03000000
23298 return PyUnicode_InternFromString("<Swig global variables>");
23299 #else
23300 return PyString_FromString("<Swig global variables>");
23301 #endif
23302 }
23303
23304 SWIGINTERN PyObject *
23305 swig_varlink_str(swig_varlinkobject *v) {
23306 #if PY_VERSION_HEX >= 0x03000000
23307 PyObject *str = PyUnicode_InternFromString("(");
23308 PyObject *tail;
23309 PyObject *joined;
23310 swig_globalvar *var;
23311 for (var = v->vars; var; var=var->next) {
23312 tail = PyUnicode_FromString(var->name);
23313 joined = PyUnicode_Concat(str, tail);
23314 Py_DecRef(str);
23315 Py_DecRef(tail);
23316 str = joined;
23317 if (var->next) {
23318 tail = PyUnicode_InternFromString(", ");
23319 joined = PyUnicode_Concat(str, tail);
23320 Py_DecRef(str);
23321 Py_DecRef(tail);
23322 str = joined;
23323 }
23324 }
23325 tail = PyUnicode_InternFromString(")");
23326 joined = PyUnicode_Concat(str, tail);
23327 Py_DecRef(str);
23328 Py_DecRef(tail);
23329 str = joined;
23330 #else
23331 PyObject *str = PyString_FromString("(");
23332 swig_globalvar *var;
23333 for (var = v->vars; var; var=var->next) {
23334 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23335 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23336 }
23337 PyString_ConcatAndDel(&str,PyString_FromString(")"));
23338 #endif
23339 return str;
23340 }
23341
23342 SWIGINTERN int
23343 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
23344 char *tmp;
23345 PyObject *str = swig_varlink_str(v);
23346 fprintf(fp,"Swig global variables ");
23347 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
23348 SWIG_Python_str_DelForPy3(tmp);
23349 Py_DECREF(str);
23350 return 0;
23351 }
23352
23353 SWIGINTERN void
23354 swig_varlink_dealloc(swig_varlinkobject *v) {
23355 swig_globalvar *var = v->vars;
23356 while (var) {
23357 swig_globalvar *n = var->next;
23358 free(var->name);
23359 free(var);
23360 var = n;
23361 }
23362 }
23363
23364 SWIGINTERN PyObject *
23365 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23366 PyObject *res = NULL;
23367 swig_globalvar *var = v->vars;
23368 while (var) {
23369 if (strcmp(var->name,n) == 0) {
23370 res = (*var->get_attr)();
23371 break;
23372 }
23373 var = var->next;
23374 }
23375 if (res == NULL && !PyErr_Occurred()) {
23376 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23377 }
23378 return res;
23379 }
23380
23381 SWIGINTERN int
23382 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23383 int res = 1;
23384 swig_globalvar *var = v->vars;
23385 while (var) {
23386 if (strcmp(var->name,n) == 0) {
23387 res = (*var->set_attr)(p);
23388 break;
23389 }
23390 var = var->next;
23391 }
23392 if (res == 1 && !PyErr_Occurred()) {
23393 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23394 }
23395 return res;
23396 }
23397
23398 SWIGINTERN PyTypeObject*
23399 swig_varlink_type(void) {
23400 static char varlink__doc__[] = "Swig var link object";
23401 static PyTypeObject varlink_type;
23402 static int type_init = 0;
23403 if (!type_init) {
23404 const PyTypeObject tmp = {
23405 #if PY_VERSION_HEX >= 0x03000000
23406 PyVarObject_HEAD_INIT(NULL, 0)
23407 #else
23408 PyObject_HEAD_INIT(NULL)
23409 0, /* ob_size */
23410 #endif
23411 (char *)"swigvarlink", /* tp_name */
23412 sizeof(swig_varlinkobject), /* tp_basicsize */
23413 0, /* tp_itemsize */
23414 (destructor) swig_varlink_dealloc, /* tp_dealloc */
23415 (printfunc) swig_varlink_print, /* tp_print */
23416 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
23417 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
23418 0, /* tp_compare */
23419 (reprfunc) swig_varlink_repr, /* tp_repr */
23420 0, /* tp_as_number */
23421 0, /* tp_as_sequence */
23422 0, /* tp_as_mapping */
23423 0, /* tp_hash */
23424 0, /* tp_call */
23425 (reprfunc) swig_varlink_str, /* tp_str */
23426 0, /* tp_getattro */
23427 0, /* tp_setattro */
23428 0, /* tp_as_buffer */
23429 0, /* tp_flags */
23430 varlink__doc__, /* tp_doc */
23431 0, /* tp_traverse */
23432 0, /* tp_clear */
23433 0, /* tp_richcompare */
23434 0, /* tp_weaklistoffset */
23435 #if PY_VERSION_HEX >= 0x02020000
23436 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23437 #endif
23438 #if PY_VERSION_HEX >= 0x02030000
23439 0, /* tp_del */
23440 #endif
23441 #if PY_VERSION_HEX >= 0x02060000
23442 0, /* tp_version_tag */
23443 #endif
23444 #if PY_VERSION_HEX >= 0x03040000
23445 0, /* tp_finalize */
23446 #endif
23447 #ifdef COUNT_ALLOCS
23448 0, /* tp_allocs */
23449 0, /* tp_frees */
23450 0, /* tp_maxalloc */
23451 #if PY_VERSION_HEX >= 0x02050000
23452 0, /* tp_prev */
23453 #endif
23454 0 /* tp_next */
23455 #endif
23456 };
23457 varlink_type = tmp;
23458 type_init = 1;
23459 #if PY_VERSION_HEX < 0x02020000
23460 varlink_type.ob_type = &PyType_Type;
23461 #else
23462 if (PyType_Ready(&varlink_type) < 0)
23463 return NULL;
23464 #endif
23465 }
23466 return &varlink_type;
23467 }
23468
23469 /* Create a variable linking object for use later */
23470 SWIGINTERN PyObject *
23471 SWIG_Python_newvarlink(void) {
23472 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23473 if (result) {
23474 result->vars = 0;
23475 }
23476 return ((PyObject*) result);
23477 }
23478
23479 SWIGINTERN void
23480 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23481 swig_varlinkobject *v = (swig_varlinkobject *) p;
23482 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23483 if (gv) {
23484 size_t size = strlen(name)+1;
23485 gv->name = (char *)malloc(size);
23486 if (gv->name) {
23487 strncpy(gv->name,name,size);
23488 gv->get_attr = get_attr;
23489 gv->set_attr = set_attr;
23490 gv->next = v->vars;
23491 }
23492 }
23493 v->vars = gv;
23494 }
23495
23496 SWIGINTERN PyObject *
23497 SWIG_globals(void) {
23498 static PyObject *_SWIG_globals = 0;
23499 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23500 return _SWIG_globals;
23501 }
23502
23503 /* -----------------------------------------------------------------------------
23504 * constants/methods manipulation
23505 * ----------------------------------------------------------------------------- */
23506
23507 /* Install Constants */
23508 SWIGINTERN void
23509 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23510 PyObject *obj = 0;
23511 size_t i;
23512 for (i = 0; constants[i].type; ++i) {
23513 switch(constants[i].type) {
23514 case SWIG_PY_POINTER:
23515 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23516 break;
23517 case SWIG_PY_BINARY:
23518 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23519 break;
23520 default:
23521 obj = 0;
23522 break;
23523 }
23524 if (obj) {
23525 PyDict_SetItemString(d, constants[i].name, obj);
23526 Py_DECREF(obj);
23527 }
23528 }
23529 }
23530
23531 /* -----------------------------------------------------------------------------*/
23532 /* Fix SwigMethods to carry the callback ptrs when needed */
23533 /* -----------------------------------------------------------------------------*/
23534
23535 SWIGINTERN void
23536 SWIG_Python_FixMethods(PyMethodDef *methods,
23537 swig_const_info *const_table,
23538 swig_type_info **types,
23539 swig_type_info **types_initial) {
23540 size_t i;
23541 for (i = 0; methods[i].ml_name; ++i) {
23542 const char *c = methods[i].ml_doc;
23543 if (!c) continue;
23544 c = strstr(c, "swig_ptr: ");
23545 if (c) {
23546 int j;
23547 swig_const_info *ci = 0;
23548 const char *name = c + 10;
23549 for (j = 0; const_table[j].type; ++j) {
23550 if (strncmp(const_table[j].name, name,
23551 strlen(const_table[j].name)) == 0) {
23552 ci = &(const_table[j]);
23553 break;
23554 }
23555 }
23556 if (ci) {
23557 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23558 if (ptr) {
23559 size_t shift = (ci->ptype) - types;
23560 swig_type_info *ty = types_initial[shift];
23561 size_t ldoc = (c - methods[i].ml_doc);
23562 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23563 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23564 if (ndoc) {
23565 char *buff = ndoc;
23566 memcpy(buff, methods[i].ml_doc, ldoc);
23567 buff += ldoc;
23568 memcpy(buff, "swig_ptr: ", 10);
23569 buff += 10;
23570 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23571 methods[i].ml_doc = ndoc;
23572 }
23573 }
23574 }
23575 }
23576 }
23577 }
23578
23579 #ifdef __cplusplus
23580 }
23581 #endif
23582
23583 /* -----------------------------------------------------------------------------*
23584 * Partial Init method
23585 * -----------------------------------------------------------------------------*/
23586
23587 #ifdef __cplusplus
23588 extern "C"
23589 #endif
23590
23591 SWIGEXPORT
23592 #if PY_VERSION_HEX >= 0x03000000
23593 PyObject*
23594 #else
23595 void
23596 #endif
23597 SWIG_init(void) {
23598 PyObject *m, *d, *md;
23599 #if PY_VERSION_HEX >= 0x03000000
23600 static struct PyModuleDef SWIG_module = {
23601 # if PY_VERSION_HEX >= 0x03020000
23602 PyModuleDef_HEAD_INIT,
23603 # else
23604 {
23605 PyObject_HEAD_INIT(NULL)
23606 NULL, /* m_init */
23607 0, /* m_index */
23608 NULL, /* m_copy */
23609 },
23610 # endif
23611 (char *) SWIG_name,
23612 NULL,
23613 -1,
23614 SwigMethods,
23615 NULL,
23616 NULL,
23617 NULL,
23618 NULL
23619 };
23620 #endif
23621
23622 #if defined(SWIGPYTHON_BUILTIN)
23623 static SwigPyClientData SwigPyObject_clientdata = {
23624 0, 0, 0, 0, 0, 0, 0
23625 };
23626 static PyGetSetDef this_getset_def = {
23627 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23628 };
23629 static SwigPyGetSet thisown_getset_closure = {
23630 SwigPyObject_own,
23631 SwigPyObject_own
23632 };
23633 static PyGetSetDef thisown_getset_def = {
23634 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23635 };
23636 PyTypeObject *builtin_pytype;
23637 int builtin_base_count;
23638 swig_type_info *builtin_basetype;
23639 PyObject *tuple;
23640 PyGetSetDescrObject *static_getset;
23641 PyTypeObject *metatype;
23642 PyTypeObject *swigpyobject;
23643 SwigPyClientData *cd;
23644 PyObject *public_interface, *public_symbol;
23645 PyObject *this_descr;
23646 PyObject *thisown_descr;
23647 PyObject *self = 0;
23648 int i;
23649
23650 (void)builtin_pytype;
23651 (void)builtin_base_count;
23652 (void)builtin_basetype;
23653 (void)tuple;
23654 (void)static_getset;
23655 (void)self;
23656
23657 /* Metaclass is used to implement static member variables */
23658 metatype = SwigPyObjectType();
23659 assert(metatype);
23660 #endif
23661
23662 /* Fix SwigMethods to carry the callback ptrs when needed */
23663 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23664
23665 #if PY_VERSION_HEX >= 0x03000000
23666 m = PyModule_Create(&SWIG_module);
23667 #else
23668 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23669 #endif
23670
23671 md = d = PyModule_GetDict(m);
23672 (void)md;
23673
23674 SWIG_InitializeModule(0);
23675
23676 #ifdef SWIGPYTHON_BUILTIN
23677 swigpyobject = SwigPyObject_TypeOnce();
23678
23679 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23680 assert(SwigPyObject_stype);
23681 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23682 if (!cd) {
23683 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23684 SwigPyObject_clientdata.pytype = swigpyobject;
23685 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23686 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23687 # if PY_VERSION_HEX >= 0x03000000
23688 return NULL;
23689 # else
23690 return;
23691 # endif
23692 }
23693
23694 /* All objects have a 'this' attribute */
23695 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23696 (void)this_descr;
23697
23698 /* All objects have a 'thisown' attribute */
23699 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23700 (void)thisown_descr;
23701
23702 public_interface = PyList_New(0);
23703 public_symbol = 0;
23704 (void)public_symbol;
23705
23706 PyDict_SetItemString(md, "__all__", public_interface);
23707 Py_DECREF(public_interface);
23708 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23709 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23710 for (i = 0; swig_const_table[i].name != 0; ++i)
23711 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23712 #endif
23713
23714 SWIG_InstallConstants(d,swig_const_table);
23715
23716
23717 import_array();
23718
23719 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23720 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23721 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23722 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23723 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23724 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23725 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23726 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23727 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23728 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23729 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23730 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23731 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23732 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23733 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23734 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23735 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23736 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23737 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23738 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23739 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23740 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23741 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23742 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23743 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23744 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23745 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23746 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23747 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23748 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23749 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23750 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23751 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23752 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23753 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23754 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23755 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23756 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23757 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23758 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23759 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23760 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23761 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23762 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23763 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23764 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23765 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23766 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23767 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23768 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23769 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23770 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23771 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23772 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23773 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23774 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23775 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23776 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23777 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23778 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23779 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23780 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23781 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23782 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23783 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23784 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23785 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23786 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23787 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23788 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23789 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23790 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23791 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23792 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23793 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23794 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23795 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23796 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23797 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23798 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23799 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23800 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23801 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23802 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23803 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23804 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23805 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23806 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23807 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23808 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23809 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23810 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23811 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23812 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23813 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23814 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23815 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23816 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23817 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23818 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23819 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23820 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23821 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23822 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23823 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23824 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23825 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23826 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23827 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23828 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23829 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23830 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23831 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23832 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23833 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23834 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23835 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23836 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23837 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23838 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23839 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23840 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23841 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23842 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23843 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23844 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23845 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23846 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23847 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23848 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23849 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23850 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23851 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23852 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23853 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23854 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23855 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23856 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23857 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23858 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23859 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23860 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23861 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23862 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23863 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23864 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23865 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23866 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23867 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23868 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23869 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23870 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23871 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23872 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23873 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23874 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23875 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23876 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23877 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23878 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23879 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23880 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23881 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23882 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23883 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23884 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23885 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23886 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23887 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23888 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23889 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23890 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23891 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23892 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23893 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23894 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23895 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23896 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23897 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23898 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23899 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23900 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23901 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23902 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23903 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23904 #if PY_VERSION_HEX >= 0x03000000
23905 return m;
23906 #else
23907 return;
23908 #endif
23909 }
23910
MY_BLOCK_THREADS
#define MY_BLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3877
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplotcPYTHON_wrap.c:538
SwigPyClientData_New
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1454
SWIG_Python_str_AsChar
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
Definition: plplotcPYTHON_wrap.c:779
SWIG_PYBUFFER_SIZE
#define SWIG_PYBUFFER_SIZE
Definition: plplotcPYTHON_wrap.c:826
SWIG_TMPOBJ
#define SWIG_TMPOBJ
Definition: plplotcPYTHON_wrap.c:296
_wrap_plrandd
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10477
_wrap_plscolbg
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11386
SWIG_PYTHON_THREAD_END_BLOCK
#define SWIG_PYTHON_THREAD_END_BLOCK
Definition: plplotcPYTHON_wrap.c:1091
SWIG_STATIC_POINTER
#define SWIG_STATIC_POINTER(var)
Definition: plplotcPYTHON_wrap.c:1367
SwigPyObject::ptr
PyObject_HEAD void * ptr
Definition: plplotcPYTHON_wrap.c:1518
plplotP.h
_wrap_plflush
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6568
plsfam
#define plsfam
Definition: plplot.h:816
_wrap_plmapfill
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14688
plplotc.plClearOpts
def plClearOpts
Definition: plplotc.py:8448
plw3d
#define plw3d
Definition: plplot.h:862
_swigt__p_f_int_double_p_char_int_p_void__void
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
Definition: plplotcPYTHON_wrap.c:22971
SWIG_CanCastAsInteger
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
Definition: plplotcPYTHON_wrap.c:3153
_wrap_plbox
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5392
_wrap_plconfigtime
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5716
cleanup_PLcGrid1
void cleanup_PLcGrid1(void)
Definition: plplotcPYTHON_wrap.c:3656
plpath
#define plpath
Definition: plplot.h:761
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:22964
_wrap_pltr1
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3724
plplot::maxlen
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
marshal_PLPointer
PLPointer marshal_PLPointer(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:4226
SWIG_UnpackData
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplotcPYTHON_wrap.c:642
plgxax
#define plgxax
Definition: plplot.h:748
_wrap_plscmap0n
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10761
_wrap_plgpage
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7178
SWIG_Python_SetConstant
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1249
SWIG_MangledTypeQuery
#define SWIG_MangledTypeQuery(name)
Definition: plplotcPYTHON_wrap.c:3017
plsstrm
#define plsstrm
Definition: plplot.h:835
NPY_PLINT
#define NPY_PLINT
Definition: plplotcPYTHON_wrap.c:3052
_wrap_plot3dc
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9343
SwigPyObject_getattr
SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj, char *name)
Definition: plplotcPYTHON_wrap.c:1860
SwigPyClientData::pytype
PyTypeObject * pytype
Definition: plplotcPYTHON_wrap.c:1435
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
_wrap_plstyl
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13412
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotcPYTHON_wrap.c:3122
swig_const_info::name
char * name
Definition: plplotcPYTHON_wrap.c:1115
plspage
#define plspage
Definition: plplot.h:831
swig_varlinkobject::vars
PyObject_HEAD swig_globalvar * vars
Definition: plplotcPYTHON_wrap.c:23292
_wrap_plstripa
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13079
_wrap_plGetCursor
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15303
swig_const_info::pvalue
void * pvalue
Definition: plplotcPYTHON_wrap.c:1118
plvpor
#define plvpor
Definition: plplot.h:860
swig_varlinkobject
struct swig_varlinkobject swig_varlinkobject
_wrap_PLGraphicsIn_dX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4728
_wrap_plOptUsage
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15234
_wrap_plscompression
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11494
_wrap_pltimefmt
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13744
swig_varlink_getattr
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
Definition: plplotcPYTHON_wrap.c:23365
do_pltr_callback
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3899
_wrap_plgvpd
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7501
swig_cast_info
struct swig_cast_info swig_cast_info
_wrap_plwind
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14163
swig_const_info::ptype
swig_type_info ** ptype
Definition: plplotcPYTHON_wrap.c:1119
SWIG_AsVal_unsigned_SS_int
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
Definition: plplotcPYTHON_wrap.c:3290
_wrap_plptex
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10294
plmtex3
#define plmtex3
Definition: plplot.h:774
plerry
#define plerry
Definition: plplot.h:715
_wrap_PLGraphicsIn_wX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4802
_wrap_plinit
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7835
plsyax
#define plsyax
Definition: plplot.h:852
swig_const_info::lvalue
long lvalue
Definition: plplotcPYTHON_wrap.c:1116
lenfunc
inquiry lenfunc
Definition: plplotcPYTHON_wrap.c:894
_wrap_plhist
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7701
SWIG_AttributeError
#define SWIG_AttributeError
Definition: plplotcPYTHON_wrap.c:736
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotcPYTHON_wrap.c:597
SwigPyObject_acquire
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1775
swig_const_info::type
int type
Definition: plplotcPYTHON_wrap.c:1114
_wrap_plspal1
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12683
SWIG_PyInstanceMethod_New
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
Definition: plplotcPYTHON_wrap.c:1133
plschr
#define plschr
Definition: plplot.h:790
plsdev
#define plsdev
Definition: plplot.h:806
writebufferproc
getwritebufferproc writebufferproc
Definition: plplotcPYTHON_wrap.c:900
plgdev
#define plgdev
Definition: plplot.h:729
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplotcPYTHON_wrap.c:22979
SWIG_InstallConstants
#define SWIG_InstallConstants(d, constants)
Definition: plplotcPYTHON_wrap.c:23277
SWIG_init
#define SWIG_init
Definition: plplotcPYTHON_wrap.c:3034
SWIG_IndexError
#define SWIG_IndexError
Definition: plplotcPYTHON_wrap.c:729
_wrap_plseed
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11770
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2496
_wrap_plgxax
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7605
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:3125
SWIGUNUSEDPARM
#define SWIGUNUSEDPARM(p)
Definition: plplotcPYTHON_wrap.c:70
_wrap_plspause
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12716
pllegend
#define pllegend
Definition: plplot.h:758
SWIG_Python_CallFunctor
#define SWIG_Python_CallFunctor(functor, obj)
Definition: plplotcPYTHON_wrap.c:1357
SWIG_DivisionByZero
#define SWIG_DivisionByZero
Definition: plplotcPYTHON_wrap.c:731
_wrap_plmap
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14242
SwigMethods
static PyMethodDef SwigMethods[]
Definition: plplotcPYTHON_wrap.c:15325
_wrap_plcont
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5827
_wrap_plmesh
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8920
plshade
#define plshade
Definition: plplot.h:820
swig_globalvar::next
struct swig_globalvar * next
Definition: plplotcPYTHON_wrap.c:23287
plscompression
#define plscompression
Definition: plplot.h:805
SwigPyClientData
Definition: plplotcPYTHON_wrap.c:1428
SWIG_UnpackVoidPtr
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplotcPYTHON_wrap.c:681
plarc
#define plarc
Definition: plplot.h:693
SWIG_Python_addvarlink
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
Definition: plplotcPYTHON_wrap.c:23480
SwigPyPacked_compare
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
Definition: plplotcPYTHON_wrap.c:2074
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
_wrap_plfamadv
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6380
tmpGrid2
static PLcGrid2 tmpGrid2
Definition: plplotcPYTHON_wrap.c:3609
PyHeapTypeObject
Definition: plplotcPYTHON_wrap.c:931
cleanup_mapform
void cleanup_mapform(void)
Definition: plplotcPYTHON_wrap.c:4220
plot3dc
#define plot3dc
Definition: plplot.h:776
_swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
Definition: plplotcPYTHON_wrap.c:22973
SwigPyPacked::size
size_t size
Definition: plplotcPYTHON_wrap.c:2034
_wrap_plline
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8781
_wrap_plbox3
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5464
plot3dcl
#define plot3dcl
Definition: plplot.h:777
_wrap_plmapline
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14326
_wrap_plsetopt
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11812
tmpGrid1
static PLcGrid tmpGrid1
Definition: plplotcPYTHON_wrap.c:3608
SWIG_Python_CheckImplicit
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:1439
pllsty
#define pllsty
Definition: plplot.h:763
plsmin
#define plsmin
Definition: plplot.h:829
plwind
#define plwind
Definition: plplot.h:864
plclear
#define plclear
Definition: plplot.h:701
plfill
#define plfill
Definition: plplot.h:717
plconfigtime
#define plconfigtime
Definition: plplot.h:705
_swigt__p_p_double
static swig_type_info _swigt__p_p_double
Definition: plplotcPYTHON_wrap.c:22976
SWIG_Python_TypeQuery
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
Definition: plplotcPYTHON_wrap.c:2794
_wrap_plbin
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5241
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
SwigPyObject
Definition: plplotcPYTHON_wrap.c:1516
SwigPyClientData::newraw
PyObject * newraw
Definition: plplotcPYTHON_wrap.c:1430
_wrap_plsdev
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11515
SwigPyPacked::pack
PyObject_HEAD void * pack
Definition: plplotcPYTHON_wrap.c:2032
_wrap_plscmap1l
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10942
SWIG_POINTER_NEW
#define SWIG_POINTER_NEW
Definition: plplotcPYTHON_wrap.c:1376
do_ct_callback
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
Definition: plplotcPYTHON_wrap.c:4056
plmapline
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
SwigPyObject_repr
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v, PyObject *args)
Definition: plplotcPYTHON_wrap.c:1588
plbtime
#define plbtime
Definition: plplot.h:699
SWIG_Python_NewPointerObj
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
Definition: plplotcPYTHON_wrap.c:2616
_SWIG_This
SWIGRUNTIMEINLINE PyObject * _SWIG_This(void)
Definition: plplotcPYTHON_wrap.c:2237
_wrap_plctime
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5968
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
swig_module
static swig_module_info swig_module
Definition: plplotcPYTHON_wrap.c:3015
SWIG_TypeName
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:492
_wrap_plpsty
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10273
SWIG_TypeError
#define SWIG_TypeError
Definition: plplotcPYTHON_wrap.c:730
plscolbg
#define plscolbg
Definition: plplot.h:802
SWIG_BUFFER_SIZE
#define SWIG_BUFFER_SIZE
Definition: plplotcPYTHON_wrap.c:191
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:331
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:332
plfont
#define plfont
Definition: plplot.h:720
swig_this
static PyObject * swig_this
Definition: plplotcPYTHON_wrap.c:2242
_wrap_plspage
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12593
plstyl
#define plstyl
Definition: plplot.h:846
_wrap_plsdidev
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11539
plpoly3
#define plpoly3
Definition: plplot.h:782
swig_globalvar
struct swig_globalvar swig_globalvar
Alen
static PLINT Alen
Definition: plplotcPYTHON_wrap.c:3067
SwigPyObject::own
int own
Definition: plplotcPYTHON_wrap.c:1520
plimage
#define plimage
Definition: plplot.h:753
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:339
_wrap_PLGraphicsIn_subwindow_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4483
plfontld
#define plfontld
Definition: plplot.h:721
SWIG_Python_NewPackedObj
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
Definition: plplotcPYTHON_wrap.c:2670
plscolbga
#define plscolbga
Definition: plplot.h:803
_wrap_PLGraphicsIn_button_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4461
Py_NotImplemented
#define Py_NotImplemented
Definition: plplotcPYTHON_wrap.c:858
plbin
#define plbin
Definition: plplot.h:695
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplotcPYTHON_wrap.c:22974
SwigPyPacked_type
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
Definition: plplotcPYTHON_wrap.c:2085
_wrap_plMinMax2dGrid
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15246
marshal_ct
ct_func marshal_ct(PyObject *input)
Definition: plplotcPYTHON_wrap.c:4197
plsdiori
#define plsdiori
Definition: plplot.h:809
SWIG_Python_ConvertPtr
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1156
SwigPyPacked_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:2107
_wrap_plend1
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6086
SWIGEXPORT
#define SWIGEXPORT
Definition: plplotcPYTHON_wrap.c:104
_wrap_pljoin
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7847
swig_globalvar::name
char * name
Definition: plplotcPYTHON_wrap.c:23284
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
plparseopts
#define plparseopts
Definition: plplot.h:778
SWIG_Python_AddErrMesg
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
Definition: plplotcPYTHON_wrap.c:2831
SWIG_IOError
#define SWIG_IOError
Definition: plplotcPYTHON_wrap.c:727
plmaptex
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
plsym
#define plsym
Definition: plplot.h:853
plscmap1
#define plscmap1
Definition: plplot.h:794
_wrap_plbtime
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5299
plinit
#define plinit
Definition: plplot.h:755
SWIG_Python_InstallConstants
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
Definition: plplotcPYTHON_wrap.c:23509
swig_varlink_repr
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
Definition: plplotcPYTHON_wrap.c:23296
plctime
#define plctime
Definition: plplot.h:708
pltimefmt
#define pltimefmt
Definition: plplot.h:856
plscmap1n
#define plscmap1n
Definition: plplot.h:798
_wrap_plscmap1
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10782
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplotcPYTHON_wrap.c:552
_wrap_plsfont
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11933
SwigPyObject::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:1519
_wrap_plbop
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5380
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplotcPYTHON_wrap.c:22977
plbop
#define plbop
Definition: plplot.h:696
SWIG_Python_ExceptionType
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
Definition: plplotcPYTHON_wrap.c:1446
Ylen
static PLINT Ylen
Definition: plplotcPYTHON_wrap.c:3068
_swigt__p_f_double_double__int
static swig_type_info _swigt__p_f_double_double__int
Definition: plplotcPYTHON_wrap.c:22969
plplotc.pltr0
def pltr0
Definition: plplotc.py:101
python_label
PyObject * python_label
Definition: plplotcPYTHON_wrap.c:3860
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplotcPYTHON_wrap.c:694
SWIG_AsVal_double
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
Definition: plplotcPYTHON_wrap.c:3072
plsdiplt
#define plsdiplt
Definition: plplot.h:810
plsvect
#define plsvect
Definition: plplot.h:849
plscmap1a
#define plscmap1a
Definition: plplot.h:795
plssub
#define plssub
Definition: plplot.h:836
SWIG_DelNewMask
#define SWIG_DelNewMask(r)
Definition: plplotcPYTHON_wrap.c:299
SWIG_NewPointerObj
#define SWIG_NewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1163
_wrap_plsmin
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12542
swig_globalvar
Definition: plplotcPYTHON_wrap.c:23283
_wrap_PLGraphicsIn_string_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4566
_wrap_plmtex3
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9188
_wrap_plpoin3
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10067
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotcPYTHON_wrap.c:3124
SWIG_POINTER_OWN
#define SWIG_POINTER_OWN
Definition: plplotcPYTHON_wrap.c:199
SWIG_TypePrettyName
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplotcPYTHON_wrap.c:501
_swigc__p_p_double
static swig_cast_info _swigc__p_p_double[]
Definition: plplotcPYTHON_wrap.c:23008
_wrap_plgcol0
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6654
pltr_xg
PyArrayObject * pltr_xg
Definition: plplotcPYTHON_wrap.c:3607
SwigPyClientData::implicitconv
int implicitconv
Definition: plplotcPYTHON_wrap.c:1434
PLPointer
void * PLPointer
Definition: plplot.h:209
plspal1
#define plspal1
Definition: plplot.h:833
plsetopt
#define plsetopt
Definition: plplot.h:815
_wrap_plenv
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6098
SWIG_OLDOBJ
#define SWIG_OLDOBJ
Definition: plplotcPYTHON_wrap.c:294
marshal_pltr
pltr_func marshal_pltr(PyObject *input)
Definition: plplotcPYTHON_wrap.c:4138
_swigc__p_PLcGrid2
static swig_cast_info _swigc__p_PLcGrid2[]
Definition: plplotcPYTHON_wrap.c:22998
plmeshc
#define plmeshc
Definition: plplot.h:771
_wrap_plshades
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11972
plgcompression
#define plgcompression
Definition: plplot.h:728
_wrap_plot3d
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9251
_wrap_plpath
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9952
plszax
#define plszax
Definition: plplot.h:854
plvsta
#define plvsta
Definition: plplot.h:861
_wrap_PLGraphicsIn_state_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4357
SWIG_TypeQuery
#define SWIG_TypeQuery(name)
Definition: plplotcPYTHON_wrap.c:3016
_wrap_PLGraphicsIn_wY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4884
_wrap_plgfam
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7029
SWIG_Python_str_FromChar
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
Definition: plplotcPYTHON_wrap.c:804
SWIG_Python_str_DelForPy3
#define SWIG_Python_str_DelForPy3(x)
Definition: plplotcPYTHON_wrap.c:799
PyHeapTypeObject::as_mapping
PyMappingMethods as_mapping
Definition: plplotcPYTHON_wrap.c:934
swig_varlink_dealloc
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
Definition: plplotcPYTHON_wrap.c:23354
SWIG_FromCharPtrAndSize
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
Definition: plplotcPYTHON_wrap.c:3464
swig_varlink_setattr
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
Definition: plplotcPYTHON_wrap.c:23382
plgpage
#define plgpage
Definition: plplot.h:739
plaxes
#define plaxes
Definition: plplot.h:694
SWIG_OK
#define SWIG_OK
Definition: plplotcPYTHON_wrap.c:281
SwigPyPacked_Check
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:2091
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplotcPYTHON_wrap.c:1191
plsori
#define plsori
Definition: plplot.h:830
_wrap_plpoin
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10009
SWIG_IsTmpObj
#define SWIG_IsTmpObj(r)
Definition: plplotcPYTHON_wrap.c:303
_wrap_plfont
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6580
_wrap_pllightsource
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8742
_wrap_pleop
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6230
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplotcPYTHON_wrap.c:522
SwigPyPacked_dealloc
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
Definition: plplotcPYTHON_wrap.c:2097
SWIG_as_voidptrptr
#define SWIG_as_voidptrptr(a)
Definition: plplotcPYTHON_wrap.c:3044
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplotcPYTHON_wrap.c:81
_wrap_plgdidev
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6903
plgdiplt
#define plgdiplt
Definition: plplot.h:732
_wrap_plmtex
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9125
_wrap_plvsta
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14019
plscmap0a
#define plscmap0a
Definition: plplot.h:792
SWIG_PY_BINARY
#define SWIG_PY_BINARY
Definition: plplotcPYTHON_wrap.c:1110
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplotcPYTHON_wrap.c:23000
SwigPyObject_own
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
Definition: plplotcPYTHON_wrap.c:1798
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
SWIG_RuntimeError
#define SWIG_RuntimeError
Definition: plplotcPYTHON_wrap.c:728
swig_type_info
struct swig_type_info swig_type_info
plfamadv
#define plfamadv
Definition: plplot.h:716
SWIG_Python_ConvertPtrAndOwn
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
Definition: plplotcPYTHON_wrap.c:2341
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplotcPYTHON_wrap.c:22975
SWIG_BUILTIN_TP_INIT
#define SWIG_BUILTIN_TP_INIT
Definition: plplotcPYTHON_wrap.c:1380
PyString_AsStringAndSize
#define PyString_AsStringAndSize(obj, s, len)
Definition: plplotcPYTHON_wrap.c:865
_wrap_plscol0a
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11329
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:350
plend
#define plend
Definition: plplot.h:709
_wrap_plglevel
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7156
SWIG_ConvertPtr
#define SWIG_ConvertPtr(obj, pptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1157
_wrap_plstring
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12937
SWIG_Python_str_FromFormat
#define SWIG_Python_str_FromFormat
Definition: plplotcPYTHON_wrap.c:771
SWIG_Python_ConvertPacked
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2478
_wrap_plmkstrm
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9103
_wrap_new_PLGraphicsIn
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4906
_wrap_plsyax
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13614
plsmem
#define plsmem
Definition: plplot.h:827
plgfont
#define plgfont
Definition: plplot.h:737
plplotc.plSetUsage
def plSetUsage
Definition: plplotc.py:8456
_swigc__p_f_int_double_p_char_int_p_void__void
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
Definition: plplotcPYTHON_wrap.c:23003
plend1
#define plend1
Definition: plplot.h:710
SWIG_POINTER_NOSHADOW
#define SWIG_POINTER_NOSHADOW
Definition: plplotcPYTHON_wrap.c:1375
PLINT
int PLINT
Definition: plplot.h:181
plenv0
#define plenv0
Definition: plplot.h:712
_wrap_PLGraphicsIn_type_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4275
python_f2eval
PyObject * python_f2eval
Definition: plplotcPYTHON_wrap.c:3857
PySequence_Size
#define PySequence_Size
Definition: plplotcPYTHON_wrap.c:3064
_wrap_pltr2
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3787
_wrap_plgcolbga
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6808
plgdiori
#define plgdiori
Definition: plplot.h:731
SWIG_Python_SetModule
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
Definition: plplotcPYTHON_wrap.c:2761
PyString_FromFormat
static PyObject * PyString_FromFormat(const char *fmt,...)
Definition: plplotcPYTHON_wrap.c:830
plshades
#define plshades
Definition: plplot.h:824
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
charbufferproc
getcharbufferproc charbufferproc
Definition: plplotcPYTHON_wrap.c:902
_wrap_plsmema
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12499
marshal_PLcGrid1
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3616
swig_const_info::dvalue
double dvalue
Definition: plplotcPYTHON_wrap.c:1117
_wrap_plscmap1_range
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11219
plssym
#define plssym
Definition: plplot.h:837
swig_const_table
static swig_const_info swig_const_table[]
Definition: plplotcPYTHON_wrap.c:23031
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
SwigPyPacked
Definition: plplotcPYTHON_wrap.c:2030
pljoin
#define pljoin
Definition: plplot.h:756
plgzax
#define plgzax
Definition: plplot.h:750
_wrap_PLGraphicsIn_dX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4698
SWIG_name
#define SWIG_name
Definition: plplotcPYTHON_wrap.c:3037
SWIG_Python_ConvertFunctionPtr
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2446
_wrap_plgdev
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6882
_wrap_plsvpa
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13536
plgfam
#define plgfam
Definition: plplot.h:734
do_mapform_callback
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplotcPYTHON_wrap.c:4097
_wrap_pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4968
_wrap_plsmem
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12456
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplotcPYTHON_wrap.c:22967
ssizeargfunc
intargfunc ssizeargfunc
Definition: plplotcPYTHON_wrap.c:895
SWIG_AddNewMask
#define SWIG_AddNewMask(r)
Definition: plplotcPYTHON_wrap.c:298
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
plgdidev
#define plgdidev
Definition: plplot.h:730
SWIG_fail
#define SWIG_fail
Definition: plplotcPYTHON_wrap.c:1199
_wrap_plmapstring
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14435
plstar
#define plstar
Definition: plplot.h:838
_wrap_plstring3
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12998
swig_varlink_type
SWIGINTERN PyTypeObject * swig_varlink_type(void)
Definition: plplotcPYTHON_wrap.c:23399
SWIG_Python_DestroyModule
SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr)
Definition: plplotcPYTHON_wrap.c:2739
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplotcPYTHON_wrap.c:374
_swigt__p_PLcGrid
static swig_type_info _swigt__p_PLcGrid
Definition: plplotcPYTHON_wrap.c:22965
_wrap_plerry
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6311
SwigPyObject_compare
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
Definition: plplotcPYTHON_wrap.c:1620
SWIG_AsVal_long
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
Definition: plplotcPYTHON_wrap.c:3183
plcpstrm
#define plcpstrm
Definition: plplot.h:707
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplotcPYTHON_wrap.c:3120
_wrap_plparseopts
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9835
plimagefr
#define plimagefr
Definition: plplot.h:754
plcalc_world
#define plcalc_world
Definition: plplot.h:700
_wrap_plxormod
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14211
PyHeapTypeObject::as_number
PyNumberMethods as_number
Definition: plplotcPYTHON_wrap.c:933
CB_2
Definition: plplotcPYTHON_wrap.c:3855
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplotcPYTHON_wrap.c:670
plsfnam
#define plsfnam
Definition: plplot.h:818
plhist
#define plhist
Definition: plplot.h:751
_wrap_plfill3
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6441
_wrap_plsdimap
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11587
SWIG_SystemError
#define SWIG_SystemError
Definition: plplotcPYTHON_wrap.c:735
_wrap_plgcol0a
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6705
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplotcPYTHON_wrap.c:478
PLcGrid
Definition: plplot.h:506
_wrap_plResetOpts
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15186
_wrap_plSetUsage
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15198
_wrap_plslabelfunc
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12379
PyBool_FromLong
static PyObject * PyBool_FromLong(long ok)
Definition: plplotcPYTHON_wrap.c:879
plgchr
#define plgchr
Definition: plplot.h:722
SWIG_OverflowError
#define SWIG_OverflowError
Definition: plplotcPYTHON_wrap.c:732
_wrap_plimage
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14887
SWIG_Python_MustGetPtr
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
Definition: plplotcPYTHON_wrap.c:2918
_wrap_plsurf3d
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9589
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:351
_swigc__p_f_double_double_p_double_p_double_p_void__void
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
Definition: plplotcPYTHON_wrap.c:23002
_wrap_PLGraphicsIn_keysym_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4409
plsdidev
#define plsdidev
Definition: plplot.h:807
SWIG_AsVal_unsigned_SS_long
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
Definition: plplotcPYTHON_wrap.c:3242
plspal0
#define plspal0
Definition: plplot.h:832
SwigPyObject_New
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
Definition: plplotcPYTHON_wrap.c:2014
plfill3
#define plfill3
Definition: plplot.h:718
_wrap_plmeridians
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14797
PyHeapTypeObject::type
PyTypeObject type
Definition: plplotcPYTHON_wrap.c:932
plsmema
#define plsmema
Definition: plplot.h:828
_wrap_plgyax
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7637
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplotcPYTHON_wrap.c:334
SWIG_From_int
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
Definition: plplotcPYTHON_wrap.c:3130
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:340
PySequence_Fast_GET_ITEM
#define PySequence_Fast_GET_ITEM
Definition: plplotcPYTHON_wrap.c:3062
_wrap_PLGraphicsIn_pY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4646
SWIG_Python_AppendOutput
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1263
_wrap_plfill
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6392
SWIG_MemoryError
#define SWIG_MemoryError
Definition: plplotcPYTHON_wrap.c:737
SWIG_Python_TypeCache
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
Definition: plplotcPYTHON_wrap.c:2788
plseed
#define plseed
Definition: plplot.h:813
plplotc.plOptUsage
def plOptUsage
Definition: plplotc.py:8460
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plstring
#define plstring
Definition: plplot.h:841
SwigPyObject_richcompare
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
Definition: plplotcPYTHON_wrap.c:1629
plstransform
#define plstransform
Definition: plplot.h:840
plvect
#define plvect
Definition: plplot.h:858
_wrap_plgchr
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6622
PyHeapTypeObject::as_buffer
PyBufferProcs as_buffer
Definition: plplotcPYTHON_wrap.c:936
python_ct
PyObject * python_ct
Definition: plplotcPYTHON_wrap.c:3858
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplotcPYTHON_wrap.c:23238
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplotcPYTHON_wrap.c:1192
_wrap_plgradient
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6510
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplotcPYTHON_wrap.c:22968
SWIG_Python_InitShadowInstance
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
Definition: plplotcPYTHON_wrap.c:2598
swig_globalvar::set_attr
int(* set_attr)(PyObject *)
Definition: plplotcPYTHON_wrap.c:23286
SWIG_exception_fail
#define SWIG_exception_fail(code, msg)
Definition: plplotcPYTHON_wrap.c:2992
ssizessizeargfunc
intintargfunc ssizessizeargfunc
Definition: plplotcPYTHON_wrap.c:896
plplotc.plResetOpts
def plResetOpts
Definition: plplotc.py:8452
SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
Definition: plplotcPYTHON_wrap.c:1090
PLcGrid2
Definition: plplot.h:518
plscmap1la
#define plscmap1la
Definition: plplot.h:797
_wrap_plsxwin
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4947
plgfnam
#define plgfnam
Definition: plplot.h:736
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplotcPYTHON_wrap.c:169
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplotcPYTHON_wrap.c:626
_wrap_plscolbga
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11425
plcont
#define plcont
Definition: plplot.h:706
plsxax
#define plsxax
Definition: plplot.h:851
plstart
#define plstart
Definition: plplot.h:839
SWIG_AsCharPtrAndSize
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
Definition: plplotcPYTHON_wrap.c:3326
SWIG_NEWOBJ
#define SWIG_NEWOBJ
Definition: plplotcPYTHON_wrap.c:295
SwigPyClientData_Del
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
Definition: plplotcPYTHON_wrap.c:1508
pleop
#define pleop
Definition: plplot.h:713
plmesh
#define plmesh
Definition: plplot.h:770
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:349
SWIG_Py_Void
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
Definition: plplotcPYTHON_wrap.c:1419
swig_globalvar::get_attr
PyObject *(* get_attr)(void)
Definition: plplotcPYTHON_wrap.c:23285
segcountproc
getsegcountproc segcountproc
Definition: plplotcPYTHON_wrap.c:901
PyInt_FromSize_t
#define PyInt_FromSize_t(x)
Definition: plplotcPYTHON_wrap.c:916
plsmaj
#define plsmaj
Definition: plplot.h:826
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
_wrap_plsym
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13644
callback_type
callback_type
Definition: plplotcPYTHON_wrap.c:3855
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplotcPYTHON_wrap.c:23009
swigobject_methods
static PyMethodDef swigobject_methods[]
Definition: plplotcPYTHON_wrap.c:1847
_wrap_plfontld
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6601
_wrap_pltext
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13732
_swigc__p_f_double_double__int
static swig_cast_info _swigc__p_f_double_double__int[]
Definition: plplotcPYTHON_wrap.c:23001
_wrap_plgfnam
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7093
_swigt__p_PLcGrid2
static swig_type_info _swigt__p_PLcGrid2
Definition: plplotcPYTHON_wrap.c:22966
SWIG_Python_newvarlink
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
Definition: plplotcPYTHON_wrap.c:23471
_wrap_plenv0
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6164
plcol1
#define plcol1
Definition: plplot.h:703
pllab
#define pllab
Definition: plplot.h:757
pllightsource
#define pllightsource
Definition: plplot.h:759
PyObject_DEL
#define PyObject_DEL
Definition: plplotcPYTHON_wrap.c:842
_wrap_PLGraphicsIn_pX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4594
SWIG_Python_SetErrorMsg
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
Definition: plplotcPYTHON_wrap.c:1215
SwigPyObject_format
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1551
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplotcPYTHON_wrap.c:161
plbox
#define plbox
Definition: plplot.h:697
do_label_callback
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3999
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotcPYTHON_wrap.c:3121
_wrap_plgfont
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7114
pltext
#define pltext
Definition: plplot.h:855
SwigPyObject_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:1867
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplotcPYTHON_wrap.c:333
_wrap_plvpor
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13971
swig_cast_info
Definition: plplotluacLUA_wrap.c:338
SWIG_CAST_NEW_MEMORY
#define SWIG_CAST_NEW_MEMORY
Definition: plplotcPYTHON_wrap.c:196
_wrap_plsdiori
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11653
SWIG_pchar_descriptor
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
Definition: plplotcPYTHON_wrap.c:3313
swig_const_info
Definition: plplotcPYTHON_wrap.c:1113
plwidth
#define plwidth
Definition: plplot.h:863
SwigPyObject_Check
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:1663
plgver
#define plgver
Definition: plplot.h:745
SWIG_POINTER_IMPLICIT_CONV
#define SWIG_POINTER_IMPLICIT_CONV
Definition: plplotcPYTHON_wrap.c:1378
python_pltr
PyObject * python_pltr
Definition: plplotcPYTHON_wrap.c:3856
_wrap_plline3
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8830
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:416
_wrap_plcol1
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5695
SWIG_From_unsigned_SS_int
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
Definition: plplotcPYTHON_wrap.c:3306
plscol0a
#define plscol0a
Definition: plplot.h:801
SwigPyObject_disown
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1763
plptex3
#define plptex3
Definition: plplot.h:786
plsdiplz
#define plsdiplz
Definition: plplot.h:811
cleanup_PLcGrid2
void cleanup_PLcGrid2(void)
Definition: plplotcPYTHON_wrap.c:3715
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
_wrap_plvpas
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13914
buf
static char buf[200]
Definition: tclAPI.c:873
CB_0
Definition: plplotcPYTHON_wrap.c:3855
SWIG_NewClientData
#define SWIG_NewClientData(obj)
Definition: plplotcPYTHON_wrap.c:1193
SWIG_ERROR
#define SWIG_ERROR
Definition: plplotcPYTHON_wrap.c:282
swig_varlinkobject
Definition: plplotcPYTHON_wrap.c:23290
plspause
#define plspause
Definition: plplot.h:834
_wrap_PLGraphicsIn_pY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4676
_wrap_plgcmap1_range
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11249
SwigPyObject_next
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1748
PyOS_snprintf
#define PyOS_snprintf
Definition: plplotcPYTHON_wrap.c:818
plline3
#define plline3
Definition: plplot.h:762
_wrap_PLGraphicsIn_pX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4624
plplotc.plsxwin
def plsxwin
Definition: plplotc.py:364
plstripd
#define plstripd
Definition: plplot.h:845
plgfci
#define plgfci
Definition: plplot.h:735
SWIG_AsVal_int
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
Definition: plplotcPYTHON_wrap.c:3226
plgspa
#define plgspa
Definition: plplot.h:743
plgcolbg
#define plgcolbg
Definition: plplot.h:726
plstripc
#define plstripc
Definition: plplot.h:844
_wrap_plgzax
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7669
SWIG_NewPackedObj
#define SWIG_NewPackedObj(ptr, sz, type)
Definition: plplotcPYTHON_wrap.c:1174
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:330
_wrap_plstart
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12848
SWIG_Python_GetModule
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
Definition: plplotcPYTHON_wrap.c:2683
plstripa
#define plstripa
Definition: plplot.h:843
_wrap_plgfci
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7071
CB_1
Definition: plplotcPYTHON_wrap.c:3855
_wrap_plrgbhls
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10502
plstring3
#define plstring3
Definition: plplot.h:842
cleanup_PLPointer
void cleanup_PLPointer(void)
Definition: plplotcPYTHON_wrap.c:4251
_wrap_plshade
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12157
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplotcPYTHON_wrap.c:408
plvpas
#define plvpas
Definition: plplot.h:859
_wrap_plsfnam
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11909
_wrap_plgdiplt
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6977
_wrap_delete_PLGraphicsIn
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4919
SwigPyObject_GetDesc
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
Definition: plplotcPYTHON_wrap.c:2871
_wrap_plw3d
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14031
PyModule_AddObject
SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o)
Definition: plplotcPYTHON_wrap.c:2709
freefunc
destructor freefunc
Definition: plplotcPYTHON_wrap.c:942
SWIG_ValueError
#define SWIG_ValueError
Definition: plplotcPYTHON_wrap.c:734
PyHeapTypeObject::as_sequence
PySequenceMethods as_sequence
Definition: plplotcPYTHON_wrap.c:935
PyHeapTypeObject::slots
PyObject * slots
Definition: plplotcPYTHON_wrap.c:937
plplotc.plMinMax2dGrid
def plMinMax2dGrid
Definition: plplotc.py:8464
plsfont
#define plsfont
Definition: plplot.h:819
plmapfill
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
PyObject_GenericGetAttr
#define PyObject_GenericGetAttr
Definition: plplotcPYTHON_wrap.c:851
swig_varlink_str
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
Definition: plplotcPYTHON_wrap.c:23305
SWIG_Python_GetSwigThis
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
Definition: plplotcPYTHON_wrap.c:2260
Xlen
static PLINT Xlen
Definition: plplotcPYTHON_wrap.c:3068
SwigPyObject_append
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
Definition: plplotcPYTHON_wrap.c:1730
plpsty
#define plpsty
Definition: plplot.h:784
MY_UNBLOCK_THREADS
#define MY_UNBLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3878
_wrap_plszax
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13702
_wrap_plstransform
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12890
SwigPyPacked_UnpackData
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
Definition: plplotcPYTHON_wrap.c:2220
swig_module_info
struct swig_module_info swig_module_info
SWIG_strnlen
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
Definition: plplotcPYTHON_wrap.c:3493
_wrap_plvasp
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13768
plgvpd
#define plgvpd
Definition: plplot.h:746
plpoin
#define plpoin
Definition: plplot.h:780
plgriddata
#define plgriddata
Definition: plplot.h:742
_swigt__p_f_double_double_p_double_p_double_p_void__void
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
Definition: plplotcPYTHON_wrap.c:22970
plgvpw
#define plgvpw
Definition: plplot.h:747
_wrap_plerrx
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6242
SWIG_Python_SetSwigThis
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
Definition: plplotcPYTHON_wrap.c:2576
_wrap_plschr
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10571
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:3000
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplotcPYTHON_wrap.c:283
_wrap_PLGraphicsIn_dY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4750
_wrap_plstar
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12818
_wrap_plpoly3
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10145
_wrap_PLGraphicsIn_type_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4305
max
int max(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2492
_wrap_plimagefr
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15014
_wrap_plgcompression
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6860
SWIG_Python_ArgFail
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
Definition: plplotcPYTHON_wrap.c:2858
_wrap_plgcolbg
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6766
_wrap_plclear
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5662
cleanup_pltr
void cleanup_pltr(void)
Definition: plplotcPYTHON_wrap.c:4190
SwigPyObject_dealloc
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
Definition: plplotcPYTHON_wrap.c:1679
_swigc__p_f_int_p_double_p_double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
Definition: plplotcPYTHON_wrap.c:23004
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplotcPYTHON_wrap.c:323
_wrap_plsstrm
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12737
pltr_yg
PyArrayObject * pltr_yg
Definition: plplotcPYTHON_wrap.c:3607
swig_types
static swig_type_info * swig_types[15]
Definition: plplotcPYTHON_wrap.c:3014
t_output_helper
#define t_output_helper
Definition: plplotcPYTHON_wrap.c:3505
_wrap_plscol0
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11281
_wrap_plssym
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12788
plmkstrm
#define plmkstrm
Definition: plplot.h:772
PL_UNUSED
#define PL_UNUSED(x)
Definition: plplot.h:138
ssizessizeobjargproc
intintobjargproc ssizessizeobjargproc
Definition: plplotcPYTHON_wrap.c:898
SWIG_InternalNewPointerObj
#define SWIG_InternalNewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1166
PLFLT
float PLFLT
Definition: plplot.h:163
_wrap_plcalc_world
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5602
plscol0
#define plscol0
Definition: plplot.h:800
plplotc.pltr2
def pltr2
Definition: plplotc.py:109
swig_type_info
Definition: plplotluacLUA_wrap.c:328
SwigPyPacked_New
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2201
plxormod
#define plxormod
Definition: plplot.h:865
_wrap_plscolor
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11473
Py_TYPE
#define Py_TYPE(op)
Definition: plplotcPYTHON_wrap.c:763
plflush
#define plflush
Definition: plplot.h:719
plerrx
#define plerrx
Definition: plplot.h:714
cleanup_ct
void cleanup_ct(void)
Definition: plplotcPYTHON_wrap.c:4205
plgcol0a
#define plgcol0a
Definition: plplot.h:725
SWIG_AsCharArray
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
Definition: plplotcPYTHON_wrap.c:3439
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:3126
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplotcPYTHON_wrap.c:23011
SWIG_This
SWIGRUNTIME PyObject * SWIG_This(void)
Definition: plplotcPYTHON_wrap.c:2245
readbufferproc
getreadbufferproc readbufferproc
Definition: plplotcPYTHON_wrap.c:899
plgcolbga
#define plgcolbga
Definition: plplot.h:727
myArray_ContiguousFromObject
#define myArray_ContiguousFromObject
Definition: plplotcPYTHON_wrap.c:3550
SWIG_Python_ErrorType
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
Definition: plplotcPYTHON_wrap.c:963
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplotcPYTHON_wrap.c:22996
SwigPyObject_oct
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1573
SWIG_ArgError
#define SWIG_ArgError(r)
Definition: plplotcPYTHON_wrap.c:284
_wrap_plgspa
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7406
_wrap_plcpstrm
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6044
_wrap_pllegend
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7943
plgyax
#define plgyax
Definition: plplot.h:749
_wrap_PLGraphicsIn_subwindow_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4513
plsesc
#define plsesc
Definition: plplot.h:814
_wrap_PLGraphicsIn_dY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4780
_wrap_plsfci
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11888
plenv
#define plenv
Definition: plplot.h:711
Py_ssize_t
int Py_ssize_t
Definition: plplotcPYTHON_wrap.c:891
SWIG_newvarlink
#define SWIG_newvarlink()
Definition: plplotcPYTHON_wrap.c:23275
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:341
_wrap_plmaptex
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14556
_wrap_plsori
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12572
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:334
marshal_PLcGrid2
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3663
_swigt__p_f_int_p_double_p_double__void
static swig_type_info _swigt__p_f_int_p_double_p_double__void
Definition: plplotcPYTHON_wrap.c:22972
_wrap_plot3dcl
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9443
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplotcPYTHON_wrap.c:195
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
_wrap_plcol0
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5674
SWIG_Python_AcquirePtr
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
Definition: plplotcPYTHON_wrap.c:2326
plcol0
#define plcol0
Definition: plplot.h:702
_wrap_pllsty
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8899
plbox3
#define plbox3
Definition: plplot.h:698
SwigPyPacked_str
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
Definition: plplotcPYTHON_wrap.c:2063
swig_varlink_print
SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
Definition: plplotcPYTHON_wrap.c:23343
_wrap_pllab
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7895
SWIG_From_double
#define SWIG_From_double
Definition: plplotcPYTHON_wrap.c:3117
plcolorbar
#define plcolorbar
Definition: plplot.h:704
_swigc__p_PLcGrid
static swig_cast_info _swigc__p_PLcGrid[]
Definition: plplotcPYTHON_wrap.c:22997
PyNumber_AsSsize_t
static long PyNumber_AsSsize_t(PyObject *x, void *SWIGUNUSEDPARM(exc))
Definition: plplotcPYTHON_wrap.c:903
SwigPyPacked::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:2033
ssizeobjargproc
intobjargproc ssizeobjargproc
Definition: plplotcPYTHON_wrap.c:897
SwigPyObject_long
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1545
_wrap_plhlsrgb
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7766
plglevel
#define plglevel
Definition: plplot.h:738
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
_wrap_plreplot
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10490
plpoin3
#define plpoin3
Definition: plplot.h:781
_wrap_plsmaj
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12426
_wrap_plwidth
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14142
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SWIG_Python_TypeError
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:2879
plscolor
#define plscolor
Definition: plplot.h:804
plsvpa
#define plsvpa
Definition: plplot.h:850
_wrap_plprec
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10243
_wrap_plsurf3dl
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9689
_wrap_plarc
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5067
tail
static tclMatrixXtnsnDescr * tail
Definition: tclMatrix.c:461
plpat
#define plpat
Definition: plplot.h:779
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
_wrap_PLGraphicsIn_button_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4431
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SwigPyPacked_repr
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
Definition: plplotcPYTHON_wrap.c:2052
SWIGINTERN
#define SWIGINTERN
Definition: plplotcPYTHON_wrap.c:76
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:342
SWIG_IsNewObj
#define SWIG_IsNewObj(r)
Definition: plplotcPYTHON_wrap.c:300
plgcol0
#define plgcol0
Definition: plplot.h:724
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplotcPYTHON_wrap.c:470
_wrap_plcolorbar
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8426
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplotcPYTHON_wrap.c:23091
python_mapform
PyObject * python_mapform
Definition: plplotcPYTHON_wrap.c:3859
plreplot
#define plreplot
Definition: plplot.h:788
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:353
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplotcPYTHON_wrap.c:186
SwigPyObject::next
PyObject * next
Definition: plplotcPYTHON_wrap.c:1521
_wrap_plgstrm
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7458
_wrap_plvect
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13789
SWIG_as_voidptr
#define SWIG_as_voidptr(a)
Definition: plplotcPYTHON_wrap.c:3043
_wrap_plptex3
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10363
SWIG_Python_NewShadowInstance
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
Definition: plplotcPYTHON_wrap.c:2501
SWIGTYPE_p_int
#define SWIGTYPE_p_int
Definition: plplotcPYTHON_wrap.c:3010
_wrap_PLGraphicsIn_state_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4327
SWIG_Python_AddErrorMsg
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
Definition: plplotcPYTHON_wrap.c:1007
plscmap1l
#define plscmap1l
Definition: plplot.h:796
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
plprec
#define plprec
Definition: plplot.h:783
plptex
#define plptex
Definition: plplot.h:785
_wrap_PLGraphicsIn_wY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4854
plline
#define plline
Definition: plplot.h:760
SwigPyClientData::newargs
PyObject * newargs
Definition: plplotcPYTHON_wrap.c:1431
_wrap_plscmap0a
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10671
SWIG_Python_FixMethods
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
Definition: plplotcPYTHON_wrap.c:23536
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
SWIG_Python_SetErrorObj
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1207
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:443
pltr_type
enum callback_type pltr_type
_wrap_plgvpw
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7553
SWIG_SyntaxError
#define SWIG_SyntaxError
Definition: plplotcPYTHON_wrap.c:733
plgradient
#define plgradient
Definition: plplot.h:741
do_f2eval_callback
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3962
SwigPyPacked_print
SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
Definition: plplotcPYTHON_wrap.c:2038
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:352
_wrap_plscmap0
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10601
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplotcPYTHON_wrap.c:182
plplot.h
_wrap_plspal0
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12659
SWIG_AsVal_char
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
Definition: plplotcPYTHON_wrap.c:3509
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplotcPYTHON_wrap.c:23007
_wrap_plmeshc
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9003
SwigPyObject_repr2
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1614
NPY_PLFLT
#define NPY_PLFLT
Definition: plplotcPYTHON_wrap.c:3057
_wrap_pladv
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5046
pladv
#define pladv
Definition: plplot.h:692
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:329
_wrap_plstripd
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13391
SwigPyObject_hex
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1579
_wrap_plsfam
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11849
SWIGTYPE_p_double
#define SWIGTYPE_p_double
Definition: plplotcPYTHON_wrap.c:3004
_wrap_plgra
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7250
plvasp
#define plvasp
Definition: plplot.h:857
plrandd
#define plrandd
Definition: plplot.h:787
SWIG_PY_POINTER
#define SWIG_PY_POINTER
Definition: plplotcPYTHON_wrap.c:1109
_wrap_plsxax
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13584
SwigPyClientData::destroy
PyObject * destroy
Definition: plplotcPYTHON_wrap.c:1432
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplotcPYTHON_wrap.c:322
SWIG_UnpackDataName
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplotcPYTHON_wrap.c:709
plscmap0
#define plscmap0
Definition: plplot.h:791
_wrap_plssub
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12758
plmapstring
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
plgstrm
#define plgstrm
Definition: plplot.h:744
_wrap_plaxes
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5151
SWIGTYPE_p_unsigned_int
#define SWIGTYPE_p_unsigned_int
Definition: plplotcPYTHON_wrap.c:3013
plsfci
#define plsfci
Definition: plplot.h:817
_wrap_plgdiori
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6955
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:333
_wrap_pl_setcontlabelparam
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4998
_swigc__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
Definition: plplotcPYTHON_wrap.c:23005
swig_module_info
Definition: plplotluacLUA_wrap.c:348
SwigPyClientData::klass
PyObject * klass
Definition: plplotcPYTHON_wrap.c:1429
PLGraphicsIn::string
char string[PL_MAXKEY]
Definition: plplot.h:440
_wrap_plgver
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7480
plmtex
#define plmtex
Definition: plplot.h:773
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplotcPYTHON_wrap.c:23006
plrgbhls
#define plrgbhls
Definition: plplot.h:789
plsurf3d
#define plsurf3d
Definition: plplot.h:847
SWIG_Python_UnpackTuple
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
Definition: plplotcPYTHON_wrap.c:1308
marshal_mapform
mapform_func marshal_mapform(PyObject *input)
Definition: plplotcPYTHON_wrap.c:4212
plplotc.pltr1
def pltr1
Definition: plplotc.py:105
plgra
#define plgra
Definition: plplot.h:740
_wrap_plscmap1n
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11198
_wrap_plsdiplz
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11722
_wrap_PLGraphicsIn_keysym_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4379
SwigPyClientData::delargs
int delargs
Definition: plplotcPYTHON_wrap.c:1433
_wrap_plClearOpts
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15174
plsdimap
#define plsdimap
Definition: plplot.h:808
swig_const_info
struct swig_const_info swig_const_info
_wrap_plgriddata
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7262
SwigPyObject_type
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
Definition: plplotcPYTHON_wrap.c:1656
_wrap_plend
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6074
_wrap_PLGraphicsIn_string_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4535
_wrap_plpat
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9903
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplotcPYTHON_wrap.c:389
SWIG_globals
SWIGINTERN PyObject * SWIG_globals(void)
Definition: plplotcPYTHON_wrap.c:23497
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplotcPYTHON_wrap.c:22999
plot3d
#define plot3d
Definition: plplot.h:775
_wrap_plstripc
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13127
_wrap_plsvect
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13461
_wrap_plsesc
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11791
_wrap_plsdiplt
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11674
_wrap_PLGraphicsIn_wX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4832
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotcPYTHON_wrap.c:3123
_wrap_plscmap1a
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10852
myIntArray_ContiguousFromObject
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
_wrap_plscmap1la
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11060
CB_Python
Definition: plplotcPYTHON_wrap.c:3855
_wrap_pltr0
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3552
PLGraphicsIn
Definition: plplot.h:433
PLGraphicsIn_swigregister
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4940