PLplot: plplotcmodulePYTHON_wrap.c Source File

PLplot 5.10.0

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplotcmodulePYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 2.0.7
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 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 /* -----------------------------------------------------------------------------
15 * This section contains generic SWIG labels for method/variable
16 * declarations/attributes, and other compiler dependent labels.
17 * ----------------------------------------------------------------------------- */
18
19 /* template workaround for compilers that cannot correctly implement the C++ standard */
20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22 # define SWIGTEMPLATEDISAMBIGUATOR template
23 # elif defined(__HP_aCC)
24 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # else
28 # define SWIGTEMPLATEDISAMBIGUATOR
29 # endif
30 #endif
31
32 /* inline attribute */
33 #ifndef SWIGINLINE
34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35 # define SWIGINLINE inline
36 # else
37 # define SWIGINLINE
38 # endif
39 #endif
40
41 /* attribute recognised by some compilers to avoid 'unused' warnings */
42 #ifndef SWIGUNUSED
43 # if defined(__GNUC__)
44 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45 # define SWIGUNUSED __attribute__ ((__unused__))
46 # else
47 # define SWIGUNUSED
48 # endif
49 # elif defined(__ICC)
50 # define SWIGUNUSED __attribute__ ((__unused__))
51 # else
52 # define SWIGUNUSED
53 # endif
54 #endif
55
56 #ifndef SWIG_MSC_UNSUPPRESS_4505
57 # if defined(_MSC_VER)
58 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
59 # endif
60 #endif
61
62 #ifndef SWIGUNUSEDPARM
63 # ifdef __cplusplus
64 # define SWIGUNUSEDPARM(p)
65 # else
66 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
67 # endif
68 #endif
69
70 /* internal SWIG method */
71 #ifndef SWIGINTERN
72 # define SWIGINTERN static SWIGUNUSED
73 #endif
74
75 /* internal inline SWIG method */
76 #ifndef SWIGINTERNINLINE
77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78 #endif
79
80 /* exporting methods */
81 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
82 # ifndef GCC_HASCLASSVISIBILITY
83 # define GCC_HASCLASSVISIBILITY
84 # endif
85 #endif
86
87 #ifndef SWIGEXPORT
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # if defined(STATIC_LINKED)
90 # define SWIGEXPORT
91 # else
92 # define SWIGEXPORT __declspec(dllexport)
93 # endif
94 # else
95 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
96 # define SWIGEXPORT __attribute__ ((visibility("default")))
97 # else
98 # define SWIGEXPORT
99 # endif
100 # endif
101 #endif
102
103 /* calling conventions for Windows */
104 #ifndef SWIGSTDCALL
105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
106 # define SWIGSTDCALL __stdcall
107 # else
108 # define SWIGSTDCALL
109 # endif
110 #endif
111
112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
114 # define _CRT_SECURE_NO_DEPRECATE
115 #endif
116
117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
119 # define _SCL_SECURE_NO_DEPRECATE
120 #endif
121
122
123
124 /* Python.h has to appear first */
125 #include <Python.h>
126
127 /* -----------------------------------------------------------------------------
128 * swigrun.swg
129 *
130 * This file contains generic C API SWIG runtime support for pointer
131 * type checking.
132 * ----------------------------------------------------------------------------- */
133
134 /* This should only be incremented when either the layout of swig_type_info changes,
135 or for whatever reason, the runtime changes incompatibly */
136 #define SWIG_RUNTIME_VERSION "4"
137
138 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
139 #ifdef SWIG_TYPE_TABLE
140 # define SWIG_QUOTE_STRING(x) #x
141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
143 #else
144 # define SWIG_TYPE_TABLE_NAME
145 #endif
146
147 /*
148 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
149 creating a static or dynamic library from the SWIG runtime code.
150 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
151
152 But only do this if strictly necessary, ie, if you have problems
153 with your compiler or suchlike.
154 */
155
156 #ifndef SWIGRUNTIME
157 # define SWIGRUNTIME SWIGINTERN
158 #endif
159
160 #ifndef SWIGRUNTIMEINLINE
161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
162 #endif
163
164 /* Generic buffer size */
165 #ifndef SWIG_BUFFER_SIZE
166 # define SWIG_BUFFER_SIZE 1024
167 #endif
168
169 /* Flags for pointer conversions */
170 #define SWIG_POINTER_DISOWN 0x1
171 #define SWIG_CAST_NEW_MEMORY 0x2
172
173 /* Flags for new pointer objects */
174 #define SWIG_POINTER_OWN 0x1
175
176
177 /*
178 Flags/methods for returning states.
179
180 The SWIG conversion methods, as ConvertPtr, return an integer
181 that tells if the conversion was successful or not. And if not,
182 an error code can be returned (see swigerrors.swg for the codes).
183
184 Use the following macros/flags to set or process the returning
185 states.
186
187 In old versions of SWIG, code such as the following was usually written:
188
189 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
190 // success code
191 } else {
192 //fail code
193 }
194
195 Now you can be more explicit:
196
197 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
198 if (SWIG_IsOK(res)) {
199 // success code
200 } else {
201 // fail code
202 }
203
204 which is the same really, but now you can also do
205
206 Type *ptr;
207 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
208 if (SWIG_IsOK(res)) {
209 // success code
210 if (SWIG_IsNewObj(res) {
211 ...
212 delete *ptr;
213 } else {
214 ...
215 }
216 } else {
217 // fail code
218 }
219
220 I.e., now SWIG_ConvertPtr can return new objects and you can
221 identify the case and take care of the deallocation. Of course that
222 also requires SWIG_ConvertPtr to return new result values, such as
223
224 int SWIG_ConvertPtr(obj, ptr,...) {
225 if (<obj is ok>) {
226 if (<need new object>) {
227 *ptr = <ptr to new allocated object>;
228 return SWIG_NEWOBJ;
229 } else {
230 *ptr = <ptr to old object>;
231 return SWIG_OLDOBJ;
232 }
233 } else {
234 return SWIG_BADOBJ;
235 }
236 }
237
238 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
239 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
240 SWIG errors code.
241
242 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
243 allows to return the 'cast rank', for example, if you have this
244
245 int food(double)
246 int fooi(int);
247
248 and you call
249
250 food(1) // cast rank '1' (1 -> 1.0)
251 fooi(1) // cast rank '0'
252
253 just use the SWIG_AddCast()/SWIG_CheckState()
254 */
255
256 #define SWIG_OK (0)
257 #define SWIG_ERROR (-1)
258 #define SWIG_IsOK(r) (r >= 0)
259 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
260
261 /* The CastRankLimit says how many bits are used for the cast rank */
262 #define SWIG_CASTRANKLIMIT (1 << 8)
263 /* The NewMask denotes the object was created (using new/malloc) */
264 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
265 /* The TmpMask is for in/out typemaps that use temporal objects */
266 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
267 /* Simple returning values */
268 #define SWIG_BADOBJ (SWIG_ERROR)
269 #define SWIG_OLDOBJ (SWIG_OK)
270 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
271 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
272 /* Check, add and del mask methods */
273 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279
280 /* Cast-Rank Mode */
281 #if defined(SWIG_CASTRANK_MODE)
282 # ifndef SWIG_TypeRank
283 # define SWIG_TypeRank unsigned long
284 # endif
285 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
286 # define SWIG_MAXCASTRANK (2)
287 # endif
288 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
289 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
290 SWIGINTERNINLINE int SWIG_AddCast(int r) {
291 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
292 }
293 SWIGINTERNINLINE int SWIG_CheckState(int r) {
294 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
295 }
296 #else /* no cast-rank mode */
297 # define SWIG_AddCast
298 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
299 #endif
300
301
302 #include <string.h>
303
304 #ifdef __cplusplus
305 extern "C" {
306 #endif
307
308 typedef void *(*swig_converter_func)(void *, int *);
309 typedef struct swig_type_info *(*swig_dycast_func)(void **);
310
311 /* Structure to store information on one type */
312 typedef struct swig_type_info {
313 const char *name; /* mangled name of this type */
314 const char *str; /* human readable name of this type */
315 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
316 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
317 void *clientdata; /* language specific type data */
318 int owndata; /* flag if the structure owns the clientdata */
319 } swig_type_info;
320
321 /* Structure to store a type and conversion function used for casting */
322 typedef struct swig_cast_info {
323 swig_type_info *type; /* pointer to type that is equivalent to this type */
324 swig_converter_func converter; /* function to cast the void pointers */
325 struct swig_cast_info *next; /* pointer to next cast in linked list */
326 struct swig_cast_info *prev; /* pointer to the previous cast */
327 } swig_cast_info;
328
329 /* Structure used to store module information
330 * Each module generates one structure like this, and the runtime collects
331 * all of these structures and stores them in a circularly linked list.*/
332 typedef struct swig_module_info {
333 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
334 size_t size; /* Number of types in this module */
335 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
336 swig_type_info **type_initial; /* Array of initially generated type structures */
337 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
338 void *clientdata; /* Language specific module data */
339 } swig_module_info;
340
341 /*
342 Compare two type names skipping the space characters, therefore
343 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
344
345 Return 0 when the two name types are equivalent, as in
346 strncmp, but skipping ' '.
347 */
348 SWIGRUNTIME int
349 SWIG_TypeNameComp(const char *f1, const char *l1,
350 const char *f2, const char *l2) {
351 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
352 while ((*f1 == ' ') && (f1 != l1)) ++f1;
353 while ((*f2 == ' ') && (f2 != l2)) ++f2;
354 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
355 }
356 return (int)((l1 - f1) - (l2 - f2));
357 }
358
359 /*
360 Check type equivalence in a name list like <name1>|<name2>|...
361 Return 0 if not equal, 1 if equal
362 */
363 SWIGRUNTIME int
364 SWIG_TypeEquiv(const char *nb, const char *tb) {
365 int equiv = 0;
366 const char* te = tb + strlen(tb);
367 const char* ne = nb;
368 while (!equiv && *ne) {
369 for (nb = ne; *ne; ++ne) {
370 if (*ne == '|') break;
371 }
372 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
373 if (*ne) ++ne;
374 }
375 return equiv;
376 }
377
378 /*
379 Check type equivalence in a name list like <name1>|<name2>|...
380 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
381 */
382 SWIGRUNTIME int
383 SWIG_TypeCompare(const char *nb, const char *tb) {
384 int equiv = 0;
385 const char* te = tb + strlen(tb);
386 const char* ne = nb;
387 while (!equiv && *ne) {
388 for (nb = ne; *ne; ++ne) {
389 if (*ne == '|') break;
390 }
391 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
392 if (*ne) ++ne;
393 }
394 return equiv;
395 }
396
397
398 /*
399 Check the typename
400 */
401 SWIGRUNTIME swig_cast_info *
402 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
403 if (ty) {
404 swig_cast_info *iter = ty->cast;
405 while (iter) {
406 if (strcmp(iter->type->name, c) == 0) {
407 if (iter == ty->cast)
408 return iter;
409 /* Move iter to the top of the linked list */
410 iter->prev->next = iter->next;
411 if (iter->next)
412 iter->next->prev = iter->prev;
413 iter->next = ty->cast;
414 iter->prev = 0;
415 if (ty->cast) ty->cast->prev = iter;
416 ty->cast = iter;
417 return iter;
418 }
419 iter = iter->next;
420 }
421 }
422 return 0;
423 }
424
425 /*
426 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
427 */
428 SWIGRUNTIME swig_cast_info *
429 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
430 if (ty) {
431 swig_cast_info *iter = ty->cast;
432 while (iter) {
433 if (iter->type == from) {
434 if (iter == ty->cast)
435 return iter;
436 /* Move iter to the top of the linked list */
437 iter->prev->next = iter->next;
438 if (iter->next)
439 iter->next->prev = iter->prev;
440 iter->next = ty->cast;
441 iter->prev = 0;
442 if (ty->cast) ty->cast->prev = iter;
443 ty->cast = iter;
444 return iter;
445 }
446 iter = iter->next;
447 }
448 }
449 return 0;
450 }
451
452 /*
453 Cast a pointer up an inheritance hierarchy
454 */
455 SWIGRUNTIMEINLINE void *
456 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
457 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
458 }
459
460 /*
461 Dynamic pointer casting. Down an inheritance hierarchy
462 */
463 SWIGRUNTIME swig_type_info *
464 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
465 swig_type_info *lastty = ty;
466 if (!ty || !ty->dcast) return ty;
467 while (ty && (ty->dcast)) {
468 ty = (*ty->dcast)(ptr);
469 if (ty) lastty = ty;
470 }
471 return lastty;
472 }
473
474 /*
475 Return the name associated with this type
476 */
477 SWIGRUNTIMEINLINE const char *
478 SWIG_TypeName(const swig_type_info *ty) {
479 return ty->name;
480 }
481
482 /*
483 Return the pretty name associated with this type,
484 that is an unmangled type name in a form presentable to the user.
485 */
486 SWIGRUNTIME const char *
487 SWIG_TypePrettyName(const swig_type_info *type) {
488 /* The "str" field contains the equivalent pretty names of the
489 type, separated by vertical-bar characters. We choose
490 to print the last name, as it is often (?) the most
491 specific. */
492 if (!type) return NULL;
493 if (type->str != NULL) {
494 const char *last_name = type->str;
495 const char *s;
496 for (s = type->str; *s; s++)
497 if (*s == '|') last_name = s+1;
498 return last_name;
499 }
500 else
501 return type->name;
502 }
503
504 /*
505 Set the clientdata field for a type
506 */
507 SWIGRUNTIME void
508 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
509 swig_cast_info *cast = ti->cast;
510 /* if (ti->clientdata == clientdata) return; */
511 ti->clientdata = clientdata;
512
513 while (cast) {
514 if (!cast->converter) {
515 swig_type_info *tc = cast->type;
516 if (!tc->clientdata) {
517 SWIG_TypeClientData(tc, clientdata);
518 }
519 }
520 cast = cast->next;
521 }
522 }
523 SWIGRUNTIME void
524 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
525 SWIG_TypeClientData(ti, clientdata);
526 ti->owndata = 1;
527 }
528
529 /*
530 Search for a swig_type_info structure only by mangled name
531 Search is a O(log #types)
532
533 We start searching at module start, and finish searching when start == end.
534 Note: if start == end at the beginning of the function, we go all the way around
535 the circular list.
536 */
537 SWIGRUNTIME swig_type_info *
538 SWIG_MangledTypeQueryModule(swig_module_info *start,
539 swig_module_info *end,
540 const char *name) {
541 swig_module_info *iter = start;
542 do {
543 if (iter->size) {
544 register size_t l = 0;
545 register size_t r = iter->size - 1;
546 do {
547 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
548 register size_t i = (l + r) >> 1;
549 const char *iname = iter->types[i]->name;
550 if (iname) {
551 register int compare = strcmp(name, iname);
552 if (compare == 0) {
553 return iter->types[i];
554 } else if (compare < 0) {
555 if (i) {
556 r = i - 1;
557 } else {
558 break;
559 }
560 } else if (compare > 0) {
561 l = i + 1;
562 }
563 } else {
564 break; /* should never happen */
565 }
566 } while (l <= r);
567 }
568 iter = iter->next;
569 } while (iter != end);
570 return 0;
571 }
572
573 /*
574 Search for a swig_type_info structure for either a mangled name or a human readable name.
575 It first searches the mangled names of the types, which is a O(log #types)
576 If a type is not found it then searches the human readable names, which is O(#types).
577
578 We start searching at module start, and finish searching when start == end.
579 Note: if start == end at the beginning of the function, we go all the way around
580 the circular list.
581 */
582 SWIGRUNTIME swig_type_info *
583 SWIG_TypeQueryModule(swig_module_info *start,
584 swig_module_info *end,
585 const char *name) {
586 /* STEP 1: Search the name field using binary search */
587 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
588 if (ret) {
589 return ret;
590 } else {
591 /* STEP 2: If the type hasn't been found, do a complete search
592 of the str field (the human readable name) */
593 swig_module_info *iter = start;
594 do {
595 register size_t i = 0;
596 for (; i < iter->size; ++i) {
597 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
598 return iter->types[i];
599 }
600 iter = iter->next;
601 } while (iter != end);
602 }
603
604 /* neither found a match */
605 return 0;
606 }
607
608 /*
609 Pack binary data into a string
610 */
611 SWIGRUNTIME char *
612 SWIG_PackData(char *c, void *ptr, size_t sz) {
613 static const char hex[17] = "0123456789abcdef";
614 register const unsigned char *u = (unsigned char *) ptr;
615 register const unsigned char *eu = u + sz;
616 for (; u != eu; ++u) {
617 register unsigned char uu = *u;
618 *(c++) = hex[(uu & 0xf0) >> 4];
619 *(c++) = hex[uu & 0xf];
620 }
621 return c;
622 }
623
624 /*
625 Unpack binary data from a string
626 */
627 SWIGRUNTIME const char *
628 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
629 register unsigned char *u = (unsigned char *) ptr;
630 register const unsigned char *eu = u + sz;
631 for (; u != eu; ++u) {
632 register char d = *(c++);
633 register unsigned char uu;
634 if ((d >= '0') && (d <= '9'))
635 uu = ((d - '0') << 4);
636 else if ((d >= 'a') && (d <= 'f'))
637 uu = ((d - ('a'-10)) << 4);
638 else
639 return (char *) 0;
640 d = *(c++);
641 if ((d >= '0') && (d <= '9'))
642 uu |= (d - '0');
643 else if ((d >= 'a') && (d <= 'f'))
644 uu |= (d - ('a'-10));
645 else
646 return (char *) 0;
647 *u = uu;
648 }
649 return c;
650 }
651
652 /*
653 Pack 'void *' into a string buffer.
654 */
655 SWIGRUNTIME char *
656 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
657 char *r = buff;
658 if ((2*sizeof(void *) + 2) > bsz) return 0;
659 *(r++) = '_';
660 r = SWIG_PackData(r,&ptr,sizeof(void *));
661 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
662 strcpy(r,name);
663 return buff;
664 }
665
666 SWIGRUNTIME const char *
667 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
668 if (*c != '_') {
669 if (strcmp(c,"NULL") == 0) {
670 *ptr = (void *) 0;
671 return name;
672 } else {
673 return 0;
674 }
675 }
676 return SWIG_UnpackData(++c,ptr,sizeof(void *));
677 }
678
679 SWIGRUNTIME char *
680 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
681 char *r = buff;
682 size_t lname = (name ? strlen(name) : 0);
683 if ((2*sz + 2 + lname) > bsz) return 0;
684 *(r++) = '_';
685 r = SWIG_PackData(r,ptr,sz);
686 if (lname) {
687 strncpy(r,name,lname+1);
688 } else {
689 *r = 0;
690 }
691 return buff;
692 }
693
694 SWIGRUNTIME const char *
695 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
696 if (*c != '_') {
697 if (strcmp(c,"NULL") == 0) {
698 memset(ptr,0,sz);
699 return name;
700 } else {
701 return 0;
702 }
703 }
704 return SWIG_UnpackData(++c,ptr,sz);
705 }
706
707 #ifdef __cplusplus
708 }
709 #endif
710
711 /* Errors in SWIG */
712 #define SWIG_UnknownError -1
713 #define SWIG_IOError -2
714 #define SWIG_RuntimeError -3
715 #define SWIG_IndexError -4
716 #define SWIG_TypeError -5
717 #define SWIG_DivisionByZero -6
718 #define SWIG_OverflowError -7
719 #define SWIG_SyntaxError -8
720 #define SWIG_ValueError -9
721 #define SWIG_SystemError -10
722 #define SWIG_AttributeError -11
723 #define SWIG_MemoryError -12
724 #define SWIG_NullReferenceError -13
725
726
727
728 /* Compatibility macros for Python 3 */
729 #if PY_VERSION_HEX >= 0x03000000
730
731 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
732 #define PyInt_Check(x) PyLong_Check(x)
733 #define PyInt_AsLong(x) PyLong_AsLong(x)
734 #define PyInt_FromLong(x) PyLong_FromLong(x)
735 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
736 #define PyString_Check(name) PyBytes_Check(name)
737 #define PyString_FromString(x) PyUnicode_FromString(x)
738 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
739 #define PyString_AsString(str) PyBytes_AsString(str)
740 #define PyString_Size(str) PyBytes_Size(str)
741 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
742 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
743 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
744 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
745
746 #endif
747
748 #ifndef Py_TYPE
749 # define Py_TYPE(op) ((op)->ob_type)
750 #endif
751
752 /* SWIG APIs for compatibility of both Python 2 & 3 */
753
754 #if PY_VERSION_HEX >= 0x03000000
755 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
756 #else
757 # define SWIG_Python_str_FromFormat PyString_FromFormat
758 #endif
759
760
761 /* Warning: This function will allocate a new string in Python 3,
762 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
763 */
764 SWIGINTERN char*
765 SWIG_Python_str_AsChar(PyObject *str)
766 {
767 #if PY_VERSION_HEX >= 0x03000000
768 char *cstr;
769 char *newstr;
770 Py_ssize_t len;
771 str = PyUnicode_AsUTF8String(str);
772 PyBytes_AsStringAndSize(str, &cstr, &len);
773 newstr = (char *) malloc(len+1);
774 memcpy(newstr, cstr, len+1);
775 Py_XDECREF(str);
776 return newstr;
777 #else
778 return PyString_AsString(str);
779 #endif
780 }
781
782 #if PY_VERSION_HEX >= 0x03000000
783 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
784 #else
785 # define SWIG_Python_str_DelForPy3(x)
786 #endif
787
788
789 SWIGINTERN PyObject*
790 SWIG_Python_str_FromChar(const char *c)
791 {
792 #if PY_VERSION_HEX >= 0x03000000
793 return PyUnicode_FromString(c);
794 #else
795 return PyString_FromString(c);
796 #endif
797 }
798
799 /* Add PyOS_snprintf for old Pythons */
800 #if PY_VERSION_HEX < 0x02020000
801 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
802 # define PyOS_snprintf _snprintf
803 # else
804 # define PyOS_snprintf snprintf
805 # endif
806 #endif
807
808 /* A crude PyString_FromFormat implementation for old Pythons */
809 #if PY_VERSION_HEX < 0x02020000
810
811 #ifndef SWIG_PYBUFFER_SIZE
812 # define SWIG_PYBUFFER_SIZE 1024
813 #endif
814
815 static PyObject *
816 PyString_FromFormat(const char *fmt, ...) {
817 va_list ap;
818 char buf[SWIG_PYBUFFER_SIZE * 2];
819 int res;
820 va_start(ap, fmt);
821 res = vsnprintf(buf, sizeof(buf), fmt, ap);
822 va_end(ap);
823 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
824 }
825 #endif
826
827 /* Add PyObject_Del for old Pythons */
828 #if PY_VERSION_HEX < 0x01060000
829 # define PyObject_Del(op) PyMem_DEL((op))
830 #endif
831 #ifndef PyObject_DEL
832 # define PyObject_DEL PyObject_Del
833 #endif
834
835 /* A crude PyExc_StopIteration exception for old Pythons */
836 #if PY_VERSION_HEX < 0x02020000
837 # ifndef PyExc_StopIteration
838 # define PyExc_StopIteration PyExc_RuntimeError
839 # endif
840 # ifndef PyObject_GenericGetAttr
841 # define PyObject_GenericGetAttr 0
842 # endif
843 #endif
844
845 /* Py_NotImplemented is defined in 2.1 and up. */
846 #if PY_VERSION_HEX < 0x02010000
847 # ifndef Py_NotImplemented
848 # define Py_NotImplemented PyExc_RuntimeError
849 # endif
850 #endif
851
852 /* A crude PyString_AsStringAndSize implementation for old Pythons */
853 #if PY_VERSION_HEX < 0x02010000
854 # ifndef PyString_AsStringAndSize
855 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
856 # endif
857 #endif
858
859 /* PySequence_Size for old Pythons */
860 #if PY_VERSION_HEX < 0x02000000
861 # ifndef PySequence_Size
862 # define PySequence_Size PySequence_Length
863 # endif
864 #endif
865
866 /* PyBool_FromLong for old Pythons */
867 #if PY_VERSION_HEX < 0x02030000
868 static
869 PyObject *PyBool_FromLong(long ok)
870 {
871 PyObject *result = ok ? Py_True : Py_False;
872 Py_INCREF(result);
873 return result;
874 }
875 #endif
876
877 /* Py_ssize_t for old Pythons */
878 /* This code is as recommended by: */
879 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
880 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
881 typedef int Py_ssize_t;
882 # define PY_SSIZE_T_MAX INT_MAX
883 # define PY_SSIZE_T_MIN INT_MIN
884 typedef inquiry lenfunc;
885 typedef intargfunc ssizeargfunc;
886 typedef intintargfunc ssizessizeargfunc;
887 typedef intobjargproc ssizeobjargproc;
888 typedef intintobjargproc ssizessizeobjargproc;
889 typedef getreadbufferproc readbufferproc;
890 typedef getwritebufferproc writebufferproc;
891 typedef getsegcountproc segcountproc;
892 typedef getcharbufferproc charbufferproc;
893 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
894 {
895 long result = 0;
896 PyObject *i = PyNumber_Int(x);
897 if (i) {
898 result = PyInt_AsLong(i);
899 Py_DECREF(i);
900 }
901 return result;
902 }
903 #endif
904
905 #if PY_VERSION_HEX < 0x02040000
906 #define Py_VISIT(op) \
907 do { \
908 if (op) { \
909 int vret = visit((op), arg); \
910 if (vret) \
911 return vret; \
912 } \
913 } while (0)
914 #endif
915
916 #if PY_VERSION_HEX < 0x02030000
917 typedef struct {
918 PyTypeObject type;
919 PyNumberMethods as_number;
920 PyMappingMethods as_mapping;
921 PySequenceMethods as_sequence;
922 PyBufferProcs as_buffer;
923 PyObject *name, *slots;
924 } PyHeapTypeObject;
925 #endif
926
927 #if PY_VERSION_HEX < 0x02030000
928 typedef destructor freefunc;
929 #endif
930
931 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
932 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
933 (PY_MAJOR_VERSION > 3))
934 # define SWIGPY_USE_CAPSULE
935 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
936 #endif
937
938 #if PY_VERSION_HEX < 0x03020000
939 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
940 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
941 #endif
942
943 /* -----------------------------------------------------------------------------
944 * error manipulation
945 * ----------------------------------------------------------------------------- */
946
947 SWIGRUNTIME PyObject*
948 SWIG_Python_ErrorType(int code) {
949 PyObject* type = 0;
950 switch(code) {
951 case SWIG_MemoryError:
952 type = PyExc_MemoryError;
953 break;
954 case SWIG_IOError:
955 type = PyExc_IOError;
956 break;
957 case SWIG_RuntimeError:
958 type = PyExc_RuntimeError;
959 break;
960 case SWIG_IndexError:
961 type = PyExc_IndexError;
962 break;
963 case SWIG_TypeError:
964 type = PyExc_TypeError;
965 break;
966 case SWIG_DivisionByZero:
967 type = PyExc_ZeroDivisionError;
968 break;
969 case SWIG_OverflowError:
970 type = PyExc_OverflowError;
971 break;
972 case SWIG_SyntaxError:
973 type = PyExc_SyntaxError;
974 break;
975 case SWIG_ValueError:
976 type = PyExc_ValueError;
977 break;
978 case SWIG_SystemError:
979 type = PyExc_SystemError;
980 break;
981 case SWIG_AttributeError:
982 type = PyExc_AttributeError;
983 break;
984 default:
985 type = PyExc_RuntimeError;
986 }
987 return type;
988 }
989
990
991 SWIGRUNTIME void
992 SWIG_Python_AddErrorMsg(const char* mesg)
993 {
994 PyObject *type = 0;
995 PyObject *value = 0;
996 PyObject *traceback = 0;
997
998 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
999 if (value) {
1000 char *tmp;
1001 PyObject *old_str = PyObject_Str(value);
1002 PyErr_Clear();
1003 Py_XINCREF(type);
1004
1005 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1006 SWIG_Python_str_DelForPy3(tmp);
1007 Py_DECREF(old_str);
1008 Py_DECREF(value);
1009 } else {
1010 PyErr_SetString(PyExc_RuntimeError, mesg);
1011 }
1012 }
1013
1014 #if defined(SWIG_PYTHON_NO_THREADS)
1015 # if defined(SWIG_PYTHON_THREADS)
1016 # undef SWIG_PYTHON_THREADS
1017 # endif
1018 #endif
1019 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1020 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1021 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1022 # define SWIG_PYTHON_USE_GIL
1023 # endif
1024 # endif
1025 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1026 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1027 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1028 # endif
1029 # ifdef __cplusplus /* C++ code */
1030 class SWIG_Python_Thread_Block {
1031 bool status;
1032 PyGILState_STATE state;
1033 public:
1034 void end() { if (status) { PyGILState_Release(state); status = false;} }
1035 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1036 ~SWIG_Python_Thread_Block() { end(); }
1037 };
1038 class SWIG_Python_Thread_Allow {
1039 bool status;
1040 PyThreadState *save;
1041 public:
1042 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1043 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1044 ~SWIG_Python_Thread_Allow() { end(); }
1045 };
1046 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1047 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1048 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1049 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1050 # else /* C code */
1051 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1052 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1053 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1054 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1055 # endif
1056 # else /* Old thread way, not implemented, user must provide it */
1057 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1058 # define SWIG_PYTHON_INITIALIZE_THREADS
1059 # endif
1060 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1061 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1062 # endif
1063 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1064 # define SWIG_PYTHON_THREAD_END_BLOCK
1065 # endif
1066 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1067 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1068 # endif
1069 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1070 # define SWIG_PYTHON_THREAD_END_ALLOW
1071 # endif
1072 # endif
1073 #else /* No thread support */
1074 # define SWIG_PYTHON_INITIALIZE_THREADS
1075 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1076 # define SWIG_PYTHON_THREAD_END_BLOCK
1077 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1078 # define SWIG_PYTHON_THREAD_END_ALLOW
1079 #endif
1080
1081 /* -----------------------------------------------------------------------------
1082 * Python API portion that goes into the runtime
1083 * ----------------------------------------------------------------------------- */
1084
1085 #ifdef __cplusplus
1086 extern "C" {
1087 #endif
1088
1089 /* -----------------------------------------------------------------------------
1090 * Constant declarations
1091 * ----------------------------------------------------------------------------- */
1092
1093 /* Constant Types */
1094 #define SWIG_PY_POINTER 4
1095 #define SWIG_PY_BINARY 5
1096
1097 /* Constant information structure */
1098 typedef struct swig_const_info {
1099 int type;
1100 char *name;
1101 long lvalue;
1102 double dvalue;
1103 void *pvalue;
1104 swig_type_info **ptype;
1105 } swig_const_info;
1106
1107
1108 /* -----------------------------------------------------------------------------
1109 * Wrapper of PyInstanceMethod_New() used in Python 3
1110 * It is exported to the generated module, used for -fastproxy
1111 * ----------------------------------------------------------------------------- */
1112 #if PY_VERSION_HEX >= 0x03000000
1113 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1114 {
1115 return PyInstanceMethod_New(func);
1116 }
1117 #else
1118 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1119 {
1120 return NULL;
1121 }
1122 #endif
1123
1124 #ifdef __cplusplus
1125 }
1126 #endif
1127
1128
1129 /* -----------------------------------------------------------------------------
1130 * pyrun.swg
1131 *
1132 * This file contains the runtime support for Python modules
1133 * and includes code for managing global variables and pointer
1134 * type checking.
1135 *
1136 * ----------------------------------------------------------------------------- */
1137
1138 /* Common SWIG API */
1139
1140 /* for raw pointers */
1141 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1142 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1143 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1144
1145 #ifdef SWIGPYTHON_BUILTIN
1146 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1147 #else
1148 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1149 #endif
1150
1151 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1152
1153 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1154 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1155 #define swig_owntype int
1156
1157 /* for raw packed data */
1158 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1159 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1160
1161 /* for class or struct pointers */
1162 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1163 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1164
1165 /* for C or C++ function pointers */
1166 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1167 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1168
1169 /* for C++ member pointers, ie, member methods */
1170 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1171 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1172
1173
1174 /* Runtime API */
1175
1176 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1177 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1178 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1179
1180 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1181 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1182 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1183 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1184 #define SWIG_fail goto fail
1185
1186
1187 /* Runtime API implementation */
1188
1189 /* Error manipulation */
1190
1191 SWIGINTERN void
1192 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1193 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1194 PyErr_SetObject(errtype, obj);
1195 Py_DECREF(obj);
1196 SWIG_PYTHON_THREAD_END_BLOCK;
1197 }
1198
1199 SWIGINTERN void
1200 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1201 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1202 PyErr_SetString(errtype, msg);
1203 SWIG_PYTHON_THREAD_END_BLOCK;
1204 }
1205
1206 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1207
1208 /* Set a constant value */
1209
1210 #if defined(SWIGPYTHON_BUILTIN)
1211
1212 SWIGINTERN void
1213 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1214 PyObject *s = PyString_InternFromString(key);
1215 PyList_Append(seq, s);
1216 Py_DECREF(s);
1217 }
1218
1219 SWIGINTERN void
1220 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1221 #if PY_VERSION_HEX < 0x02030000
1222 PyDict_SetItemString(d, (char *)name, obj);
1223 #else
1224 PyDict_SetItemString(d, name, obj);
1225 #endif
1226 Py_DECREF(obj);
1227 if (public_interface)
1228 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1229 }
1230
1231 #else
1232
1233 SWIGINTERN void
1234 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1235 #if PY_VERSION_HEX < 0x02030000
1236 PyDict_SetItemString(d, (char *)name, obj);
1237 #else
1238 PyDict_SetItemString(d, name, obj);
1239 #endif
1240 Py_DECREF(obj);
1241 }
1242
1243 #endif
1244
1245 /* Append a value to the result obj */
1246
1247 SWIGINTERN PyObject*
1248 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1249 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1250 if (!result) {
1251 result = obj;
1252 } else if (result == Py_None) {
1253 Py_DECREF(result);
1254 result = obj;
1255 } else {
1256 if (!PyList_Check(result)) {
1257 PyObject *o2 = result;
1258 result = PyList_New(1);
1259 PyList_SetItem(result, 0, o2);
1260 }
1261 PyList_Append(result,obj);
1262 Py_DECREF(obj);
1263 }
1264 return result;
1265 #else
1266 PyObject* o2;
1267 PyObject* o3;
1268 if (!result) {
1269 result = obj;
1270 } else if (result == Py_None) {
1271 Py_DECREF(result);
1272 result = obj;
1273 } else {
1274 if (!PyTuple_Check(result)) {
1275 o2 = result;
1276 result = PyTuple_New(1);
1277 PyTuple_SET_ITEM(result, 0, o2);
1278 }
1279 o3 = PyTuple_New(1);
1280 PyTuple_SET_ITEM(o3, 0, obj);
1281 o2 = result;
1282 result = PySequence_Concat(o2, o3);
1283 Py_DECREF(o2);
1284 Py_DECREF(o3);
1285 }
1286 return result;
1287 #endif
1288 }
1289
1290 /* Unpack the argument tuple */
1291
1292 SWIGINTERN int
1293 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1294 {
1295 if (!args) {
1296 if (!min && !max) {
1297 return 1;
1298 } else {
1299 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1300 name, (min == max ? "" : "at least "), (int)min);
1301 return 0;
1302 }
1303 }
1304 if (!PyTuple_Check(args)) {
1305 if (min <= 1 && max >= 1) {
1306 register int i;
1307 objs[0] = args;
1308 for (i = 1; i < max; ++i) {
1309 objs[i] = 0;
1310 }
1311 return 2;
1312 }
1313 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1314 return 0;
1315 } else {
1316 register Py_ssize_t l = PyTuple_GET_SIZE(args);
1317 if (l < min) {
1318 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1319 name, (min == max ? "" : "at least "), (int)min, (int)l);
1320 return 0;
1321 } else if (l > max) {
1322 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1323 name, (min == max ? "" : "at most "), (int)max, (int)l);
1324 return 0;
1325 } else {
1326 register int i;
1327 for (i = 0; i < l; ++i) {
1328 objs[i] = PyTuple_GET_ITEM(args, i);
1329 }
1330 for (; l < max; ++l) {
1331 objs[l] = 0;
1332 }
1333 return i + 1;
1334 }
1335 }
1336 }
1337
1338 /* A functor is a function object with one single object argument */
1339 #if PY_VERSION_HEX >= 0x02020000
1340 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1341 #else
1342 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1343 #endif
1344
1345 /*
1346 Helper for static pointer initialization for both C and C++ code, for example
1347 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1348 */
1349 #ifdef __cplusplus
1350 #define SWIG_STATIC_POINTER(var) var
1351 #else
1352 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1353 #endif
1354
1355 /* -----------------------------------------------------------------------------
1356 * Pointer declarations
1357 * ----------------------------------------------------------------------------- */
1358
1359 /* Flags for new pointer objects */
1360 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1361 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1362
1363 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1364
1365 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1366 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1367
1368 #ifdef __cplusplus
1369 extern "C" {
1370 #endif
1371
1372 /* How to access Py_None */
1373 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1374 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1375 # ifndef SWIG_PYTHON_BUILD_NONE
1376 # define SWIG_PYTHON_BUILD_NONE
1377 # endif
1378 # endif
1379 #endif
1380
1381 #ifdef SWIG_PYTHON_BUILD_NONE
1382 # ifdef Py_None
1383 # undef Py_None
1384 # define Py_None SWIG_Py_None()
1385 # endif
1386 SWIGRUNTIMEINLINE PyObject *
1387 _SWIG_Py_None(void)
1388 {
1389 PyObject *none = Py_BuildValue((char*)"");
1390 Py_DECREF(none);
1391 return none;
1392 }
1393 SWIGRUNTIME PyObject *
1394 SWIG_Py_None(void)
1395 {
1396 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1397 return none;
1398 }
1399 #endif
1400
1401 /* The python void return value */
1402
1403 SWIGRUNTIMEINLINE PyObject *
1404 SWIG_Py_Void(void)
1405 {
1406 PyObject *none = Py_None;
1407 Py_INCREF(none);
1408 return none;
1409 }
1410
1411 /* SwigPyClientData */
1412
1413 typedef struct {
1414 PyObject *klass;
1415 PyObject *newraw;
1416 PyObject *newargs;
1417 PyObject *destroy;
1418 int delargs;
1419 int implicitconv;
1420 PyTypeObject *pytype;
1421 } SwigPyClientData;
1422
1423 SWIGRUNTIMEINLINE int
1424 SWIG_Python_CheckImplicit(swig_type_info *ty)
1425 {
1426 SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1427 return data ? data->implicitconv : 0;
1428 }
1429
1430 SWIGRUNTIMEINLINE PyObject *
1431 SWIG_Python_ExceptionType(swig_type_info *desc) {
1432 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1433 PyObject *klass = data ? data->klass : 0;
1434 return (klass ? klass : PyExc_RuntimeError);
1435 }
1436
1437
1438 SWIGRUNTIME SwigPyClientData *
1439 SwigPyClientData_New(PyObject* obj)
1440 {
1441 if (!obj) {
1442 return 0;
1443 } else {
1444 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1445 /* the klass element */
1446 data->klass = obj;
1447 Py_INCREF(data->klass);
1448 /* the newraw method and newargs arguments used to create a new raw instance */
1449 if (PyClass_Check(obj)) {
1450 data->newraw = 0;
1451 data->newargs = obj;
1452 Py_INCREF(obj);
1453 } else {
1454 #if (PY_VERSION_HEX < 0x02020000)
1455 data->newraw = 0;
1456 #else
1457 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1458 #endif
1459 if (data->newraw) {
1460 Py_INCREF(data->newraw);
1461 data->newargs = PyTuple_New(1);
1462 PyTuple_SetItem(data->newargs, 0, obj);
1463 } else {
1464 data->newargs = obj;
1465 }
1466 Py_INCREF(data->newargs);
1467 }
1468 /* the destroy method, aka as the C++ delete method */
1469 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1470 if (PyErr_Occurred()) {
1471 PyErr_Clear();
1472 data->destroy = 0;
1473 }
1474 if (data->destroy) {
1475 int flags;
1476 Py_INCREF(data->destroy);
1477 flags = PyCFunction_GET_FLAGS(data->destroy);
1478 #ifdef METH_O
1479 data->delargs = !(flags & (METH_O));
1480 #else
1481 data->delargs = 0;
1482 #endif
1483 } else {
1484 data->delargs = 0;
1485 }
1486 data->implicitconv = 0;
1487 data->pytype = 0;
1488 return data;
1489 }
1490 }
1491
1492 SWIGRUNTIME void
1493 SwigPyClientData_Del(SwigPyClientData *data) {
1494 Py_XDECREF(data->newraw);
1495 Py_XDECREF(data->newargs);
1496 Py_XDECREF(data->destroy);
1497 }
1498
1499 /* =============== SwigPyObject =====================*/
1500
1501 typedef struct {
1502 PyObject_HEAD
1503 void *ptr;
1504 swig_type_info *ty;
1505 int own;
1506 PyObject *next;
1507 #ifdef SWIGPYTHON_BUILTIN
1508 PyObject *dict;
1509 #endif
1510 } SwigPyObject;
1511
1512 SWIGRUNTIME PyObject *
1513 SwigPyObject_long(SwigPyObject *v)
1514 {
1515 return PyLong_FromVoidPtr(v->ptr);
1516 }
1517
1518 SWIGRUNTIME PyObject *
1519 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1520 {
1521 PyObject *res = NULL;
1522 PyObject *args = PyTuple_New(1);
1523 if (args) {
1524 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1525 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1526 if (ofmt) {
1527 #if PY_VERSION_HEX >= 0x03000000
1528 res = PyUnicode_Format(ofmt,args);
1529 #else
1530 res = PyString_Format(ofmt,args);
1531 #endif
1532 Py_DECREF(ofmt);
1533 }
1534 Py_DECREF(args);
1535 }
1536 }
1537 return res;
1538 }
1539
1540 SWIGRUNTIME PyObject *
1541 SwigPyObject_oct(SwigPyObject *v)
1542 {
1543 return SwigPyObject_format("%o",v);
1544 }
1545
1546 SWIGRUNTIME PyObject *
1547 SwigPyObject_hex(SwigPyObject *v)
1548 {
1549 return SwigPyObject_format("%x",v);
1550 }
1551
1552 SWIGRUNTIME PyObject *
1553 #ifdef METH_NOARGS
1554 SwigPyObject_repr(SwigPyObject *v)
1555 #else
1556 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1557 #endif
1558 {
1559 const char *name = SWIG_TypePrettyName(v->ty);
1560 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1561 if (v->next) {
1562 # ifdef METH_NOARGS
1563 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1564 # else
1565 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1566 # endif
1567 # if PY_VERSION_HEX >= 0x03000000
1568 PyObject *joined = PyUnicode_Concat(repr, nrep);
1569 Py_DecRef(repr);
1570 Py_DecRef(nrep);
1571 repr = joined;
1572 # else
1573 PyString_ConcatAndDel(&repr,nrep);
1574 # endif
1575 }
1576 return repr;
1577 }
1578
1579 SWIGRUNTIME int
1580 SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1581 {
1582 char *str;
1583 #ifdef METH_NOARGS
1584 PyObject *repr = SwigPyObject_repr(v);
1585 #else
1586 PyObject *repr = SwigPyObject_repr(v, NULL);
1587 #endif
1588 if (repr) {
1589 str = SWIG_Python_str_AsChar(repr);
1590 fputs(str, fp);
1591 SWIG_Python_str_DelForPy3(str);
1592 Py_DECREF(repr);
1593 return 0;
1594 } else {
1595 return 1;
1596 }
1597 }
1598
1599 SWIGRUNTIME PyObject *
1600 SwigPyObject_str(SwigPyObject *v)
1601 {
1602 char result[SWIG_BUFFER_SIZE];
1603 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1604 SWIG_Python_str_FromChar(result) : 0;
1605 }
1606
1607 SWIGRUNTIME int
1608 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1609 {
1610 void *i = v->ptr;
1611 void *j = w->ptr;
1612 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1613 }
1614
1615 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1616 SWIGRUNTIME PyObject*
1617 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1618 {
1619 PyObject* res;
1620 if( op != Py_EQ && op != Py_NE ) {
1621 Py_INCREF(Py_NotImplemented);
1622 return Py_NotImplemented;
1623 }
1624 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1625 return res;
1626 }
1627
1628
1629 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1630
1631 #ifdef SWIGPYTHON_BUILTIN
1632 static swig_type_info *SwigPyObject_stype = 0;
1633 SWIGRUNTIME PyTypeObject*
1634 SwigPyObject_type(void) {
1635 SwigPyClientData *cd;
1636 assert(SwigPyObject_stype);
1637 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1638 assert(cd);
1639 assert(cd->pytype);
1640 return cd->pytype;
1641 }
1642 #else
1643 SWIGRUNTIME PyTypeObject*
1644 SwigPyObject_type(void) {
1645 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1646 return type;
1647 }
1648 #endif
1649
1650 SWIGRUNTIMEINLINE int
1651 SwigPyObject_Check(PyObject *op) {
1652 #ifdef SWIGPYTHON_BUILTIN
1653 PyTypeObject *target_tp = SwigPyObject_type();
1654 if (PyType_IsSubtype(op->ob_type, target_tp))
1655 return 1;
1656 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1657 #else
1658 return (Py_TYPE(op) == SwigPyObject_type())
1659 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1660 #endif
1661 }
1662
1663 SWIGRUNTIME PyObject *
1664 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1665
1666 SWIGRUNTIME void
1667 SwigPyObject_dealloc(PyObject *v)
1668 {
1669 SwigPyObject *sobj = (SwigPyObject *) v;
1670 PyObject *next = sobj->next;
1671 if (sobj->own == SWIG_POINTER_OWN) {
1672 swig_type_info *ty = sobj->ty;
1673 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1674 PyObject *destroy = data ? data->destroy : 0;
1675 if (destroy) {
1676 /* destroy is always a VARARGS method */
1677 PyObject *res;
1678 if (data->delargs) {
1679 /* we need to create a temporary object to carry the destroy operation */
1680 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1681 res = SWIG_Python_CallFunctor(destroy, tmp);
1682 Py_DECREF(tmp);
1683 } else {
1684 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1685 PyObject *mself = PyCFunction_GET_SELF(destroy);
1686 res = ((*meth)(mself, v));
1687 }
1688 Py_XDECREF(res);
1689 }
1690 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1691 else {
1692 const char *name = SWIG_TypePrettyName(ty);
1693 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1694 }
1695 #endif
1696 }
1697 Py_XDECREF(next);
1698 PyObject_DEL(v);
1699 }
1700
1701 SWIGRUNTIME PyObject*
1702 SwigPyObject_append(PyObject* v, PyObject* next)
1703 {
1704 SwigPyObject *sobj = (SwigPyObject *) v;
1705 #ifndef METH_O
1706 PyObject *tmp = 0;
1707 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1708 next = tmp;
1709 #endif
1710 if (!SwigPyObject_Check(next)) {
1711 return NULL;
1712 }
1713 sobj->next = next;
1714 Py_INCREF(next);
1715 return SWIG_Py_Void();
1716 }
1717
1718 SWIGRUNTIME PyObject*
1719 #ifdef METH_NOARGS
1720 SwigPyObject_next(PyObject* v)
1721 #else
1722 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1723 #endif
1724 {
1725 SwigPyObject *sobj = (SwigPyObject *) v;
1726 if (sobj->next) {
1727 Py_INCREF(sobj->next);
1728 return sobj->next;
1729 } else {
1730 return SWIG_Py_Void();
1731 }
1732 }
1733
1734 SWIGINTERN PyObject*
1735 #ifdef METH_NOARGS
1736 SwigPyObject_disown(PyObject *v)
1737 #else
1738 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1739 #endif
1740 {
1741 SwigPyObject *sobj = (SwigPyObject *)v;
1742 sobj->own = 0;
1743 return SWIG_Py_Void();
1744 }
1745
1746 SWIGINTERN PyObject*
1747 #ifdef METH_NOARGS
1748 SwigPyObject_acquire(PyObject *v)
1749 #else
1750 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1751 #endif
1752 {
1753 SwigPyObject *sobj = (SwigPyObject *)v;
1754 sobj->own = SWIG_POINTER_OWN;
1755 return SWIG_Py_Void();
1756 }
1757
1758 SWIGINTERN PyObject*
1759 SwigPyObject_own(PyObject *v, PyObject *args)
1760 {
1761 PyObject *val = 0;
1762 #if (PY_VERSION_HEX < 0x02020000)
1763 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1764 #elif (PY_VERSION_HEX < 0x02050000)
1765 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1766 #else
1767 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1768 #endif
1769 {
1770 return NULL;
1771 }
1772 else
1773 {
1774 SwigPyObject *sobj = (SwigPyObject *)v;
1775 PyObject *obj = PyBool_FromLong(sobj->own);
1776 if (val) {
1777 #ifdef METH_NOARGS
1778 if (PyObject_IsTrue(val)) {
1779 SwigPyObject_acquire(v);
1780 } else {
1781 SwigPyObject_disown(v);
1782 }
1783 #else
1784 if (PyObject_IsTrue(val)) {
1785 SwigPyObject_acquire(v,args);
1786 } else {
1787 SwigPyObject_disown(v,args);
1788 }
1789 #endif
1790 }
1791 return obj;
1792 }
1793 }
1794
1795 #ifdef METH_O
1796 static PyMethodDef
1797 swigobject_methods[] = {
1798 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1799 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1800 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1801 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1802 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1803 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1804 {0, 0, 0, 0}
1805 };
1806 #else
1807 static PyMethodDef
1808 swigobject_methods[] = {
1809 {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1810 {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1811 {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1812 {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1813 {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1814 {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1815 {0, 0, 0, 0}
1816 };
1817 #endif
1818
1819 #if PY_VERSION_HEX < 0x02020000
1820 SWIGINTERN PyObject *
1821 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1822 {
1823 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1824 }
1825 #endif
1826
1827 SWIGRUNTIME PyTypeObject*
1828 SwigPyObject_TypeOnce(void) {
1829 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1830
1831 static PyNumberMethods SwigPyObject_as_number = {
1832 (binaryfunc)0, /*nb_add*/
1833 (binaryfunc)0, /*nb_subtract*/
1834 (binaryfunc)0, /*nb_multiply*/
1835 /* nb_divide removed in Python 3 */
1836 #if PY_VERSION_HEX < 0x03000000
1837 (binaryfunc)0, /*nb_divide*/
1838 #endif
1839 (binaryfunc)0, /*nb_remainder*/
1840 (binaryfunc)0, /*nb_divmod*/
1841 (ternaryfunc)0,/*nb_power*/
1842 (unaryfunc)0, /*nb_negative*/
1843 (unaryfunc)0, /*nb_positive*/
1844 (unaryfunc)0, /*nb_absolute*/
1845 (inquiry)0, /*nb_nonzero*/
1846 0, /*nb_invert*/
1847 0, /*nb_lshift*/
1848 0, /*nb_rshift*/
1849 0, /*nb_and*/
1850 0, /*nb_xor*/
1851 0, /*nb_or*/
1852 #if PY_VERSION_HEX < 0x03000000
1853 0, /*nb_coerce*/
1854 #endif
1855 (unaryfunc)SwigPyObject_long, /*nb_int*/
1856 #if PY_VERSION_HEX < 0x03000000
1857 (unaryfunc)SwigPyObject_long, /*nb_long*/
1858 #else
1859 0, /*nb_reserved*/
1860 #endif
1861 (unaryfunc)0, /*nb_float*/
1862 #if PY_VERSION_HEX < 0x03000000
1863 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1864 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1865 #endif
1866 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1867 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1868 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1869 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1870 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1871 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1872 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1873 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1874 #endif
1875 };
1876
1877 static PyTypeObject swigpyobject_type;
1878 static int type_init = 0;
1879 if (!type_init) {
1880 const PyTypeObject tmp = {
1881 /* PyObject header changed in Python 3 */
1882 #if PY_VERSION_HEX >= 0x03000000
1883 PyVarObject_HEAD_INIT(NULL, 0)
1884 #else
1885 PyObject_HEAD_INIT(NULL)
1886 0, /* ob_size */
1887 #endif
1888 (char *)"SwigPyObject", /* tp_name */
1889 sizeof(SwigPyObject), /* tp_basicsize */
1890 0, /* tp_itemsize */
1891 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1892 (printfunc)SwigPyObject_print, /* tp_print */
1893 #if PY_VERSION_HEX < 0x02020000
1894 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1895 #else
1896 (getattrfunc)0, /* tp_getattr */
1897 #endif
1898 (setattrfunc)0, /* tp_setattr */
1899 #if PY_VERSION_HEX >= 0x03000000
1900 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1901 #else
1902 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1903 #endif
1904 (reprfunc)SwigPyObject_repr, /* tp_repr */
1905 &SwigPyObject_as_number, /* tp_as_number */
1906 0, /* tp_as_sequence */
1907 0, /* tp_as_mapping */
1908 (hashfunc)0, /* tp_hash */
1909 (ternaryfunc)0, /* tp_call */
1910 (reprfunc)SwigPyObject_str, /* tp_str */
1911 PyObject_GenericGetAttr, /* tp_getattro */
1912 0, /* tp_setattro */
1913 0, /* tp_as_buffer */
1914 Py_TPFLAGS_DEFAULT, /* tp_flags */
1915 swigobject_doc, /* tp_doc */
1916 0, /* tp_traverse */
1917 0, /* tp_clear */
1918 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1919 0, /* tp_weaklistoffset */
1920 #if PY_VERSION_HEX >= 0x02020000
1921 0, /* tp_iter */
1922 0, /* tp_iternext */
1923 swigobject_methods, /* tp_methods */
1924 0, /* tp_members */
1925 0, /* tp_getset */
1926 0, /* tp_base */
1927 0, /* tp_dict */
1928 0, /* tp_descr_get */
1929 0, /* tp_descr_set */
1930 0, /* tp_dictoffset */
1931 0, /* tp_init */
1932 0, /* tp_alloc */
1933 0, /* tp_new */
1934 0, /* tp_free */
1935 0, /* tp_is_gc */
1936 0, /* tp_bases */
1937 0, /* tp_mro */
1938 0, /* tp_cache */
1939 0, /* tp_subclasses */
1940 0, /* tp_weaklist */
1941 #endif
1942 #if PY_VERSION_HEX >= 0x02030000
1943 0, /* tp_del */
1944 #endif
1945 #if PY_VERSION_HEX >= 0x02060000
1946 0, /* tp_version */
1947 #endif
1948 #ifdef COUNT_ALLOCS
1949 0,0,0,0 /* tp_alloc -> tp_next */
1950 #endif
1951 };
1952 swigpyobject_type = tmp;
1953 type_init = 1;
1954 #if PY_VERSION_HEX < 0x02020000
1955 swigpyobject_type.ob_type = &PyType_Type;
1956 #else
1957 if (PyType_Ready(&swigpyobject_type) < 0)
1958 return NULL;
1959 #endif
1960 }
1961 return &swigpyobject_type;
1962 }
1963
1964 SWIGRUNTIME PyObject *
1965 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1966 {
1967 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1968 if (sobj) {
1969 sobj->ptr = ptr;
1970 sobj->ty = ty;
1971 sobj->own = own;
1972 sobj->next = 0;
1973 }
1974 return (PyObject *)sobj;
1975 }
1976
1977 /* -----------------------------------------------------------------------------
1978 * Implements a simple Swig Packed type, and use it instead of string
1979 * ----------------------------------------------------------------------------- */
1980
1981 typedef struct {
1982 PyObject_HEAD
1983 void *pack;
1984 swig_type_info *ty;
1985 size_t size;
1986 } SwigPyPacked;
1987
1988 SWIGRUNTIME int
1989 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1990 {
1991 char result[SWIG_BUFFER_SIZE];
1992 fputs("<Swig Packed ", fp);
1993 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1994 fputs("at ", fp);
1995 fputs(result, fp);
1996 }
1997 fputs(v->ty->name,fp);
1998 fputs(">", fp);
1999 return 0;
2000 }
2001
2002 SWIGRUNTIME PyObject *
2003 SwigPyPacked_repr(SwigPyPacked *v)
2004 {
2005 char result[SWIG_BUFFER_SIZE];
2006 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2007 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2008 } else {
2009 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2010 }
2011 }
2012
2013 SWIGRUNTIME PyObject *
2014 SwigPyPacked_str(SwigPyPacked *v)
2015 {
2016 char result[SWIG_BUFFER_SIZE];
2017 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2018 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2019 } else {
2020 return SWIG_Python_str_FromChar(v->ty->name);
2021 }
2022 }
2023
2024 SWIGRUNTIME int
2025 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2026 {
2027 size_t i = v->size;
2028 size_t j = w->size;
2029 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2030 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2031 }
2032
2033 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2034
2035 SWIGRUNTIME PyTypeObject*
2036 SwigPyPacked_type(void) {
2037 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2038 return type;
2039 }
2040
2041 SWIGRUNTIMEINLINE int
2042 SwigPyPacked_Check(PyObject *op) {
2043 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2044 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2045 }
2046
2047 SWIGRUNTIME void
2048 SwigPyPacked_dealloc(PyObject *v)
2049 {
2050 if (SwigPyPacked_Check(v)) {
2051 SwigPyPacked *sobj = (SwigPyPacked *) v;
2052 free(sobj->pack);
2053 }
2054 PyObject_DEL(v);
2055 }
2056
2057 SWIGRUNTIME PyTypeObject*
2058 SwigPyPacked_TypeOnce(void) {
2059 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2060 static PyTypeObject swigpypacked_type;
2061 static int type_init = 0;
2062 if (!type_init) {
2063 const PyTypeObject tmp = {
2064 /* PyObject header changed in Python 3 */
2065 #if PY_VERSION_HEX>=0x03000000
2066 PyVarObject_HEAD_INIT(NULL, 0)
2067 #else
2068 PyObject_HEAD_INIT(NULL)
2069 0, /* ob_size */
2070 #endif
2071 (char *)"SwigPyPacked", /* tp_name */
2072 sizeof(SwigPyPacked), /* tp_basicsize */
2073 0, /* tp_itemsize */
2074 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2075 (printfunc)SwigPyPacked_print, /* tp_print */
2076 (getattrfunc)0, /* tp_getattr */
2077 (setattrfunc)0, /* tp_setattr */
2078 #if PY_VERSION_HEX>=0x03000000
2079 0, /* tp_reserved in 3.0.1 */
2080 #else
2081 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2082 #endif
2083 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2084 0, /* tp_as_number */
2085 0, /* tp_as_sequence */
2086 0, /* tp_as_mapping */
2087 (hashfunc)0, /* tp_hash */
2088 (ternaryfunc)0, /* tp_call */
2089 (reprfunc)SwigPyPacked_str, /* tp_str */
2090 PyObject_GenericGetAttr, /* tp_getattro */
2091 0, /* tp_setattro */
2092 0, /* tp_as_buffer */
2093 Py_TPFLAGS_DEFAULT, /* tp_flags */
2094 swigpacked_doc, /* tp_doc */
2095 0, /* tp_traverse */
2096 0, /* tp_clear */
2097 0, /* tp_richcompare */
2098 0, /* tp_weaklistoffset */
2099 #if PY_VERSION_HEX >= 0x02020000
2100 0, /* tp_iter */
2101 0, /* tp_iternext */
2102 0, /* tp_methods */
2103 0, /* tp_members */
2104 0, /* tp_getset */
2105 0, /* tp_base */
2106 0, /* tp_dict */
2107 0, /* tp_descr_get */
2108 0, /* tp_descr_set */
2109 0, /* tp_dictoffset */
2110 0, /* tp_init */
2111 0, /* tp_alloc */
2112 0, /* tp_new */
2113 0, /* tp_free */
2114 0, /* tp_is_gc */
2115 0, /* tp_bases */
2116 0, /* tp_mro */
2117 0, /* tp_cache */
2118 0, /* tp_subclasses */
2119 0, /* tp_weaklist */
2120 #endif
2121 #if PY_VERSION_HEX >= 0x02030000
2122 0, /* tp_del */
2123 #endif
2124 #if PY_VERSION_HEX >= 0x02060000
2125 0, /* tp_version */
2126 #endif
2127 #ifdef COUNT_ALLOCS
2128 0,0,0,0 /* tp_alloc -> tp_next */
2129 #endif
2130 };
2131 swigpypacked_type = tmp;
2132 type_init = 1;
2133 #if PY_VERSION_HEX < 0x02020000
2134 swigpypacked_type.ob_type = &PyType_Type;
2135 #else
2136 if (PyType_Ready(&swigpypacked_type) < 0)
2137 return NULL;
2138 #endif
2139 }
2140 return &swigpypacked_type;
2141 }
2142
2143 SWIGRUNTIME PyObject *
2144 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2145 {
2146 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2147 if (sobj) {
2148 void *pack = malloc(size);
2149 if (pack) {
2150 memcpy(pack, ptr, size);
2151 sobj->pack = pack;
2152 sobj->ty = ty;
2153 sobj->size = size;
2154 } else {
2155 PyObject_DEL((PyObject *) sobj);
2156 sobj = 0;
2157 }
2158 }
2159 return (PyObject *) sobj;
2160 }
2161
2162 SWIGRUNTIME swig_type_info *
2163 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2164 {
2165 if (SwigPyPacked_Check(obj)) {
2166 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2167 if (sobj->size != size) return 0;
2168 memcpy(ptr, sobj->pack, size);
2169 return sobj->ty;
2170 } else {
2171 return 0;
2172 }
2173 }
2174
2175 /* -----------------------------------------------------------------------------
2176 * pointers/data manipulation
2177 * ----------------------------------------------------------------------------- */
2178
2179 SWIGRUNTIMEINLINE PyObject *
2180 _SWIG_This(void)
2181 {
2182 return SWIG_Python_str_FromChar("this");
2183 }
2184
2185 static PyObject *swig_this = NULL;
2186
2187 SWIGRUNTIME PyObject *
2188 SWIG_This(void)
2189 {
2190 if (swig_this == NULL)
2191 swig_this = _SWIG_This();
2192 return swig_this;
2193 }
2194
2195 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2196
2197 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2198 #if PY_VERSION_HEX>=0x03000000
2199 #define SWIG_PYTHON_SLOW_GETSET_THIS
2200 #endif
2201
2202 SWIGRUNTIME SwigPyObject *
2203 SWIG_Python_GetSwigThis(PyObject *pyobj)
2204 {
2205 PyObject *obj;
2206
2207 if (SwigPyObject_Check(pyobj))
2208 return (SwigPyObject *) pyobj;
2209
2210 #ifdef SWIGPYTHON_BUILTIN
2211 (void)obj;
2212 # ifdef PyWeakref_CheckProxy
2213 if (PyWeakref_CheckProxy(pyobj)) {
2214 pyobj = PyWeakref_GET_OBJECT(pyobj);
2215 if (pyobj && SwigPyObject_Check(pyobj))
2216 return (SwigPyObject*) pyobj;
2217 }
2218 # endif
2219 return NULL;
2220 #else
2221
2222 obj = 0;
2223
2224 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2225 if (PyInstance_Check(pyobj)) {
2226 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2227 } else {
2228 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2229 if (dictptr != NULL) {
2230 PyObject *dict = *dictptr;
2231 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2232 } else {
2233 #ifdef PyWeakref_CheckProxy
2234 if (PyWeakref_CheckProxy(pyobj)) {
2235 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2236 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2237 }
2238 #endif
2239 obj = PyObject_GetAttr(pyobj,SWIG_This());
2240 if (obj) {
2241 Py_DECREF(obj);
2242 } else {
2243 if (PyErr_Occurred()) PyErr_Clear();
2244 return 0;
2245 }
2246 }
2247 }
2248 #else
2249 obj = PyObject_GetAttr(pyobj,SWIG_This());
2250 if (obj) {
2251 Py_DECREF(obj);
2252 } else {
2253 if (PyErr_Occurred()) PyErr_Clear();
2254 return 0;
2255 }
2256 #endif
2257 if (obj && !SwigPyObject_Check(obj)) {
2258 /* a PyObject is called 'this', try to get the 'real this'
2259 SwigPyObject from it */
2260 return SWIG_Python_GetSwigThis(obj);
2261 }
2262 return (SwigPyObject *)obj;
2263 #endif
2264 }
2265
2266 /* Acquire a pointer value */
2267
2268 SWIGRUNTIME int
2269 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2270 if (own == SWIG_POINTER_OWN) {
2271 SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2272 if (sobj) {
2273 int oldown = sobj->own;
2274 sobj->own = own;
2275 return oldown;
2276 }
2277 }
2278 return 0;
2279 }
2280
2281 /* Convert a pointer value */
2282
2283 SWIGRUNTIME int
2284 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2285 int res;
2286 SwigPyObject *sobj;
2287
2288 if (!obj)
2289 return SWIG_ERROR;
2290 if (obj == Py_None) {
2291 if (ptr)
2292 *ptr = 0;
2293 return SWIG_OK;
2294 }
2295
2296 res = SWIG_ERROR;
2297
2298 sobj = SWIG_Python_GetSwigThis(obj);
2299 if (own)
2300 *own = 0;
2301 while (sobj) {
2302 void *vptr = sobj->ptr;
2303 if (ty) {
2304 swig_type_info *to = sobj->ty;
2305 if (to == ty) {
2306 /* no type cast needed */
2307 if (ptr) *ptr = vptr;
2308 break;
2309 } else {
2310 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2311 if (!tc) {
2312 sobj = (SwigPyObject *)sobj->next;
2313 } else {
2314 if (ptr) {
2315 int newmemory = 0;
2316 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2317 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2318 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2319 if (own)
2320 *own = *own | SWIG_CAST_NEW_MEMORY;
2321 }
2322 }
2323 break;
2324 }
2325 }
2326 } else {
2327 if (ptr) *ptr = vptr;
2328 break;
2329 }
2330 }
2331 if (sobj) {
2332 if (own)
2333 *own = *own | sobj->own;
2334 if (flags & SWIG_POINTER_DISOWN) {
2335 sobj->own = 0;
2336 }
2337 res = SWIG_OK;
2338 } else {
2339 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2340 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2341 if (data && !data->implicitconv) {
2342 PyObject *klass = data->klass;
2343 if (klass) {
2344 PyObject *impconv;
2345 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2346 impconv = SWIG_Python_CallFunctor(klass, obj);
2347 data->implicitconv = 0;
2348 if (PyErr_Occurred()) {
2349 PyErr_Clear();
2350 impconv = 0;
2351 }
2352 if (impconv) {
2353 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2354 if (iobj) {
2355 void *vptr;
2356 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2357 if (SWIG_IsOK(res)) {
2358 if (ptr) {
2359 *ptr = vptr;
2360 /* transfer the ownership to 'ptr' */
2361 iobj->own = 0;
2362 res = SWIG_AddCast(res);
2363 res = SWIG_AddNewMask(res);
2364 } else {
2365 res = SWIG_AddCast(res);
2366 }
2367 }
2368 }
2369 Py_DECREF(impconv);
2370 }
2371 }
2372 }
2373 }
2374 }
2375 return res;
2376 }
2377
2378 /* Convert a function ptr value */
2379
2380 SWIGRUNTIME int
2381 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2382 if (!PyCFunction_Check(obj)) {
2383 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2384 } else {
2385 void *vptr = 0;
2386
2387 /* here we get the method pointer for callbacks */
2388 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2389 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2390 if (desc)
2391 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2392 if (!desc)
2393 return SWIG_ERROR;
2394 if (ty) {
2395 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2396 if (tc) {
2397 int newmemory = 0;
2398 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2399 assert(!newmemory); /* newmemory handling not yet implemented */
2400 } else {
2401 return SWIG_ERROR;
2402 }
2403 } else {
2404 *ptr = vptr;
2405 }
2406 return SWIG_OK;
2407 }
2408 }
2409
2410 /* Convert a packed value value */
2411
2412 SWIGRUNTIME int
2413 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2414 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2415 if (!to) return SWIG_ERROR;
2416 if (ty) {
2417 if (to != ty) {
2418 /* check type cast? */
2419 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2420 if (!tc) return SWIG_ERROR;
2421 }
2422 }
2423 return SWIG_OK;
2424 }
2425
2426 /* -----------------------------------------------------------------------------
2427 * Create a new pointer object
2428 * ----------------------------------------------------------------------------- */
2429
2430 /*
2431 Create a new instance object, without calling __init__, and set the
2432 'this' attribute.
2433 */
2434
2435 SWIGRUNTIME PyObject*
2436 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2437 {
2438 #if (PY_VERSION_HEX >= 0x02020000)
2439 PyObject *inst = 0;
2440 PyObject *newraw = data->newraw;
2441 if (newraw) {
2442 inst = PyObject_Call(newraw, data->newargs, NULL);
2443 if (inst) {
2444 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2445 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2446 if (dictptr != NULL) {
2447 PyObject *dict = *dictptr;
2448 if (dict == NULL) {
2449 dict = PyDict_New();
2450 *dictptr = dict;
2451 PyDict_SetItem(dict, SWIG_This(), swig_this);
2452 }
2453 }
2454 #else
2455 PyObject *key = SWIG_This();
2456 PyObject_SetAttr(inst, key, swig_this);
2457 #endif
2458 }
2459 } else {
2460 #if PY_VERSION_HEX >= 0x03000000
2461 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2462 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2463 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2464 #else
2465 PyObject *dict = PyDict_New();
2466 PyDict_SetItem(dict, SWIG_This(), swig_this);
2467 inst = PyInstance_NewRaw(data->newargs, dict);
2468 Py_DECREF(dict);
2469 #endif
2470 }
2471 return inst;
2472 #else
2473 #if (PY_VERSION_HEX >= 0x02010000)
2474 PyObject *inst;
2475 PyObject *dict = PyDict_New();
2476 PyDict_SetItem(dict, SWIG_This(), swig_this);
2477 inst = PyInstance_NewRaw(data->newargs, dict);
2478 Py_DECREF(dict);
2479 return (PyObject *) inst;
2480 #else
2481 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2482 if (inst == NULL) {
2483 return NULL;
2484 }
2485 inst->in_class = (PyClassObject *)data->newargs;
2486 Py_INCREF(inst->in_class);
2487 inst->in_dict = PyDict_New();
2488 if (inst->in_dict == NULL) {
2489 Py_DECREF(inst);
2490 return NULL;
2491 }
2492 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2493 inst->in_weakreflist = NULL;
2494 #endif
2495 #ifdef Py_TPFLAGS_GC
2496 PyObject_GC_Init(inst);
2497 #endif
2498 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2499 return (PyObject *) inst;
2500 #endif
2501 #endif
2502 }
2503
2504 SWIGRUNTIME void
2505 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2506 {
2507 PyObject *dict;
2508 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2509 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2510 if (dictptr != NULL) {
2511 dict = *dictptr;
2512 if (dict == NULL) {
2513 dict = PyDict_New();
2514 *dictptr = dict;
2515 }
2516 PyDict_SetItem(dict, SWIG_This(), swig_this);
2517 return;
2518 }
2519 #endif
2520 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2521 PyDict_SetItem(dict, SWIG_This(), swig_this);
2522 Py_DECREF(dict);
2523 }
2524
2525
2526 SWIGINTERN PyObject *
2527 SWIG_Python_InitShadowInstance(PyObject *args) {
2528 PyObject *obj[2];
2529 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2530 return NULL;
2531 } else {
2532 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2533 if (sthis) {
2534 SwigPyObject_append((PyObject*) sthis, obj[1]);
2535 } else {
2536 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2537 }
2538 return SWIG_Py_Void();
2539 }
2540 }
2541
2542 /* Create a new pointer object */
2543
2544 SWIGRUNTIME PyObject *
2545 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2546 SwigPyClientData *clientdata;
2547 PyObject * robj;
2548 int own;
2549
2550 if (!ptr)
2551 return SWIG_Py_Void();
2552
2553 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2554 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2555 if (clientdata && clientdata->pytype) {
2556 SwigPyObject *newobj;
2557 if (flags & SWIG_BUILTIN_TP_INIT) {
2558 newobj = (SwigPyObject*) self;
2559 if (newobj->ptr) {
2560 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2561 while (newobj->next)
2562 newobj = (SwigPyObject *) newobj->next;
2563 newobj->next = next_self;
2564 newobj = (SwigPyObject *)next_self;
2565 }
2566 } else {
2567 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2568 }
2569 if (newobj) {
2570 newobj->ptr = ptr;
2571 newobj->ty = type;
2572 newobj->own = own;
2573 newobj->next = 0;
2574 #ifdef SWIGPYTHON_BUILTIN
2575 newobj->dict = 0;
2576 #endif
2577 return (PyObject*) newobj;
2578 }
2579 return SWIG_Py_Void();
2580 }
2581
2582 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2583
2584 robj = SwigPyObject_New(ptr, type, own);
2585 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2586 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2587 if (inst) {
2588 Py_DECREF(robj);
2589 robj = inst;
2590 }
2591 }
2592 return robj;
2593 }
2594
2595 /* Create a new packed object */
2596
2597 SWIGRUNTIMEINLINE PyObject *
2598 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2599 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2600 }
2601
2602 /* -----------------------------------------------------------------------------*
2603 * Get type list
2604 * -----------------------------------------------------------------------------*/
2605
2606 #ifdef SWIG_LINK_RUNTIME
2607 void *SWIG_ReturnGlobalTypeList(void *);
2608 #endif
2609
2610 SWIGRUNTIME swig_module_info *
2611 SWIG_Python_GetModule(void) {
2612 static void *type_pointer = (void *)0;
2613 /* first check if module already created */
2614 if (!type_pointer) {
2615 #ifdef SWIG_LINK_RUNTIME
2616 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2617 #else
2618 # ifdef SWIGPY_USE_CAPSULE
2619 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2620 # else
2621 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2622 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2623 # endif
2624 if (PyErr_Occurred()) {
2625 PyErr_Clear();
2626 type_pointer = (void *)0;
2627 }
2628 #endif
2629 }
2630 return (swig_module_info *) type_pointer;
2631 }
2632
2633 #if PY_MAJOR_VERSION < 2
2634 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2635 is copied out of Python/modsupport.c in python version 2.3.4 */
2636 SWIGINTERN int
2637 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2638 {
2639 PyObject *dict;
2640 if (!PyModule_Check(m)) {
2641 PyErr_SetString(PyExc_TypeError,
2642 "PyModule_AddObject() needs module as first arg");
2643 return SWIG_ERROR;
2644 }
2645 if (!o) {
2646 PyErr_SetString(PyExc_TypeError,
2647 "PyModule_AddObject() needs non-NULL value");
2648 return SWIG_ERROR;
2649 }
2650
2651 dict = PyModule_GetDict(m);
2652 if (dict == NULL) {
2653 /* Internal error -- modules must have a dict! */
2654 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2655 PyModule_GetName(m));
2656 return SWIG_ERROR;
2657 }
2658 if (PyDict_SetItemString(dict, name, o))
2659 return SWIG_ERROR;
2660 Py_DECREF(o);
2661 return SWIG_OK;
2662 }
2663 #endif
2664
2665 SWIGRUNTIME void
2666 #ifdef SWIGPY_USE_CAPSULE
2667 SWIG_Python_DestroyModule(PyObject *obj)
2668 #else
2669 SWIG_Python_DestroyModule(void *vptr)
2670 #endif
2671 {
2672 #ifdef SWIGPY_USE_CAPSULE
2673 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2674 #else
2675 swig_module_info *swig_module = (swig_module_info *) vptr;
2676 #endif
2677 swig_type_info **types = swig_module->types;
2678 size_t i;
2679 for (i =0; i < swig_module->size; ++i) {
2680 swig_type_info *ty = types[i];
2681 if (ty->owndata) {
2682 SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2683 if (data) SwigPyClientData_Del(data);
2684 }
2685 }
2686 Py_DECREF(SWIG_This());
2687 swig_this = NULL;
2688 }
2689
2690 SWIGRUNTIME void
2691 SWIG_Python_SetModule(swig_module_info *swig_module) {
2692 #if PY_VERSION_HEX >= 0x03000000
2693 /* Add a dummy module object into sys.modules */
2694 PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2695 #else
2696 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2697 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2698 #endif
2699 #ifdef SWIGPY_USE_CAPSULE
2700 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2701 if (pointer && module) {
2702 PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2703 } else {
2704 Py_XDECREF(pointer);
2705 }
2706 #else
2707 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2708 if (pointer && module) {
2709 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2710 } else {
2711 Py_XDECREF(pointer);
2712 }
2713 #endif
2714 }
2715
2716 /* The python cached type query */
2717 SWIGRUNTIME PyObject *
2718 SWIG_Python_TypeCache(void) {
2719 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2720 return cache;
2721 }
2722
2723 SWIGRUNTIME swig_type_info *
2724 SWIG_Python_TypeQuery(const char *type)
2725 {
2726 PyObject *cache = SWIG_Python_TypeCache();
2727 PyObject *key = SWIG_Python_str_FromChar(type);
2728 PyObject *obj = PyDict_GetItem(cache, key);
2729 swig_type_info *descriptor;
2730 if (obj) {
2731 #ifdef SWIGPY_USE_CAPSULE
2732 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2733 #else
2734 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2735 #endif
2736 } else {
2737 swig_module_info *swig_module = SWIG_Python_GetModule();
2738 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2739 if (descriptor) {
2740 #ifdef SWIGPY_USE_CAPSULE
2741 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2742 #else
2743 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2744 #endif
2745 PyDict_SetItem(cache, key, obj);
2746 Py_DECREF(obj);
2747 }
2748 }
2749 Py_DECREF(key);
2750 return descriptor;
2751 }
2752
2753 /*
2754 For backward compatibility only
2755 */
2756 #define SWIG_POINTER_EXCEPTION 0
2757 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2758 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2759
2760 SWIGRUNTIME int
2761 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2762 {
2763 if (PyErr_Occurred()) {
2764 PyObject *type = 0;
2765 PyObject *value = 0;
2766 PyObject *traceback = 0;
2767 PyErr_Fetch(&type, &value, &traceback);
2768 if (value) {
2769 char *tmp;
2770 PyObject *old_str = PyObject_Str(value);
2771 Py_XINCREF(type);
2772 PyErr_Clear();
2773 if (infront) {
2774 PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2775 } else {
2776 PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2777 }
2778 SWIG_Python_str_DelForPy3(tmp);
2779 Py_DECREF(old_str);
2780 }
2781 return 1;
2782 } else {
2783 return 0;
2784 }
2785 }
2786
2787 SWIGRUNTIME int
2788 SWIG_Python_ArgFail(int argnum)
2789 {
2790 if (PyErr_Occurred()) {
2791 /* add information about failing argument */
2792 char mesg[256];
2793 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2794 return SWIG_Python_AddErrMesg(mesg, 1);
2795 } else {
2796 return 0;
2797 }
2798 }
2799
2800 SWIGRUNTIMEINLINE const char *
2801 SwigPyObject_GetDesc(PyObject *self)
2802 {
2803 SwigPyObject *v = (SwigPyObject *)self;
2804 swig_type_info *ty = v ? v->ty : 0;
2805 return ty ? ty->str : "";
2806 }
2807
2808 SWIGRUNTIME void
2809 SWIG_Python_TypeError(const char *type, PyObject *obj)
2810 {
2811 if (type) {
2812 #if defined(SWIG_COBJECT_TYPES)
2813 if (obj && SwigPyObject_Check(obj)) {
2814 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2815 if (otype) {
2816 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2817 type, otype);
2818 return;
2819 }
2820 } else
2821 #endif
2822 {
2823 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2824 if (otype) {
2825 PyObject *str = PyObject_Str(obj);
2826 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2827 if (cstr) {
2828 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2829 type, otype, cstr);
2830 SWIG_Python_str_DelForPy3(cstr);
2831 } else {
2832 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2833 type, otype);
2834 }
2835 Py_XDECREF(str);
2836 return;
2837 }
2838 }
2839 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2840 } else {
2841 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2842 }
2843 }
2844
2845
2846 /* Convert a pointer value, signal an exception on a type mismatch */
2847 SWIGRUNTIME void *
2848 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2849 void *result;
2850 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2851 PyErr_Clear();
2852 #if SWIG_POINTER_EXCEPTION
2853 if (flags) {
2854 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2855 SWIG_Python_ArgFail(argnum);
2856 }
2857 #endif
2858 }
2859 return result;
2860 }
2861
2862 #ifdef SWIGPYTHON_BUILTIN
2863 SWIGRUNTIME int
2864 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2865 PyTypeObject *tp = obj->ob_type;
2866 PyObject *descr;
2867 PyObject *encoded_name;
2868 descrsetfunc f;
2869 int res;
2870
2871 # ifdef Py_USING_UNICODE
2872 if (PyString_Check(name)) {
2873 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2874 if (!name)
2875 return -1;
2876 } else if (!PyUnicode_Check(name))
2877 # else
2878 if (!PyString_Check(name))
2879 # endif
2880 {
2881 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2882 return -1;
2883 } else {
2884 Py_INCREF(name);
2885 }
2886
2887 if (!tp->tp_dict) {
2888 if (PyType_Ready(tp) < 0)
2889 goto done;
2890 }
2891
2892 res = -1;
2893 descr = _PyType_Lookup(tp, name);
2894 f = NULL;
2895 if (descr != NULL)
2896 f = descr->ob_type->tp_descr_set;
2897 if (!f) {
2898 if (PyString_Check(name)) {
2899 encoded_name = name;
2900 Py_INCREF(name);
2901 } else {
2902 encoded_name = PyUnicode_AsUTF8String(name);
2903 }
2904 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2905 Py_DECREF(encoded_name);
2906 } else {
2907 res = f(descr, obj, value);
2908 }
2909
2910 done:
2911 Py_DECREF(name);
2912 return res;
2913 }
2914 #endif
2915
2916
2917 #ifdef __cplusplus
2918 }
2919 #endif
2920
2921
2922
2923 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2924
2925 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2926
2927
2928
2929 /* -------- TYPES TABLE (BEGIN) -------- */
2930
2931 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2932 #define SWIGTYPE_p_PLcGrid swig_types[1]
2933 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2934 #define SWIGTYPE_p_char swig_types[3]
2935 #define SWIGTYPE_p_double swig_types[4]
2936 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2937 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2938 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2939 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2940 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2941 #define SWIGTYPE_p_int swig_types[10]
2942 #define SWIGTYPE_p_p_char swig_types[11]
2943 #define SWIGTYPE_p_p_double swig_types[12]
2944 #define SWIGTYPE_p_unsigned_int swig_types[13]
2945 static swig_type_info *swig_types[15];
2946 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2947 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2948 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2949
2950 /* -------- TYPES TABLE (END) -------- */
2951
2952 #if (PY_VERSION_HEX <= 0x02000000)
2953 # if !defined(SWIG_PYTHON_CLASSIC)
2954 # error "This python version requires swig to be run with the '-classic' option"
2955 # endif
2956 #endif
2957
2958 /*-----------------------------------------------
2959 @(target):= _plplotc.so
2960 ------------------------------------------------*/
2961 #if PY_VERSION_HEX >= 0x03000000
2962 # define SWIG_init PyInit__plplotc
2963
2964 #else
2965 # define SWIG_init init_plplotc
2966
2967 #endif
2968 #define SWIG_name "_plplotc"
2969
2970 #define SWIGVERSION 0x020007
2971 #define SWIG_VERSION SWIGVERSION
2972
2973
2974 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2975 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2976
2977
2978 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2979 #include <arrayobject.h>
2980 #include "plplot.h"
2981 #include "plplotP.h"
2982
2983 #define NPY_PLINT NPY_INT32
2984
2985 #ifdef PL_DOUBLE
2986 #define NPY_PLFLT NPY_FLOAT64
2987 #else
2988 #define NPY_PLFLT NPY_FLOAT32
2989 #endif
2990
2991 // python-1.5 compatibility mode?
2992 #if !defined ( PySequence_Fast_GET_ITEM )
2993 #define PySequence_Fast_GET_ITEM PySequence_GetItem
2994 #endif
2995 #define PySequence_Size PySequence_Length
2996
2997
2998 static PLINT Alen = 0;
2999 static PLINT Xlen = 0, Ylen = 0;
3000
3001
3002 SWIGINTERN int
3003 SWIG_AsVal_double (PyObject *obj, double *val)
3004 {
3005 int res = SWIG_TypeError;
3006 if (PyFloat_Check(obj)) {
3007 if (val) *val = PyFloat_AsDouble(obj);
3008 return SWIG_OK;
3009 } else if (PyInt_Check(obj)) {
3010 if (val) *val = PyInt_AsLong(obj);
3011 return SWIG_OK;
3012 } else if (PyLong_Check(obj)) {
3013 double v = PyLong_AsDouble(obj);
3014 if (!PyErr_Occurred()) {
3015 if (val) *val = v;
3016 return SWIG_OK;
3017 } else {
3018 PyErr_Clear();
3019 }
3020 }
3021 #ifdef SWIG_PYTHON_CAST_MODE
3022 {
3023 int dispatch = 0;
3024 double d = PyFloat_AsDouble(obj);
3025 if (!PyErr_Occurred()) {
3026 if (val) *val = d;
3027 return SWIG_AddCast(SWIG_OK);
3028 } else {
3029 PyErr_Clear();
3030 }
3031 if (!dispatch) {
3032 long v = PyLong_AsLong(obj);
3033 if (!PyErr_Occurred()) {
3034 if (val) *val = v;
3035 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3036 } else {
3037 PyErr_Clear();
3038 }
3039 }
3040 }
3041 #endif
3042 return res;
3043 }
3044
3045
3046 #define SWIG_From_double PyFloat_FromDouble
3047
3048
3049 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3050 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3051 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3052 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3053 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3054 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
3055 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3056
3057
3058 SWIGINTERNINLINE PyObject*
3059 SWIG_From_int (int value)
3060 {
3061 return PyInt_FromLong((long) value);
3062 }
3063
3064
3065 #include <limits.h>
3066 #if !defined(SWIG_NO_LLONG_MAX)
3067 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3068 # define LLONG_MAX __LONG_LONG_MAX__
3069 # define LLONG_MIN (-LLONG_MAX - 1LL)
3070 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3071 # endif
3072 #endif
3073
3074
3075 #include <float.h>
3076
3077
3078 #include <math.h>
3079
3080
3081 SWIGINTERNINLINE int
3082 SWIG_CanCastAsInteger(double *d, double min, double max) {
3083 double x = *d;
3084 if ((min <= x && x <= max)) {
3085 double fx = floor(x);
3086 double cx = ceil(x);
3087 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3088 if ((errno == EDOM) || (errno == ERANGE)) {
3089 errno = 0;
3090 } else {
3091 double summ, reps, diff;
3092 if (rd < x) {
3093 diff = x - rd;
3094 } else if (rd > x) {
3095 diff = rd - x;
3096 } else {
3097 return 1;
3098 }
3099 summ = rd + x;
3100 reps = diff/summ;
3101 if (reps < 8*DBL_EPSILON) {
3102 *d = rd;
3103 return 1;
3104 }
3105 }
3106 }
3107 return 0;
3108 }
3109
3110
3111 SWIGINTERN int
3112 SWIG_AsVal_long (PyObject *obj, long* val)
3113 {
3114 if (PyInt_Check(obj)) {
3115 if (val) *val = PyInt_AsLong(obj);
3116 return SWIG_OK;
3117 } else if (PyLong_Check(obj)) {
3118 long v = PyLong_AsLong(obj);
3119 if (!PyErr_Occurred()) {
3120 if (val) *val = v;
3121 return SWIG_OK;
3122 } else {
3123 PyErr_Clear();
3124 }
3125 }
3126 #ifdef SWIG_PYTHON_CAST_MODE
3127 {
3128 int dispatch = 0;
3129 long v = PyInt_AsLong(obj);
3130 if (!PyErr_Occurred()) {
3131 if (val) *val = v;
3132 return SWIG_AddCast(SWIG_OK);
3133 } else {
3134 PyErr_Clear();
3135 }
3136 if (!dispatch) {
3137 double d;
3138 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3139 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3140 if (val) *val = (long)(d);
3141 return res;
3142 }
3143 }
3144 }
3145 #endif
3146 return SWIG_TypeError;
3147 }
3148
3149
3150 SWIGINTERN int
3151 SWIG_AsVal_int (PyObject * obj, int *val)
3152 {
3153 long v;
3154 int res = SWIG_AsVal_long (obj, &v);
3155 if (SWIG_IsOK(res)) {
3156 if ((v < INT_MIN || v > INT_MAX)) {
3157 return SWIG_OverflowError;
3158 } else {
3159 if (val) *val = (int)(v);
3160 }
3161 }
3162 return res;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3168 {
3169 if (PyInt_Check(obj)) {
3170 long v = PyInt_AsLong(obj);
3171 if (v >= 0) {
3172 if (val) *val = v;
3173 return SWIG_OK;
3174 } else {
3175 return SWIG_OverflowError;
3176 }
3177 } else if (PyLong_Check(obj)) {
3178 unsigned long v = PyLong_AsUnsignedLong(obj);
3179 if (!PyErr_Occurred()) {
3180 if (val) *val = v;
3181 return SWIG_OK;
3182 } else {
3183 PyErr_Clear();
3184 }
3185 }
3186 #ifdef SWIG_PYTHON_CAST_MODE
3187 {
3188 int dispatch = 0;
3189 unsigned long v = PyLong_AsUnsignedLong(obj);
3190 if (!PyErr_Occurred()) {
3191 if (val) *val = v;
3192 return SWIG_AddCast(SWIG_OK);
3193 } else {
3194 PyErr_Clear();
3195 }
3196 if (!dispatch) {
3197 double d;
3198 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3199 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3200 if (val) *val = (unsigned long)(d);
3201 return res;
3202 }
3203 }
3204 }
3205 #endif
3206 return SWIG_TypeError;
3207 }
3208
3209
3210 SWIGINTERN int
3211 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3212 {
3213 unsigned long v;
3214 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3215 if (SWIG_IsOK(res)) {
3216 if ((v > UINT_MAX)) {
3217 return SWIG_OverflowError;
3218 } else {
3219 if (val) *val = (unsigned int)(v);
3220 }
3221 }
3222 return res;
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject*
3227 SWIG_From_unsigned_SS_int (unsigned int value)
3228 {
3229 return PyInt_FromSize_t((size_t) value);
3230 }
3231
3232
3233 SWIGINTERN swig_type_info*
3234 SWIG_pchar_descriptor(void)
3235 {
3236 static int init = 0;
3237 static swig_type_info* info = 0;
3238 if (!init) {
3239 info = SWIG_TypeQuery("_p_char");
3240 init = 1;
3241 }
3242 return info;
3243 }
3244
3245
3246 SWIGINTERN int
3247 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3248 {
3249 #if PY_VERSION_HEX>=0x03000000
3250 if (PyUnicode_Check(obj))
3251 #else
3252 if (PyString_Check(obj))
3253 #endif
3254 {
3255 char *cstr; Py_ssize_t len;
3256 #if PY_VERSION_HEX>=0x03000000
3257 if (!alloc && cptr) {
3258 /* We can't allow converting without allocation, since the internal
3259 representation of string in Python 3 is UCS-2/UCS-4 but we require
3260 a UTF-8 representation.
3261 TODO(bhy) More detailed explanation */
3262 return SWIG_RuntimeError;
3263 }
3264 obj = PyUnicode_AsUTF8String(obj);
3265 PyBytes_AsStringAndSize(obj, &cstr, &len);
3266 if(alloc) *alloc = SWIG_NEWOBJ;
3267 #else
3268 PyString_AsStringAndSize(obj, &cstr, &len);
3269 #endif
3270 if (cptr) {
3271 if (alloc) {
3272 /*
3273 In python the user should not be able to modify the inner
3274 string representation. To warranty that, if you define
3275 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3276 buffer is always returned.
3277
3278 The default behavior is just to return the pointer value,
3279 so, be careful.
3280 */
3281 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3282 if (*alloc != SWIG_OLDOBJ)
3283 #else
3284 if (*alloc == SWIG_NEWOBJ)
3285 #endif
3286 {
3287 *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3288 *alloc = SWIG_NEWOBJ;
3289 }
3290 else {
3291 *cptr = cstr;
3292 *alloc = SWIG_OLDOBJ;
3293 }
3294 } else {
3295 #if PY_VERSION_HEX>=0x03000000
3296 assert(0); /* Should never reach here in Python 3 */
3297 #endif
3298 *cptr = SWIG_Python_str_AsChar(obj);
3299 }
3300 }
3301 if (psize) *psize = len + 1;
3302 #if PY_VERSION_HEX>=0x03000000
3303 Py_XDECREF(obj);
3304 #endif
3305 return SWIG_OK;
3306 } else {
3307 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3308 if (pchar_descriptor) {
3309 void* vptr = 0;
3310 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3311 if (cptr) *cptr = (char *) vptr;
3312 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3313 if (alloc) *alloc = SWIG_OLDOBJ;
3314 return SWIG_OK;
3315 }
3316 }
3317 }
3318 return SWIG_TypeError;
3319 }
3320
3321
3322 SWIGINTERN int
3323 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3324 {
3325 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3326 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3327 if (SWIG_IsOK(res)) {
3328 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3329 if (csize <= size) {
3330 if (val) {
3331 if (csize) memcpy(val, cptr, csize*sizeof(char));
3332 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3333 }
3334 if (alloc == SWIG_NEWOBJ) {
3335 free((char*)cptr);
3336 res = SWIG_DelNewMask(res);
3337 }
3338 return res;
3339 }
3340 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3348 {
3349 if (carray) {
3350 if (size > INT_MAX) {
3351 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3352 return pchar_descriptor ?
3353 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3354 } else {
3355 #if PY_VERSION_HEX >= 0x03000000
3356 return PyUnicode_FromStringAndSize(carray, (int)(size));
3357 #else
3358 return PyString_FromStringAndSize(carray, (int)(size));
3359 #endif
3360 }
3361 } else {
3362 return SWIG_Py_Void();
3363 }
3364 }
3365
3366
3367
3368
3369
3370 #define t_output_helper SWIG_Python_AppendOutput
3371
3372
3373 SWIGINTERN int
3374 SWIG_AsVal_char (PyObject * obj, char *val)
3375 {
3376 int res = SWIG_AsCharArray(obj, val, 1);
3377 if (!SWIG_IsOK(res)) {
3378 long v;
3379 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3380 if (SWIG_IsOK(res)) {
3381 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3382 if (val) *val = (char)(v);
3383 } else {
3384 res = SWIG_OverflowError;
3385 }
3386 }
3387 }
3388 return res;
3389 }
3390
3391 #ifdef __cplusplus
3392 extern "C" {
3393 #endif
3394
3395 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3396
3397 // some really twisted stuff to allow calling a single precision library from python
3398 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3399 {
3400 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3401 mindims, maxdims );
3402 if ( !tmp )
3403 {
3404 // could be an incoming long array which can't be "safely" converted, do it anyway
3405 if ( PyArray_Check( in ) )
3406 {
3407 PyErr_Clear();
3408 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3409 }
3410 }
3411 return tmp;
3412 }
3413
3414
3415 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3416
3417 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3418 PyObject *resultobj = 0;
3419 PLFLT arg1 ;
3420 PLFLT arg2 ;
3421 PLFLT *arg3 = (PLFLT *) 0 ;
3422 PLFLT *arg4 = (PLFLT *) 0 ;
3423 PLPointer arg5 = (PLPointer) 0 ;
3424 double val1 ;
3425 int ecode1 = 0 ;
3426 double val2 ;
3427 int ecode2 = 0 ;
3428 PLFLT temp3 ;
3429 int res3 = SWIG_TMPOBJ ;
3430 PLFLT temp4 ;
3431 int res4 = SWIG_TMPOBJ ;
3432 PyObject * obj0 = 0 ;
3433 PyObject * obj1 = 0 ;
3434
3435 arg3 = &temp3;
3436 arg4 = &temp4;
3437 {
3438 arg5 = NULL;
3439 }
3440 if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3441 ecode1 = SWIG_AsVal_double(obj0, &val1);
3442 if (!SWIG_IsOK(ecode1)) {
3443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3444 }
3445 arg1 = (PLFLT)(val1);
3446 ecode2 = SWIG_AsVal_double(obj1, &val2);
3447 if (!SWIG_IsOK(ecode2)) {
3448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3449 }
3450 arg2 = (PLFLT)(val2);
3451 pltr0(arg1,arg2,arg3,arg4,arg5);
3452 resultobj = SWIG_Py_Void();
3453 if (SWIG_IsTmpObj(res3)) {
3454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3455 } else {
3456 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3458 }
3459 if (SWIG_IsTmpObj(res4)) {
3460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3461 } else {
3462 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3464 }
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471
3472 PyArrayObject *pltr_xg, *pltr_yg;
3473 static PLcGrid tmpGrid1;
3474 static PLcGrid2 tmpGrid2;
3475
3476 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3477 void cleanup_PLcGrid1( void );
3478 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3479 void cleanup_PLcGrid2( void );
3480
3481 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3482 {
3483 // fprintf(stderr, "marshal PLcGrid1\n");
3484 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3485 {
3486 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3487 return NULL;
3488 }
3489 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3490 NPY_PLFLT, 1, 1 );
3491 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3492 NPY_PLFLT, 1, 1 );
3493 if ( pltr_xg == 0 || pltr_yg == 0 )
3494 {
3495 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3496 return NULL;
3497 }
3498 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3499 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3500 if ( isimg == 0 )
3501 {
3502 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3503 {
3504 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3505 return NULL;
3506 }
3507 }
3508 else
3509 {
3510 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3511 {
3512 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3513 return NULL;
3514 }
3515 }
3516 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3517 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3518 return &tmpGrid1;
3519 }
3520
3521 void cleanup_PLcGrid1( void )
3522 {
3523 // fprintf(stderr, "cleanup PLcGrid1\n");
3524 Py_CLEAR( pltr_xg );
3525 Py_CLEAR( pltr_yg );
3526 }
3527
3528 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3529 {
3530 int i, size;
3531 // fprintf(stderr, "marshal PLcGrid2\n");
3532 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3533 {
3534 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3535 return NULL;
3536 }
3537 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3538 NPY_PLFLT, 2, 2 );
3539 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3540 NPY_PLFLT, 2, 2 );
3541 if ( pltr_xg == 0 || pltr_yg == 0 )
3542 {
3543 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3544 return NULL;
3545 }
3546 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3547 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3548 {
3549 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3550 return NULL;
3551 }
3552 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3553 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3554 if ( isimg == 0 )
3555 {
3556 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3557 {
3558 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3559 return NULL;
3560 }
3561 }
3562 else
3563 {
3564 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3565 {
3566 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3567 return NULL;
3568 }
3569 }
3570 size = tmpGrid2.ny;
3571 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3572 for ( i = 0; i < tmpGrid2.nx; i++ )
3573 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3574 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3575 for ( i = 0; i < tmpGrid2.nx; i++ )
3576 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3577 return &tmpGrid2;
3578 }
3579
3580 void cleanup_PLcGrid2( void )
3581 {
3582 // fprintf(stderr, "cleanup PLcGrid2\n");
3583 free( tmpGrid2.xg );
3584 free( tmpGrid2.yg );
3585 Py_CLEAR( pltr_xg );
3586 Py_CLEAR( pltr_yg );
3587 }
3588
3589 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3590 PyObject *resultobj = 0;
3591 PLFLT arg1 ;
3592 PLFLT arg2 ;
3593 PLFLT *arg3 = (PLFLT *) 0 ;
3594 PLFLT *arg4 = (PLFLT *) 0 ;
3595 PLcGrid *arg5 = (PLcGrid *) 0 ;
3596 double val1 ;
3597 int ecode1 = 0 ;
3598 double val2 ;
3599 int ecode2 = 0 ;
3600 PLFLT temp3 ;
3601 int res3 = SWIG_TMPOBJ ;
3602 PLFLT temp4 ;
3603 int res4 = SWIG_TMPOBJ ;
3604 PyObject * obj0 = 0 ;
3605 PyObject * obj1 = 0 ;
3606 PyObject * obj2 = 0 ;
3607
3608 arg3 = &temp3;
3609 arg4 = &temp4;
3610 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3611 ecode1 = SWIG_AsVal_double(obj0, &val1);
3612 if (!SWIG_IsOK(ecode1)) {
3613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3614 }
3615 arg1 = (PLFLT)(val1);
3616 ecode2 = SWIG_AsVal_double(obj1, &val2);
3617 if (!SWIG_IsOK(ecode2)) {
3618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3619 }
3620 arg2 = (PLFLT)(val2);
3621 {
3622 arg5 = marshal_PLcGrid1( obj2, 0 );
3623 if ( !arg5 )
3624 return NULL;
3625 }
3626 pltr1(arg1,arg2,arg3,arg4,arg5);
3627 resultobj = SWIG_Py_Void();
3628 if (SWIG_IsTmpObj(res3)) {
3629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3630 } else {
3631 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3633 }
3634 if (SWIG_IsTmpObj(res4)) {
3635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3636 } else {
3637 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3639 }
3640 {
3641 cleanup_PLcGrid1();
3642 }
3643 return resultobj;
3644 fail:
3645 {
3646 cleanup_PLcGrid1();
3647 }
3648 return NULL;
3649 }
3650
3651
3652 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3653 PyObject *resultobj = 0;
3654 PLFLT arg1 ;
3655 PLFLT arg2 ;
3656 PLFLT *arg3 = (PLFLT *) 0 ;
3657 PLFLT *arg4 = (PLFLT *) 0 ;
3658 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3659 double val1 ;
3660 int ecode1 = 0 ;
3661 double val2 ;
3662 int ecode2 = 0 ;
3663 PLFLT temp3 ;
3664 int res3 = SWIG_TMPOBJ ;
3665 PLFLT temp4 ;
3666 int res4 = SWIG_TMPOBJ ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 PyObject * obj2 = 0 ;
3670
3671 arg3 = &temp3;
3672 arg4 = &temp4;
3673 if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3674 ecode1 = SWIG_AsVal_double(obj0, &val1);
3675 if (!SWIG_IsOK(ecode1)) {
3676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3677 }
3678 arg1 = (PLFLT)(val1);
3679 ecode2 = SWIG_AsVal_double(obj1, &val2);
3680 if (!SWIG_IsOK(ecode2)) {
3681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3682 }
3683 arg2 = (PLFLT)(val2);
3684 {
3685 arg5 = marshal_PLcGrid2( obj2, 0 );
3686 if ( !arg5 )
3687 return NULL;
3688 }
3689 pltr2(arg1,arg2,arg3,arg4,arg5);
3690 resultobj = SWIG_Py_Void();
3691 if (SWIG_IsTmpObj(res3)) {
3692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3693 } else {
3694 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3696 }
3697 if (SWIG_IsTmpObj(res4)) {
3698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3699 } else {
3700 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3702 }
3703 {
3704 cleanup_PLcGrid2();
3705 }
3706 return resultobj;
3707 fail:
3708 {
3709 cleanup_PLcGrid2();
3710 }
3711 return NULL;
3712 }
3713
3714
3715
3716 // helper code for handling the callback
3717 #if 0
3718 static PyInterpreterState *save_interp = NULL;
3719 #endif
3720 enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type;
3721 PyObject* python_pltr = NULL;
3722 PyObject* python_f2eval = NULL;
3723 PyObject* python_ct = NULL;
3724 PyObject* python_mapform = NULL;
3725 PyObject* python_label = NULL;
3726
3727 #if 0
3728 #define MY_BLOCK_THREADS { \
3729 PyThreadState *prev_state, *new_state; \
3730 /* need to have started a thread at some stage */ \
3731 /* for the following to work */ \
3732 PyEval_AcquireLock(); \
3733 new_state = PyThreadState_New( save_interp ); \
3734 prev_state = PyThreadState_Swap( new_state );
3735 #define MY_UNBLOCK_THREADS \
3736 new_state = PyThreadState_Swap( prev_state ); \
3737 PyThreadState_Clear( new_state ); \
3738 PyEval_ReleaseLock(); \
3739 PyThreadState_Delete( new_state ); \
3740 }
3741 #else
3742 #define MY_BLOCK_THREADS
3743 #define MY_UNBLOCK_THREADS
3744 #endif
3745
3746 // Function prototypes
3747 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3748 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data );
3749 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3750 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3751 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3752 pltr_func marshal_pltr( PyObject* input );
3753 void cleanup_pltr( void );
3754 ct_func marshal_ct( PyObject* input );
3755 void cleanup_ct( void );
3756 mapform_func marshal_mapform( PyObject* input );
3757 void cleanup_mapform( void );
3758 PLPointer marshal_PLPointer( PyObject* input, int isimg );
3759 void cleanup_PLPointer( void );
3760
3761
3762 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3763
3764 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3765 {
3766 PyObject *pdata, *arglist, *result;
3767 PyArrayObject *tmp;
3768
3769 // the data argument is acutally a pointer to a python object
3770 pdata = (PyObject *) data;
3771 if ( data == NULL )
3772 {
3773 pdata = Py_None;
3774 }
3775 if ( python_pltr ) // if not something is terribly wrong
3776 { // hold a reference to the data object
3777 Py_XINCREF( pdata );
3778 // grab the Global Interpreter Lock to be sure threads don't mess us up
3779 MY_BLOCK_THREADS
3780 // build the argument list
3781 #ifdef PL_DOUBLE
3782 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3783 #else
3784 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3785 #endif
3786 if ( arglist == NULL )
3787 {
3788 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3789 *tx = *ty = 0;
3790 return;
3791 }
3792 // call the python function
3793 result = PyEval_CallObject( python_pltr, arglist );
3794 // release the argument list
3795 Py_CLEAR( arglist );
3796 // check and unpack the result
3797 if ( result == NULL )
3798 {
3799 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3800 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
3801 *tx = *ty = 0;
3802 }
3803 else
3804 {
3805 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3806 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3807 {
3808 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3809 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3810 *tx = *ty = 0;
3811 }
3812 else
3813 {
3814 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3815 *tx = t[0];
3816 *ty = t[1];
3817 Py_CLEAR( tmp );
3818 }
3819 }
3820 // release the result
3821 Py_CLEAR( result );
3822 // release the global interpreter lock
3823 MY_UNBLOCK_THREADS
3824 }
3825 }
3826
3827 PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3828 {
3829 PyObject *pdata, *arglist, *result;
3830 PLFLT fresult = 0.0;
3831
3832 // the data argument is acutally a pointer to a python object
3833 pdata = (PyObject *) data;
3834 if ( python_f2eval ) // if not something is terribly wrong
3835 { // hold a reference to the data object
3836 Py_XINCREF( pdata );
3837 // grab the Global Interpreter Lock to be sure threads don't mess us up
3838 MY_BLOCK_THREADS
3839 // build the argument list
3840 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3841 // call the python function
3842 result = PyEval_CallObject( python_f2eval, arglist );
3843 // release the argument list
3844 Py_CLEAR( arglist );
3845 // check and unpack the result
3846 if ( !PyFloat_Check( result ) )
3847 {
3848 fprintf( stderr, "f2eval callback must return a float\n" );
3849 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3850 }
3851 else
3852 {
3853 // should I test the type here?
3854 fresult = (PLFLT) PyFloat_AsDouble( result );
3855 }
3856 // release the result
3857 Py_CLEAR( result );
3858 // release the global interpreter lock
3859 MY_UNBLOCK_THREADS
3860 }
3861 return fresult;
3862 }
3863
3864 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3865 {
3866 PyObject *pdata, *arglist, *result;
3867 char *pystring;
3868
3869 // the data argument is acutally a pointer to a python object
3870 if ( data )
3871 pdata = (PyObject *) data;
3872 else
3873 pdata = Py_None;
3874 if ( python_label ) // if not something is terribly wrong
3875 { // hold a reference to the data object
3876 Py_XINCREF( pdata );
3877 // grab the Global Interpreter Lock to be sure threads don't mess us up
3878 MY_BLOCK_THREADS
3879 // build the argument list
3880 #ifdef PL_DOUBLE
3881 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3882 #else
3883 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3884 #endif
3885 // call the python function
3886 result = PyEval_CallObject( python_label, arglist );
3887 // release the argument list
3888 //Py_CLEAR(arglist);
3889 // check and unpack the result
3890 if ( result == NULL )
3891 {
3892 fprintf( stderr, "label callback failed with 3 arguments\n" );
3893 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3894 }
3895 else if ( !PyString_Check( result ) )
3896 {
3897 fprintf( stderr, "label callback must return a string\n" );
3898 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3899 }
3900 else
3901 {
3902 // should I test the type here?
3903 pystring = PyString_AsString( result );
3904 strncpy( string, pystring, len );
3905 }
3906 // release the result
3907 Py_CLEAR( result );
3908 // release the global interpreter lock
3909 MY_UNBLOCK_THREADS
3910 }
3911 }
3912
3913 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3914 {
3915 PyObject *px, *py, *pdata, *arglist, *result;
3916 npy_intp n;
3917 n = 1;
3918
3919 // the data argument is acutally a pointer to a python object
3920 pdata = (PyObject *) data;
3921 if ( data == NULL )
3922 {
3923 pdata = Py_None;
3924 }
3925 if ( python_ct ) // if not something is terribly wrong
3926 { // hold a reference to the data object
3927 Py_XINCREF( pdata );
3928 // grab the Global Interpreter Lock to be sure threads don't mess us up
3929 MY_BLOCK_THREADS
3930 // build the argument list
3931 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3932 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3933 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3934 // call the python function
3935 result = PyEval_CallObject( python_ct, arglist );
3936 // release the argument list
3937 Py_CLEAR( arglist );
3938 Py_CLEAR( px );
3939 Py_CLEAR( py );
3940 Py_CLEAR( pdata );
3941 // check and unpack the result
3942 if ( result == NULL )
3943 {
3944 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3945 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3946 }
3947 // release the result
3948 Py_CLEAR( result );
3949 // release the global interpreter lock
3950 MY_UNBLOCK_THREADS
3951 }
3952 }
3953
3954 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
3955 {
3956 PyObject *px, *py, *arglist, *result;
3957 // PyArrayObject *tmpx, *tmpy;
3958 // PLFLT *xx, *yy;
3959 // PLINT i;
3960 npy_intp nn;
3961 nn = n;
3962
3963 if ( python_mapform ) // if not something is terribly wrong
3964 { // grab the Global Interpreter Lock to be sure threads don't mess us up
3965 MY_BLOCK_THREADS
3966 // build the argument list
3967 #ifdef PL_HAVE_PTHREAD
3968 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3969 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3970 #else
3971 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3972 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3973 #endif
3974 arglist = Py_BuildValue( "(iOO)", n, px, py );
3975 // call the python function
3976 result = PyEval_CallObject( python_mapform, arglist );
3977 // release the argument list
3978 Py_CLEAR( arglist );
3979 Py_CLEAR( px );
3980 Py_CLEAR( py );
3981 // check and unpack the result
3982 if ( result == NULL )
3983 {
3984 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3985 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3986 }
3987 // release the result
3988 Py_CLEAR( result );
3989 // release the global interpreter lock
3990 MY_UNBLOCK_THREADS
3991 }
3992 }
3993
3994 // marshal the pltr function pointer argument
3995 pltr_func marshal_pltr( PyObject* input )
3996 {
3997 pltr_func result = do_pltr_callback;
3998 PyObject * rep = PyObject_Repr( input );
3999 if ( rep )
4000 {
4001 char* str = PyString_AsString( rep );
4002 if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
4003 {
4004 result = pltr0;
4005 pltr_type = CB_0;
4006 python_pltr = NULL;
4007 }
4008 else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
4009 {
4010 result = pltr1;
4011 pltr_type = CB_1;
4012 python_pltr = NULL;
4013 }
4014 else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
4015 {
4016 result = pltr2;
4017 pltr_type = CB_2;
4018 python_pltr = NULL;
4019 }
4020 else
4021 {
4022 python_pltr = input;
4023 pltr_type = CB_Python;
4024 Py_XINCREF( input );
4025 }
4026 Py_CLEAR( rep );
4027 }
4028 else
4029 {
4030 python_pltr = input;
4031 pltr_type = CB_Python;
4032 Py_XINCREF( input );
4033 }
4034 return result;
4035 }
4036
4037 void cleanup_pltr( void )
4038 {
4039 Py_CLEAR( python_pltr );
4040 python_pltr = 0;
4041 }
4042
4043 // marshal the ct function pointer argument
4044 ct_func marshal_ct( PyObject* input )
4045 {
4046 ct_func result = do_ct_callback;
4047 python_ct = input;
4048 Py_XINCREF( input );
4049 return result;
4050 }
4051
4052 void cleanup_ct( void )
4053 {
4054 Py_CLEAR( python_ct );
4055 python_ct = 0;
4056 }
4057
4058 // marshal the mapform function pointer argument
4059 mapform_func marshal_mapform( PyObject* input )
4060 {
4061 mapform_func result = do_mapform_callback;
4062 python_mapform = input;
4063 Py_XINCREF( input );
4064 return result;
4065 }
4066
4067 void cleanup_mapform( void )
4068 {
4069 Py_CLEAR( python_mapform );
4070 python_mapform = 0;
4071 }
4072
4073 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4074 {
4075 PLPointer result = NULL;
4076 switch ( pltr_type )
4077 {
4078 case CB_0:
4079 break;
4080 case CB_1:
4081 if ( input != Py_None )
4082 result = marshal_PLcGrid1( input, isimg );
4083 break;
4084 case CB_2:
4085 if ( input != Py_None )
4086 result = marshal_PLcGrid2( input, isimg );
4087 break;
4088 case CB_Python:
4089 Py_XINCREF( input );
4090 result = (PLPointer *) input;
4091 break;
4092 default:
4093 fprintf( stderr, "pltr_type is invalid\n" );
4094 }
4095 return result;
4096 }
4097
4098 void cleanup_PLPointer( void )
4099 {
4100 switch ( pltr_type )
4101 {
4102 case CB_0:
4103 break;
4104 case CB_1:
4105 cleanup_PLcGrid1();
4106 break;
4107 case CB_2:
4108 cleanup_PLcGrid2();
4109 break;
4110 case CB_Python:
4111 Py_CLEAR( python_pltr );
4112 break;
4113 default:
4114 fprintf( stderr, "pltr_type is invalid\n" );
4115 }
4116 python_pltr = 0;
4117 pltr_type = CB_0;
4118 }
4119
4120
4121
4122 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4123 PyObject *resultobj = 0;
4124 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4125 int arg2 ;
4126 void *argp1 = 0 ;
4127 int res1 = 0 ;
4128 int val2 ;
4129 int ecode2 = 0 ;
4130 PyObject * obj0 = 0 ;
4131 PyObject * obj1 = 0 ;
4132
4133 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4135 if (!SWIG_IsOK(res1)) {
4136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4137 }
4138 arg1 = (PLGraphicsIn *)(argp1);
4139 ecode2 = SWIG_AsVal_int(obj1, &val2);
4140 if (!SWIG_IsOK(ecode2)) {
4141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4142 }
4143 arg2 = (int)(val2);
4144 if (arg1) (arg1)->type = arg2;
4145 resultobj = SWIG_Py_Void();
4146 return resultobj;
4147 fail:
4148 return NULL;
4149 }
4150
4151
4152 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4153 PyObject *resultobj = 0;
4154 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4155 void *argp1 = 0 ;
4156 int res1 = 0 ;
4157 PyObject * obj0 = 0 ;
4158 int result;
4159
4160 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4162 if (!SWIG_IsOK(res1)) {
4163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4164 }
4165 arg1 = (PLGraphicsIn *)(argp1);
4166 result = (int) ((arg1)->type);
4167 resultobj = SWIG_From_int((int)(result));
4168 return resultobj;
4169 fail:
4170 return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4175 PyObject *resultobj = 0;
4176 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4177 unsigned int arg2 ;
4178 void *argp1 = 0 ;
4179 int res1 = 0 ;
4180 unsigned int val2 ;
4181 int ecode2 = 0 ;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184
4185 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4187 if (!SWIG_IsOK(res1)) {
4188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4189 }
4190 arg1 = (PLGraphicsIn *)(argp1);
4191 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4192 if (!SWIG_IsOK(ecode2)) {
4193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4194 }
4195 arg2 = (unsigned int)(val2);
4196 if (arg1) (arg1)->state = arg2;
4197 resultobj = SWIG_Py_Void();
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4205 PyObject *resultobj = 0;
4206 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4207 void *argp1 = 0 ;
4208 int res1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 unsigned int result;
4211
4212 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4214 if (!SWIG_IsOK(res1)) {
4215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4216 }
4217 arg1 = (PLGraphicsIn *)(argp1);
4218 result = (unsigned int) ((arg1)->state);
4219 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4227 PyObject *resultobj = 0;
4228 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4229 unsigned int arg2 ;
4230 void *argp1 = 0 ;
4231 int res1 = 0 ;
4232 unsigned int val2 ;
4233 int ecode2 = 0 ;
4234 PyObject * obj0 = 0 ;
4235 PyObject * obj1 = 0 ;
4236
4237 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4239 if (!SWIG_IsOK(res1)) {
4240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4241 }
4242 arg1 = (PLGraphicsIn *)(argp1);
4243 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4244 if (!SWIG_IsOK(ecode2)) {
4245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4246 }
4247 arg2 = (unsigned int)(val2);
4248 if (arg1) (arg1)->keysym = arg2;
4249 resultobj = SWIG_Py_Void();
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4257 PyObject *resultobj = 0;
4258 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 PyObject * obj0 = 0 ;
4262 unsigned int result;
4263
4264 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4266 if (!SWIG_IsOK(res1)) {
4267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4268 }
4269 arg1 = (PLGraphicsIn *)(argp1);
4270 result = (unsigned int) ((arg1)->keysym);
4271 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4279 PyObject *resultobj = 0;
4280 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4281 unsigned int arg2 ;
4282 void *argp1 = 0 ;
4283 int res1 = 0 ;
4284 unsigned int val2 ;
4285 int ecode2 = 0 ;
4286 PyObject * obj0 = 0 ;
4287 PyObject * obj1 = 0 ;
4288
4289 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4291 if (!SWIG_IsOK(res1)) {
4292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4293 }
4294 arg1 = (PLGraphicsIn *)(argp1);
4295 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4296 if (!SWIG_IsOK(ecode2)) {
4297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4298 }
4299 arg2 = (unsigned int)(val2);
4300 if (arg1) (arg1)->button = arg2;
4301 resultobj = SWIG_Py_Void();
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309 PyObject *resultobj = 0;
4310 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4311 void *argp1 = 0 ;
4312 int res1 = 0 ;
4313 PyObject * obj0 = 0 ;
4314 unsigned int result;
4315
4316 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4318 if (!SWIG_IsOK(res1)) {
4319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4320 }
4321 arg1 = (PLGraphicsIn *)(argp1);
4322 result = (unsigned int) ((arg1)->button);
4323 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 PyObject *resultobj = 0;
4332 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4333 PLINT arg2 ;
4334 void *argp1 = 0 ;
4335 int res1 = 0 ;
4336 int val2 ;
4337 int ecode2 = 0 ;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4340
4341 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4343 if (!SWIG_IsOK(res1)) {
4344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4345 }
4346 arg1 = (PLGraphicsIn *)(argp1);
4347 ecode2 = SWIG_AsVal_int(obj1, &val2);
4348 if (!SWIG_IsOK(ecode2)) {
4349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4350 }
4351 arg2 = (PLINT)(val2);
4352 if (arg1) (arg1)->subwindow = arg2;
4353 resultobj = SWIG_Py_Void();
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4361 PyObject *resultobj = 0;
4362 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4363 void *argp1 = 0 ;
4364 int res1 = 0 ;
4365 PyObject * obj0 = 0 ;
4366 PLINT result;
4367
4368 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4370 if (!SWIG_IsOK(res1)) {
4371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4372 }
4373 arg1 = (PLGraphicsIn *)(argp1);
4374 result = (PLINT) ((arg1)->subwindow);
4375 resultobj = SWIG_From_int((int)(result));
4376 return resultobj;
4377 fail:
4378 return NULL;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4383 PyObject *resultobj = 0;
4384 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4385 char *arg2 ;
4386 void *argp1 = 0 ;
4387 int res1 = 0 ;
4388 char temp2[16] ;
4389 int res2 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392
4393 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4395 if (!SWIG_IsOK(res1)) {
4396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4397 }
4398 arg1 = (PLGraphicsIn *)(argp1);
4399 res2 = SWIG_AsCharArray(obj1, temp2, 16);
4400 if (!SWIG_IsOK(res2)) {
4401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4402 }
4403 arg2 = (char *)(temp2);
4404 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4405 else memset(arg1->string,0,16*sizeof(char));
4406 resultobj = SWIG_Py_Void();
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject * obj0 = 0 ;
4419 char *result = 0 ;
4420
4421 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4425 }
4426 arg1 = (PLGraphicsIn *)(argp1);
4427 result = (char *)(char *) ((arg1)->string);
4428 {
4429 size_t size = 16;
4430
4431 while (size && (result[size - 1] == '\0')) --size;
4432
4433 resultobj = SWIG_FromCharPtrAndSize(result, size);
4434 }
4435 return resultobj;
4436 fail:
4437 return NULL;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4444 int arg2 ;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 int val2 ;
4448 int ecode2 = 0 ;
4449 PyObject * obj0 = 0 ;
4450 PyObject * obj1 = 0 ;
4451
4452 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4454 if (!SWIG_IsOK(res1)) {
4455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4456 }
4457 arg1 = (PLGraphicsIn *)(argp1);
4458 ecode2 = SWIG_AsVal_int(obj1, &val2);
4459 if (!SWIG_IsOK(ecode2)) {
4460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4461 }
4462 arg2 = (int)(val2);
4463 if (arg1) (arg1)->pX = arg2;
4464 resultobj = SWIG_Py_Void();
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472 PyObject *resultobj = 0;
4473 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4474 void *argp1 = 0 ;
4475 int res1 = 0 ;
4476 PyObject * obj0 = 0 ;
4477 int result;
4478
4479 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4481 if (!SWIG_IsOK(res1)) {
4482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4483 }
4484 arg1 = (PLGraphicsIn *)(argp1);
4485 result = (int) ((arg1)->pX);
4486 resultobj = SWIG_From_int((int)(result));
4487 return resultobj;
4488 fail:
4489 return NULL;
4490 }
4491
4492
4493 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4494 PyObject *resultobj = 0;
4495 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4496 int arg2 ;
4497 void *argp1 = 0 ;
4498 int res1 = 0 ;
4499 int val2 ;
4500 int ecode2 = 0 ;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4503
4504 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4508 }
4509 arg1 = (PLGraphicsIn *)(argp1);
4510 ecode2 = SWIG_AsVal_int(obj1, &val2);
4511 if (!SWIG_IsOK(ecode2)) {
4512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4513 }
4514 arg2 = (int)(val2);
4515 if (arg1) (arg1)->pY = arg2;
4516 resultobj = SWIG_Py_Void();
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4524 PyObject *resultobj = 0;
4525 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4526 void *argp1 = 0 ;
4527 int res1 = 0 ;
4528 PyObject * obj0 = 0 ;
4529 int result;
4530
4531 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4533 if (!SWIG_IsOK(res1)) {
4534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4535 }
4536 arg1 = (PLGraphicsIn *)(argp1);
4537 result = (int) ((arg1)->pY);
4538 resultobj = SWIG_From_int((int)(result));
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546 PyObject *resultobj = 0;
4547 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4548 PLFLT arg2 ;
4549 void *argp1 = 0 ;
4550 int res1 = 0 ;
4551 double val2 ;
4552 int ecode2 = 0 ;
4553 PyObject * obj0 = 0 ;
4554 PyObject * obj1 = 0 ;
4555
4556 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4558 if (!SWIG_IsOK(res1)) {
4559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4560 }
4561 arg1 = (PLGraphicsIn *)(argp1);
4562 ecode2 = SWIG_AsVal_double(obj1, &val2);
4563 if (!SWIG_IsOK(ecode2)) {
4564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4565 }
4566 arg2 = (PLFLT)(val2);
4567 if (arg1) (arg1)->dX = arg2;
4568 resultobj = SWIG_Py_Void();
4569 return resultobj;
4570 fail:
4571 return NULL;
4572 }
4573
4574
4575 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4576 PyObject *resultobj = 0;
4577 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4578 void *argp1 = 0 ;
4579 int res1 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PLFLT result;
4582
4583 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4585 if (!SWIG_IsOK(res1)) {
4586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4587 }
4588 arg1 = (PLGraphicsIn *)(argp1);
4589 result = (PLFLT) ((arg1)->dX);
4590 resultobj = SWIG_From_double((double)(result));
4591 return resultobj;
4592 fail:
4593 return NULL;
4594 }
4595
4596
4597 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4598 PyObject *resultobj = 0;
4599 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4600 PLFLT arg2 ;
4601 void *argp1 = 0 ;
4602 int res1 = 0 ;
4603 double val2 ;
4604 int ecode2 = 0 ;
4605 PyObject * obj0 = 0 ;
4606 PyObject * obj1 = 0 ;
4607
4608 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4612 }
4613 arg1 = (PLGraphicsIn *)(argp1);
4614 ecode2 = SWIG_AsVal_double(obj1, &val2);
4615 if (!SWIG_IsOK(ecode2)) {
4616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4617 }
4618 arg2 = (PLFLT)(val2);
4619 if (arg1) (arg1)->dY = arg2;
4620 resultobj = SWIG_Py_Void();
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628 PyObject *resultobj = 0;
4629 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4630 void *argp1 = 0 ;
4631 int res1 = 0 ;
4632 PyObject * obj0 = 0 ;
4633 PLFLT result;
4634
4635 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4637 if (!SWIG_IsOK(res1)) {
4638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4639 }
4640 arg1 = (PLGraphicsIn *)(argp1);
4641 result = (PLFLT) ((arg1)->dY);
4642 resultobj = SWIG_From_double((double)(result));
4643 return resultobj;
4644 fail:
4645 return NULL;
4646 }
4647
4648
4649 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4650 PyObject *resultobj = 0;
4651 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4652 PLFLT arg2 ;
4653 void *argp1 = 0 ;
4654 int res1 = 0 ;
4655 double val2 ;
4656 int ecode2 = 0 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659
4660 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4664 }
4665 arg1 = (PLGraphicsIn *)(argp1);
4666 ecode2 = SWIG_AsVal_double(obj1, &val2);
4667 if (!SWIG_IsOK(ecode2)) {
4668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4669 }
4670 arg2 = (PLFLT)(val2);
4671 if (arg1) (arg1)->wX = arg2;
4672 resultobj = SWIG_Py_Void();
4673 return resultobj;
4674 fail:
4675 return NULL;
4676 }
4677
4678
4679 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4680 PyObject *resultobj = 0;
4681 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4682 void *argp1 = 0 ;
4683 int res1 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PLFLT result;
4686
4687 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4689 if (!SWIG_IsOK(res1)) {
4690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4691 }
4692 arg1 = (PLGraphicsIn *)(argp1);
4693 result = (PLFLT) ((arg1)->wX);
4694 resultobj = SWIG_From_double((double)(result));
4695 return resultobj;
4696 fail:
4697 return NULL;
4698 }
4699
4700
4701 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702 PyObject *resultobj = 0;
4703 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4704 PLFLT arg2 ;
4705 void *argp1 = 0 ;
4706 int res1 = 0 ;
4707 double val2 ;
4708 int ecode2 = 0 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711
4712 if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4714 if (!SWIG_IsOK(res1)) {
4715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4716 }
4717 arg1 = (PLGraphicsIn *)(argp1);
4718 ecode2 = SWIG_AsVal_double(obj1, &val2);
4719 if (!SWIG_IsOK(ecode2)) {
4720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4721 }
4722 arg2 = (PLFLT)(val2);
4723 if (arg1) (arg1)->wY = arg2;
4724 resultobj = SWIG_Py_Void();
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4732 PyObject *resultobj = 0;
4733 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4734 void *argp1 = 0 ;
4735 int res1 = 0 ;
4736 PyObject * obj0 = 0 ;
4737 PLFLT result;
4738
4739 if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4743 }
4744 arg1 = (PLGraphicsIn *)(argp1);
4745 result = (PLFLT) ((arg1)->wY);
4746 resultobj = SWIG_From_double((double)(result));
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4754 PyObject *resultobj = 0;
4755 PLGraphicsIn *result = 0 ;
4756
4757 if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4758 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW | 0 );
4760 return resultobj;
4761 fail:
4762 return NULL;
4763 }
4764
4765
4766 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4767 PyObject *resultobj = 0;
4768 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4769 void *argp1 = 0 ;
4770 int res1 = 0 ;
4771 PyObject * obj0 = 0 ;
4772
4773 if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4775 if (!SWIG_IsOK(res1)) {
4776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4777 }
4778 arg1 = (PLGraphicsIn *)(argp1);
4779 free((char *) arg1);
4780 resultobj = SWIG_Py_Void();
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4788 PyObject *obj;
4789 if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4790 SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj));
4791 return SWIG_Py_Void();
4792 }
4793
4794 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4795 PyObject *resultobj = 0;
4796 PLINT arg1 ;
4797 int val1 ;
4798 int ecode1 = 0 ;
4799 PyObject * obj0 = 0 ;
4800
4801 if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4802 ecode1 = SWIG_AsVal_int(obj0, &val1);
4803 if (!SWIG_IsOK(ecode1)) {
4804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4805 }
4806 arg1 = (PLINT)(val1);
4807 plsxwin(arg1);
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4816 PyObject *resultobj = 0;
4817 PLINT arg1 ;
4818 PLINT arg2 ;
4819 int val1 ;
4820 int ecode1 = 0 ;
4821 int val2 ;
4822 int ecode2 = 0 ;
4823 PyObject * obj0 = 0 ;
4824 PyObject * obj1 = 0 ;
4825
4826 if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4827 ecode1 = SWIG_AsVal_int(obj0, &val1);
4828 if (!SWIG_IsOK(ecode1)) {
4829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4830 }
4831 arg1 = (PLINT)(val1);
4832 ecode2 = SWIG_AsVal_int(obj1, &val2);
4833 if (!SWIG_IsOK(ecode2)) {
4834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4835 }
4836 arg2 = (PLINT)(val2);
4837 pl_setcontlabelformat(arg1,arg2);
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847 PLFLT arg1 ;
4848 PLFLT arg2 ;
4849 PLFLT arg3 ;
4850 PLINT arg4 ;
4851 double val1 ;
4852 int ecode1 = 0 ;
4853 double val2 ;
4854 int ecode2 = 0 ;
4855 double val3 ;
4856 int ecode3 = 0 ;
4857 int val4 ;
4858 int ecode4 = 0 ;
4859 PyObject * obj0 = 0 ;
4860 PyObject * obj1 = 0 ;
4861 PyObject * obj2 = 0 ;
4862 PyObject * obj3 = 0 ;
4863
4864 if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4865 ecode1 = SWIG_AsVal_double(obj0, &val1);
4866 if (!SWIG_IsOK(ecode1)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4868 }
4869 arg1 = (PLFLT)(val1);
4870 ecode2 = SWIG_AsVal_double(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4873 }
4874 arg2 = (PLFLT)(val2);
4875 ecode3 = SWIG_AsVal_double(obj2, &val3);
4876 if (!SWIG_IsOK(ecode3)) {
4877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4878 }
4879 arg3 = (PLFLT)(val3);
4880 ecode4 = SWIG_AsVal_int(obj3, &val4);
4881 if (!SWIG_IsOK(ecode4)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4883 }
4884 arg4 = (PLINT)(val4);
4885 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4886 resultobj = SWIG_Py_Void();
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4894 PyObject *resultobj = 0;
4895 PLINT arg1 ;
4896 int val1 ;
4897 int ecode1 = 0 ;
4898 PyObject * obj0 = 0 ;
4899
4900 if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
4901 ecode1 = SWIG_AsVal_int(obj0, &val1);
4902 if (!SWIG_IsOK(ecode1)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4904 }
4905 arg1 = (PLINT)(val1);
4906 pladv(arg1);
4907 resultobj = SWIG_Py_Void();
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916 PLFLT arg1 ;
4917 PLFLT arg2 ;
4918 PLFLT arg3 ;
4919 PLFLT arg4 ;
4920 PLFLT arg5 ;
4921 PLFLT arg6 ;
4922 PLFLT arg7 ;
4923 PLBOOL arg8 ;
4924 double val1 ;
4925 int ecode1 = 0 ;
4926 double val2 ;
4927 int ecode2 = 0 ;
4928 double val3 ;
4929 int ecode3 = 0 ;
4930 double val4 ;
4931 int ecode4 = 0 ;
4932 double val5 ;
4933 int ecode5 = 0 ;
4934 double val6 ;
4935 int ecode6 = 0 ;
4936 double val7 ;
4937 int ecode7 = 0 ;
4938 int val8 ;
4939 int ecode8 = 0 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 PyObject * obj2 = 0 ;
4943 PyObject * obj3 = 0 ;
4944 PyObject * obj4 = 0 ;
4945 PyObject * obj5 = 0 ;
4946 PyObject * obj6 = 0 ;
4947 PyObject * obj7 = 0 ;
4948
4949 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4950 ecode1 = SWIG_AsVal_double(obj0, &val1);
4951 if (!SWIG_IsOK(ecode1)) {
4952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4953 }
4954 arg1 = (PLFLT)(val1);
4955 ecode2 = SWIG_AsVal_double(obj1, &val2);
4956 if (!SWIG_IsOK(ecode2)) {
4957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4958 }
4959 arg2 = (PLFLT)(val2);
4960 ecode3 = SWIG_AsVal_double(obj2, &val3);
4961 if (!SWIG_IsOK(ecode3)) {
4962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4963 }
4964 arg3 = (PLFLT)(val3);
4965 ecode4 = SWIG_AsVal_double(obj3, &val4);
4966 if (!SWIG_IsOK(ecode4)) {
4967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4968 }
4969 arg4 = (PLFLT)(val4);
4970 ecode5 = SWIG_AsVal_double(obj4, &val5);
4971 if (!SWIG_IsOK(ecode5)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4973 }
4974 arg5 = (PLFLT)(val5);
4975 ecode6 = SWIG_AsVal_double(obj5, &val6);
4976 if (!SWIG_IsOK(ecode6)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4978 }
4979 arg6 = (PLFLT)(val6);
4980 ecode7 = SWIG_AsVal_double(obj6, &val7);
4981 if (!SWIG_IsOK(ecode7)) {
4982 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4983 }
4984 arg7 = (PLFLT)(val7);
4985 ecode8 = SWIG_AsVal_int(obj7, &val8);
4986 if (!SWIG_IsOK(ecode8)) {
4987 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4988 }
4989 arg8 = (PLBOOL)(val8);
4990 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4991 resultobj = SWIG_Py_Void();
4992 return resultobj;
4993 fail:
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000 PLFLT arg1 ;
5001 PLFLT arg2 ;
5002 char *arg3 = (char *) 0 ;
5003 PLFLT arg4 ;
5004 PLINT arg5 ;
5005 char *arg6 = (char *) 0 ;
5006 PLFLT arg7 ;
5007 PLINT arg8 ;
5008 double val1 ;
5009 int ecode1 = 0 ;
5010 double val2 ;
5011 int ecode2 = 0 ;
5012 int res3 ;
5013 char *buf3 = 0 ;
5014 int alloc3 = 0 ;
5015 double val4 ;
5016 int ecode4 = 0 ;
5017 int val5 ;
5018 int ecode5 = 0 ;
5019 int res6 ;
5020 char *buf6 = 0 ;
5021 int alloc6 = 0 ;
5022 double val7 ;
5023 int ecode7 = 0 ;
5024 int val8 ;
5025 int ecode8 = 0 ;
5026 PyObject * obj0 = 0 ;
5027 PyObject * obj1 = 0 ;
5028 PyObject * obj2 = 0 ;
5029 PyObject * obj3 = 0 ;
5030 PyObject * obj4 = 0 ;
5031 PyObject * obj5 = 0 ;
5032 PyObject * obj6 = 0 ;
5033 PyObject * obj7 = 0 ;
5034
5035 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5036 ecode1 = SWIG_AsVal_double(obj0, &val1);
5037 if (!SWIG_IsOK(ecode1)) {
5038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5039 }
5040 arg1 = (PLFLT)(val1);
5041 ecode2 = SWIG_AsVal_double(obj1, &val2);
5042 if (!SWIG_IsOK(ecode2)) {
5043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5044 }
5045 arg2 = (PLFLT)(val2);
5046 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5047 if (!SWIG_IsOK(res3)) {
5048 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5049 }
5050 arg3 = (char *)(buf3);
5051 ecode4 = SWIG_AsVal_double(obj3, &val4);
5052 if (!SWIG_IsOK(ecode4)) {
5053 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5054 }
5055 arg4 = (PLFLT)(val4);
5056 ecode5 = SWIG_AsVal_int(obj4, &val5);
5057 if (!SWIG_IsOK(ecode5)) {
5058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5059 }
5060 arg5 = (PLINT)(val5);
5061 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5062 if (!SWIG_IsOK(res6)) {
5063 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5064 }
5065 arg6 = (char *)(buf6);
5066 ecode7 = SWIG_AsVal_double(obj6, &val7);
5067 if (!SWIG_IsOK(ecode7)) {
5068 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5069 }
5070 arg7 = (PLFLT)(val7);
5071 ecode8 = SWIG_AsVal_int(obj7, &val8);
5072 if (!SWIG_IsOK(ecode8)) {
5073 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5074 }
5075 arg8 = (PLINT)(val8);
5076 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5077 resultobj = SWIG_Py_Void();
5078 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5079 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5080 return resultobj;
5081 fail:
5082 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5083 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5084 return NULL;
5085 }
5086
5087
5088 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5089 PyObject *resultobj = 0;
5090 PLINT arg1 ;
5091 PLFLT *arg2 = (PLFLT *) 0 ;
5092 PLFLT *arg3 = (PLFLT *) 0 ;
5093 PLINT arg4 ;
5094 PyArrayObject *tmp1 = NULL ;
5095 PyArrayObject *tmp3 = NULL ;
5096 int val4 ;
5097 int ecode4 = 0 ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 PyObject * obj2 = 0 ;
5101
5102 if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5103 {
5104 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5105 if ( tmp1 == NULL )
5106 return NULL;
5107 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5108 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5109 }
5110 {
5111 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5112 if ( tmp3 == NULL )
5113 return NULL;
5114 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5115 {
5116 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5117 return NULL;
5118 }
5119 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5120 }
5121 ecode4 = SWIG_AsVal_int(obj2, &val4);
5122 if (!SWIG_IsOK(ecode4)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5124 }
5125 arg4 = (PLINT)(val4);
5126 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5127 resultobj = SWIG_Py_Void();
5128 {
5129 Py_CLEAR( tmp1 );
5130 }
5131 {
5132 Py_CLEAR( tmp3 );
5133 }
5134 return resultobj;
5135 fail:
5136 {
5137 Py_CLEAR( tmp1 );
5138 }
5139 {
5140 Py_CLEAR( tmp3 );
5141 }
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 PLINT *arg1 = (PLINT *) 0 ;
5149 PLINT *arg2 = (PLINT *) 0 ;
5150 PLINT *arg3 = (PLINT *) 0 ;
5151 PLINT *arg4 = (PLINT *) 0 ;
5152 PLINT *arg5 = (PLINT *) 0 ;
5153 PLFLT *arg6 = (PLFLT *) 0 ;
5154 PLFLT arg7 ;
5155 PLINT temp1 ;
5156 int res1 = SWIG_TMPOBJ ;
5157 PLINT temp2 ;
5158 int res2 = SWIG_TMPOBJ ;
5159 PLINT temp3 ;
5160 int res3 = SWIG_TMPOBJ ;
5161 PLINT temp4 ;
5162 int res4 = SWIG_TMPOBJ ;
5163 PLINT temp5 ;
5164 int res5 = SWIG_TMPOBJ ;
5165 PLFLT temp6 ;
5166 int res6 = SWIG_TMPOBJ ;
5167 double val7 ;
5168 int ecode7 = 0 ;
5169 PyObject * obj0 = 0 ;
5170
5171 arg1 = &temp1;
5172 arg2 = &temp2;
5173 arg3 = &temp3;
5174 arg4 = &temp4;
5175 arg5 = &temp5;
5176 arg6 = &temp6;
5177 if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5178 ecode7 = SWIG_AsVal_double(obj0, &val7);
5179 if (!SWIG_IsOK(ecode7)) {
5180 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5181 }
5182 arg7 = (PLFLT)(val7);
5183 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5184 resultobj = SWIG_Py_Void();
5185 if (SWIG_IsTmpObj(res1)) {
5186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5187 } else {
5188 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5190 }
5191 if (SWIG_IsTmpObj(res2)) {
5192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5193 } else {
5194 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5196 }
5197 if (SWIG_IsTmpObj(res3)) {
5198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5199 } else {
5200 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5202 }
5203 if (SWIG_IsTmpObj(res4)) {
5204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5205 } else {
5206 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5208 }
5209 if (SWIG_IsTmpObj(res5)) {
5210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5211 } else {
5212 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5214 }
5215 if (SWIG_IsTmpObj(res6)) {
5216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5217 } else {
5218 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5220 }
5221 return resultobj;
5222 fail:
5223 return NULL;
5224 }
5225
5226
5227 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5228 PyObject *resultobj = 0;
5229
5230 if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5231 plbop();
5232 resultobj = SWIG_Py_Void();
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5240 PyObject *resultobj = 0;
5241 char *arg1 = (char *) 0 ;
5242 PLFLT arg2 ;
5243 PLINT arg3 ;
5244 char *arg4 = (char *) 0 ;
5245 PLFLT arg5 ;
5246 PLINT arg6 ;
5247 int res1 ;
5248 char *buf1 = 0 ;
5249 int alloc1 = 0 ;
5250 double val2 ;
5251 int ecode2 = 0 ;
5252 int val3 ;
5253 int ecode3 = 0 ;
5254 int res4 ;
5255 char *buf4 = 0 ;
5256 int alloc4 = 0 ;
5257 double val5 ;
5258 int ecode5 = 0 ;
5259 int val6 ;
5260 int ecode6 = 0 ;
5261 PyObject * obj0 = 0 ;
5262 PyObject * obj1 = 0 ;
5263 PyObject * obj2 = 0 ;
5264 PyObject * obj3 = 0 ;
5265 PyObject * obj4 = 0 ;
5266 PyObject * obj5 = 0 ;
5267
5268 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5269 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5270 if (!SWIG_IsOK(res1)) {
5271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5272 }
5273 arg1 = (char *)(buf1);
5274 ecode2 = SWIG_AsVal_double(obj1, &val2);
5275 if (!SWIG_IsOK(ecode2)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5277 }
5278 arg2 = (PLFLT)(val2);
5279 ecode3 = SWIG_AsVal_int(obj2, &val3);
5280 if (!SWIG_IsOK(ecode3)) {
5281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5282 }
5283 arg3 = (PLINT)(val3);
5284 res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5285 if (!SWIG_IsOK(res4)) {
5286 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5287 }
5288 arg4 = (char *)(buf4);
5289 ecode5 = SWIG_AsVal_double(obj4, &val5);
5290 if (!SWIG_IsOK(ecode5)) {
5291 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5292 }
5293 arg5 = (PLFLT)(val5);
5294 ecode6 = SWIG_AsVal_int(obj5, &val6);
5295 if (!SWIG_IsOK(ecode6)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5297 }
5298 arg6 = (PLINT)(val6);
5299 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5300 resultobj = SWIG_Py_Void();
5301 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5302 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5303 return resultobj;
5304 fail:
5305 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5306 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 char *arg1 = (char *) 0 ;
5314 char *arg2 = (char *) 0 ;
5315 PLFLT arg3 ;
5316 PLINT arg4 ;
5317 char *arg5 = (char *) 0 ;
5318 char *arg6 = (char *) 0 ;
5319 PLFLT arg7 ;
5320 PLINT arg8 ;
5321 char *arg9 = (char *) 0 ;
5322 char *arg10 = (char *) 0 ;
5323 PLFLT arg11 ;
5324 PLINT arg12 ;
5325 int res1 ;
5326 char *buf1 = 0 ;
5327 int alloc1 = 0 ;
5328 int res2 ;
5329 char *buf2 = 0 ;
5330 int alloc2 = 0 ;
5331 double val3 ;
5332 int ecode3 = 0 ;
5333 int val4 ;
5334 int ecode4 = 0 ;
5335 int res5 ;
5336 char *buf5 = 0 ;
5337 int alloc5 = 0 ;
5338 int res6 ;
5339 char *buf6 = 0 ;
5340 int alloc6 = 0 ;
5341 double val7 ;
5342 int ecode7 = 0 ;
5343 int val8 ;
5344 int ecode8 = 0 ;
5345 int res9 ;
5346 char *buf9 = 0 ;
5347 int alloc9 = 0 ;
5348 int res10 ;
5349 char *buf10 = 0 ;
5350 int alloc10 = 0 ;
5351 double val11 ;
5352 int ecode11 = 0 ;
5353 int val12 ;
5354 int ecode12 = 0 ;
5355 PyObject * obj0 = 0 ;
5356 PyObject * obj1 = 0 ;
5357 PyObject * obj2 = 0 ;
5358 PyObject * obj3 = 0 ;
5359 PyObject * obj4 = 0 ;
5360 PyObject * obj5 = 0 ;
5361 PyObject * obj6 = 0 ;
5362 PyObject * obj7 = 0 ;
5363 PyObject * obj8 = 0 ;
5364 PyObject * obj9 = 0 ;
5365 PyObject * obj10 = 0 ;
5366 PyObject * obj11 = 0 ;
5367
5368 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5369 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5370 if (!SWIG_IsOK(res1)) {
5371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5372 }
5373 arg1 = (char *)(buf1);
5374 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5375 if (!SWIG_IsOK(res2)) {
5376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5377 }
5378 arg2 = (char *)(buf2);
5379 ecode3 = SWIG_AsVal_double(obj2, &val3);
5380 if (!SWIG_IsOK(ecode3)) {
5381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5382 }
5383 arg3 = (PLFLT)(val3);
5384 ecode4 = SWIG_AsVal_int(obj3, &val4);
5385 if (!SWIG_IsOK(ecode4)) {
5386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5387 }
5388 arg4 = (PLINT)(val4);
5389 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5390 if (!SWIG_IsOK(res5)) {
5391 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5392 }
5393 arg5 = (char *)(buf5);
5394 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5395 if (!SWIG_IsOK(res6)) {
5396 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5397 }
5398 arg6 = (char *)(buf6);
5399 ecode7 = SWIG_AsVal_double(obj6, &val7);
5400 if (!SWIG_IsOK(ecode7)) {
5401 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5402 }
5403 arg7 = (PLFLT)(val7);
5404 ecode8 = SWIG_AsVal_int(obj7, &val8);
5405 if (!SWIG_IsOK(ecode8)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5407 }
5408 arg8 = (PLINT)(val8);
5409 res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5410 if (!SWIG_IsOK(res9)) {
5411 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5412 }
5413 arg9 = (char *)(buf9);
5414 res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5415 if (!SWIG_IsOK(res10)) {
5416 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5417 }
5418 arg10 = (char *)(buf10);
5419 ecode11 = SWIG_AsVal_double(obj10, &val11);
5420 if (!SWIG_IsOK(ecode11)) {
5421 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5422 }
5423 arg11 = (PLFLT)(val11);
5424 ecode12 = SWIG_AsVal_int(obj11, &val12);
5425 if (!SWIG_IsOK(ecode12)) {
5426 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5427 }
5428 arg12 = (PLINT)(val12);
5429 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);
5430 resultobj = SWIG_Py_Void();
5431 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5432 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5433 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5434 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5435 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5436 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5437 return resultobj;
5438 fail:
5439 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5440 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5441 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5442 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5443 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5444 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5445 return NULL;
5446 }
5447
5448
5449 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5450 PyObject *resultobj = 0;
5451 PLFLT arg1 ;
5452 PLFLT arg2 ;
5453 PLFLT *arg3 = (PLFLT *) 0 ;
5454 PLFLT *arg4 = (PLFLT *) 0 ;
5455 PLINT *arg5 = (PLINT *) 0 ;
5456 double val1 ;
5457 int ecode1 = 0 ;
5458 double val2 ;
5459 int ecode2 = 0 ;
5460 PLFLT temp3 ;
5461 int res3 = SWIG_TMPOBJ ;
5462 PLFLT temp4 ;
5463 int res4 = SWIG_TMPOBJ ;
5464 PLINT temp5 ;
5465 int res5 = SWIG_TMPOBJ ;
5466 PyObject * obj0 = 0 ;
5467 PyObject * obj1 = 0 ;
5468
5469 arg3 = &temp3;
5470 arg4 = &temp4;
5471 arg5 = &temp5;
5472 if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5473 ecode1 = SWIG_AsVal_double(obj0, &val1);
5474 if (!SWIG_IsOK(ecode1)) {
5475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5476 }
5477 arg1 = (PLFLT)(val1);
5478 ecode2 = SWIG_AsVal_double(obj1, &val2);
5479 if (!SWIG_IsOK(ecode2)) {
5480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5481 }
5482 arg2 = (PLFLT)(val2);
5483 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5484 resultobj = SWIG_Py_Void();
5485 if (SWIG_IsTmpObj(res3)) {
5486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5487 } else {
5488 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5490 }
5491 if (SWIG_IsTmpObj(res4)) {
5492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5493 } else {
5494 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5496 }
5497 if (SWIG_IsTmpObj(res5)) {
5498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5499 } else {
5500 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5502 }
5503 return resultobj;
5504 fail:
5505 return NULL;
5506 }
5507
5508
5509 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5510 PyObject *resultobj = 0;
5511
5512 if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5513 plclear();
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *resultobj = 0;
5523 PLINT arg1 ;
5524 int val1 ;
5525 int ecode1 = 0 ;
5526 PyObject * obj0 = 0 ;
5527
5528 if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5529 ecode1 = SWIG_AsVal_int(obj0, &val1);
5530 if (!SWIG_IsOK(ecode1)) {
5531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5532 }
5533 arg1 = (PLINT)(val1);
5534 plcol0(arg1);
5535 resultobj = SWIG_Py_Void();
5536 return resultobj;
5537 fail:
5538 return NULL;
5539 }
5540
5541
5542 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5543 PyObject *resultobj = 0;
5544 PLFLT arg1 ;
5545 double val1 ;
5546 int ecode1 = 0 ;
5547 PyObject * obj0 = 0 ;
5548
5549 if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5550 ecode1 = SWIG_AsVal_double(obj0, &val1);
5551 if (!SWIG_IsOK(ecode1)) {
5552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5553 }
5554 arg1 = (PLFLT)(val1);
5555 plcol1(arg1);
5556 resultobj = SWIG_Py_Void();
5557 return resultobj;
5558 fail:
5559 return NULL;
5560 }
5561
5562
5563 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5564 PyObject *resultobj = 0;
5565 PLFLT arg1 ;
5566 PLFLT arg2 ;
5567 PLFLT arg3 ;
5568 PLINT arg4 ;
5569 PLBOOL arg5 ;
5570 PLINT arg6 ;
5571 PLINT arg7 ;
5572 PLINT arg8 ;
5573 PLINT arg9 ;
5574 PLINT arg10 ;
5575 PLFLT arg11 ;
5576 double val1 ;
5577 int ecode1 = 0 ;
5578 double val2 ;
5579 int ecode2 = 0 ;
5580 double val3 ;
5581 int ecode3 = 0 ;
5582 int val4 ;
5583 int ecode4 = 0 ;
5584 int val5 ;
5585 int ecode5 = 0 ;
5586 int val6 ;
5587 int ecode6 = 0 ;
5588 int val7 ;
5589 int ecode7 = 0 ;
5590 int val8 ;
5591 int ecode8 = 0 ;
5592 int val9 ;
5593 int ecode9 = 0 ;
5594 int val10 ;
5595 int ecode10 = 0 ;
5596 double val11 ;
5597 int ecode11 = 0 ;
5598 PyObject * obj0 = 0 ;
5599 PyObject * obj1 = 0 ;
5600 PyObject * obj2 = 0 ;
5601 PyObject * obj3 = 0 ;
5602 PyObject * obj4 = 0 ;
5603 PyObject * obj5 = 0 ;
5604 PyObject * obj6 = 0 ;
5605 PyObject * obj7 = 0 ;
5606 PyObject * obj8 = 0 ;
5607 PyObject * obj9 = 0 ;
5608 PyObject * obj10 = 0 ;
5609
5610 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5611 ecode1 = SWIG_AsVal_double(obj0, &val1);
5612 if (!SWIG_IsOK(ecode1)) {
5613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5614 }
5615 arg1 = (PLFLT)(val1);
5616 ecode2 = SWIG_AsVal_double(obj1, &val2);
5617 if (!SWIG_IsOK(ecode2)) {
5618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5619 }
5620 arg2 = (PLFLT)(val2);
5621 ecode3 = SWIG_AsVal_double(obj2, &val3);
5622 if (!SWIG_IsOK(ecode3)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5624 }
5625 arg3 = (PLFLT)(val3);
5626 ecode4 = SWIG_AsVal_int(obj3, &val4);
5627 if (!SWIG_IsOK(ecode4)) {
5628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5629 }
5630 arg4 = (PLINT)(val4);
5631 ecode5 = SWIG_AsVal_int(obj4, &val5);
5632 if (!SWIG_IsOK(ecode5)) {
5633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5634 }
5635 arg5 = (PLBOOL)(val5);
5636 ecode6 = SWIG_AsVal_int(obj5, &val6);
5637 if (!SWIG_IsOK(ecode6)) {
5638 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5639 }
5640 arg6 = (PLINT)(val6);
5641 ecode7 = SWIG_AsVal_int(obj6, &val7);
5642 if (!SWIG_IsOK(ecode7)) {
5643 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5644 }
5645 arg7 = (PLINT)(val7);
5646 ecode8 = SWIG_AsVal_int(obj7, &val8);
5647 if (!SWIG_IsOK(ecode8)) {
5648 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5649 }
5650 arg8 = (PLINT)(val8);
5651 ecode9 = SWIG_AsVal_int(obj8, &val9);
5652 if (!SWIG_IsOK(ecode9)) {
5653 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5654 }
5655 arg9 = (PLINT)(val9);
5656 ecode10 = SWIG_AsVal_int(obj9, &val10);
5657 if (!SWIG_IsOK(ecode10)) {
5658 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5659 }
5660 arg10 = (PLINT)(val10);
5661 ecode11 = SWIG_AsVal_double(obj10, &val11);
5662 if (!SWIG_IsOK(ecode11)) {
5663 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5664 }
5665 arg11 = (PLFLT)(val11);
5666 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5667 resultobj = SWIG_Py_Void();
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675 PyObject *resultobj = 0;
5676 PLFLT **arg1 = (PLFLT **) 0 ;
5677 PLINT arg2 ;
5678 PLINT arg3 ;
5679 PLINT arg4 ;
5680 PLINT arg5 ;
5681 PLINT arg6 ;
5682 PLINT arg7 ;
5683 PLFLT *arg8 = (PLFLT *) 0 ;
5684 PLINT arg9 ;
5685 pltr_func arg10 = (pltr_func) 0 ;
5686 PLPointer arg11 = (PLPointer) 0 ;
5687 PyArrayObject *tmp1 = NULL ;
5688 int val4 ;
5689 int ecode4 = 0 ;
5690 int val5 ;
5691 int ecode5 = 0 ;
5692 int val6 ;
5693 int ecode6 = 0 ;
5694 int val7 ;
5695 int ecode7 = 0 ;
5696 PyArrayObject *tmp8 = NULL ;
5697 PyObject * obj0 = 0 ;
5698 PyObject * obj1 = 0 ;
5699 PyObject * obj2 = 0 ;
5700 PyObject * obj3 = 0 ;
5701 PyObject * obj4 = 0 ;
5702 PyObject * obj5 = 0 ;
5703 PyObject * obj6 = 0 ;
5704 PyObject * obj7 = 0 ;
5705
5706 {
5707 python_pltr = 0;
5708 arg10 = NULL;
5709 }
5710 {
5711 arg11 = NULL;
5712 }
5713 if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5714 {
5715 int i, size;
5716 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5717 if ( tmp1 == NULL )
5718 return NULL;
5719 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5720 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5721 size = arg3;
5722 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5723 for ( i = 0; i < arg2; i++ )
5724 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5725 }
5726 ecode4 = SWIG_AsVal_int(obj1, &val4);
5727 if (!SWIG_IsOK(ecode4)) {
5728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5729 }
5730 arg4 = (PLINT)(val4);
5731 ecode5 = SWIG_AsVal_int(obj2, &val5);
5732 if (!SWIG_IsOK(ecode5)) {
5733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5734 }
5735 arg5 = (PLINT)(val5);
5736 ecode6 = SWIG_AsVal_int(obj3, &val6);
5737 if (!SWIG_IsOK(ecode6)) {
5738 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5739 }
5740 arg6 = (PLINT)(val6);
5741 ecode7 = SWIG_AsVal_int(obj4, &val7);
5742 if (!SWIG_IsOK(ecode7)) {
5743 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5744 }
5745 arg7 = (PLINT)(val7);
5746 {
5747 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5748 if ( tmp8 == NULL )
5749 return NULL;
5750 arg9 = PyArray_DIMS( tmp8 )[0];
5751 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5752 }
5753 if (obj6) {
5754 {
5755 // it must be a callable or None
5756 if ( obj6 == Py_None )
5757 {
5758 arg10 = NULL;
5759 }
5760 else
5761 {
5762 if ( !PyCallable_Check( (PyObject *) obj6 ) )
5763 {
5764 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5765 return NULL;
5766 }
5767 arg10 = marshal_pltr( obj6 );
5768 }
5769 }
5770 }
5771 if (obj7) {
5772 {
5773 if ( obj7 == Py_None )
5774 arg11 = NULL;
5775 else
5776 {
5777 arg11 = marshal_PLPointer( obj7, 0 );
5778 }
5779 }
5780 }
5781 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5782 resultobj = SWIG_Py_Void();
5783 {
5784 Py_CLEAR( tmp1 );
5785 free( arg1 );
5786 }
5787 {
5788 Py_CLEAR( tmp8 );
5789 }
5790 {
5791 cleanup_pltr();
5792 }
5793 {
5794 cleanup_PLPointer();
5795 }
5796 return resultobj;
5797 fail:
5798 {
5799 Py_CLEAR( tmp1 );
5800 free( arg1 );
5801 }
5802 {
5803 Py_CLEAR( tmp8 );
5804 }
5805 {
5806 cleanup_pltr();
5807 }
5808 {
5809 cleanup_PLPointer();
5810 }
5811 return NULL;
5812 }
5813
5814
5815 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5816 PyObject *resultobj = 0;
5817 PLINT arg1 ;
5818 PLINT arg2 ;
5819 PLINT arg3 ;
5820 PLINT arg4 ;
5821 PLINT arg5 ;
5822 PLFLT arg6 ;
5823 PLFLT *arg7 = (PLFLT *) 0 ;
5824 int val1 ;
5825 int ecode1 = 0 ;
5826 int val2 ;
5827 int ecode2 = 0 ;
5828 int val3 ;
5829 int ecode3 = 0 ;
5830 int val4 ;
5831 int ecode4 = 0 ;
5832 int val5 ;
5833 int ecode5 = 0 ;
5834 double val6 ;
5835 int ecode6 = 0 ;
5836 PLFLT temp7 ;
5837 int res7 = SWIG_TMPOBJ ;
5838 PyObject * obj0 = 0 ;
5839 PyObject * obj1 = 0 ;
5840 PyObject * obj2 = 0 ;
5841 PyObject * obj3 = 0 ;
5842 PyObject * obj4 = 0 ;
5843 PyObject * obj5 = 0 ;
5844
5845 arg7 = &temp7;
5846 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5847 ecode1 = SWIG_AsVal_int(obj0, &val1);
5848 if (!SWIG_IsOK(ecode1)) {
5849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5850 }
5851 arg1 = (PLINT)(val1);
5852 ecode2 = SWIG_AsVal_int(obj1, &val2);
5853 if (!SWIG_IsOK(ecode2)) {
5854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5855 }
5856 arg2 = (PLINT)(val2);
5857 ecode3 = SWIG_AsVal_int(obj2, &val3);
5858 if (!SWIG_IsOK(ecode3)) {
5859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5860 }
5861 arg3 = (PLINT)(val3);
5862 ecode4 = SWIG_AsVal_int(obj3, &val4);
5863 if (!SWIG_IsOK(ecode4)) {
5864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5865 }
5866 arg4 = (PLINT)(val4);
5867 ecode5 = SWIG_AsVal_int(obj4, &val5);
5868 if (!SWIG_IsOK(ecode5)) {
5869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5870 }
5871 arg5 = (PLINT)(val5);
5872 ecode6 = SWIG_AsVal_double(obj5, &val6);
5873 if (!SWIG_IsOK(ecode6)) {
5874 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5875 }
5876 arg6 = (PLFLT)(val6);
5877 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5878 resultobj = SWIG_Py_Void();
5879 if (SWIG_IsTmpObj(res7)) {
5880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5881 } else {
5882 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5884 }
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5892 PyObject *resultobj = 0;
5893 PLINT arg1 ;
5894 PLBOOL arg2 ;
5895 int val1 ;
5896 int ecode1 = 0 ;
5897 int val2 ;
5898 int ecode2 = 0 ;
5899 PyObject * obj0 = 0 ;
5900 PyObject * obj1 = 0 ;
5901
5902 if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
5903 ecode1 = SWIG_AsVal_int(obj0, &val1);
5904 if (!SWIG_IsOK(ecode1)) {
5905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5906 }
5907 arg1 = (PLINT)(val1);
5908 ecode2 = SWIG_AsVal_int(obj1, &val2);
5909 if (!SWIG_IsOK(ecode2)) {
5910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5911 }
5912 arg2 = (PLBOOL)(val2);
5913 plcpstrm(arg1,arg2);
5914 resultobj = SWIG_Py_Void();
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5922 PyObject *resultobj = 0;
5923
5924 if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
5925 plend();
5926 resultobj = SWIG_Py_Void();
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5934 PyObject *resultobj = 0;
5935
5936 if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
5937 plend1();
5938 resultobj = SWIG_Py_Void();
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5946 PyObject *resultobj = 0;
5947 PLFLT arg1 ;
5948 PLFLT arg2 ;
5949 PLFLT arg3 ;
5950 PLFLT arg4 ;
5951 PLINT arg5 ;
5952 PLINT arg6 ;
5953 double val1 ;
5954 int ecode1 = 0 ;
5955 double val2 ;
5956 int ecode2 = 0 ;
5957 double val3 ;
5958 int ecode3 = 0 ;
5959 double val4 ;
5960 int ecode4 = 0 ;
5961 int val5 ;
5962 int ecode5 = 0 ;
5963 int val6 ;
5964 int ecode6 = 0 ;
5965 PyObject * obj0 = 0 ;
5966 PyObject * obj1 = 0 ;
5967 PyObject * obj2 = 0 ;
5968 PyObject * obj3 = 0 ;
5969 PyObject * obj4 = 0 ;
5970 PyObject * obj5 = 0 ;
5971
5972 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5973 ecode1 = SWIG_AsVal_double(obj0, &val1);
5974 if (!SWIG_IsOK(ecode1)) {
5975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5976 }
5977 arg1 = (PLFLT)(val1);
5978 ecode2 = SWIG_AsVal_double(obj1, &val2);
5979 if (!SWIG_IsOK(ecode2)) {
5980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5981 }
5982 arg2 = (PLFLT)(val2);
5983 ecode3 = SWIG_AsVal_double(obj2, &val3);
5984 if (!SWIG_IsOK(ecode3)) {
5985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5986 }
5987 arg3 = (PLFLT)(val3);
5988 ecode4 = SWIG_AsVal_double(obj3, &val4);
5989 if (!SWIG_IsOK(ecode4)) {
5990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5991 }
5992 arg4 = (PLFLT)(val4);
5993 ecode5 = SWIG_AsVal_int(obj4, &val5);
5994 if (!SWIG_IsOK(ecode5)) {
5995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5996 }
5997 arg5 = (PLINT)(val5);
5998 ecode6 = SWIG_AsVal_int(obj5, &val6);
5999 if (!SWIG_IsOK(ecode6)) {
6000 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6001 }
6002 arg6 = (PLINT)(val6);
6003 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6004 resultobj = SWIG_Py_Void();
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6012 PyObject *resultobj = 0;
6013 PLFLT arg1 ;
6014 PLFLT arg2 ;
6015 PLFLT arg3 ;
6016 PLFLT arg4 ;
6017 PLINT arg5 ;
6018 PLINT arg6 ;
6019 double val1 ;
6020 int ecode1 = 0 ;
6021 double val2 ;
6022 int ecode2 = 0 ;
6023 double val3 ;
6024 int ecode3 = 0 ;
6025 double val4 ;
6026 int ecode4 = 0 ;
6027 int val5 ;
6028 int ecode5 = 0 ;
6029 int val6 ;
6030 int ecode6 = 0 ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 PyObject * obj3 = 0 ;
6035 PyObject * obj4 = 0 ;
6036 PyObject * obj5 = 0 ;
6037
6038 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6039 ecode1 = SWIG_AsVal_double(obj0, &val1);
6040 if (!SWIG_IsOK(ecode1)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6042 }
6043 arg1 = (PLFLT)(val1);
6044 ecode2 = SWIG_AsVal_double(obj1, &val2);
6045 if (!SWIG_IsOK(ecode2)) {
6046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6047 }
6048 arg2 = (PLFLT)(val2);
6049 ecode3 = SWIG_AsVal_double(obj2, &val3);
6050 if (!SWIG_IsOK(ecode3)) {
6051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6052 }
6053 arg3 = (PLFLT)(val3);
6054 ecode4 = SWIG_AsVal_double(obj3, &val4);
6055 if (!SWIG_IsOK(ecode4)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6057 }
6058 arg4 = (PLFLT)(val4);
6059 ecode5 = SWIG_AsVal_int(obj4, &val5);
6060 if (!SWIG_IsOK(ecode5)) {
6061 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6062 }
6063 arg5 = (PLINT)(val5);
6064 ecode6 = SWIG_AsVal_int(obj5, &val6);
6065 if (!SWIG_IsOK(ecode6)) {
6066 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6067 }
6068 arg6 = (PLINT)(val6);
6069 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6070 resultobj = SWIG_Py_Void();
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078 PyObject *resultobj = 0;
6079
6080 if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6081 pleop();
6082 resultobj = SWIG_Py_Void();
6083 return resultobj;
6084 fail:
6085 return NULL;
6086 }
6087
6088
6089 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6090 PyObject *resultobj = 0;
6091 PLINT arg1 ;
6092 PLFLT *arg2 = (PLFLT *) 0 ;
6093 PLFLT *arg3 = (PLFLT *) 0 ;
6094 PLFLT *arg4 = (PLFLT *) 0 ;
6095 PyArrayObject *tmp1 = NULL ;
6096 PyArrayObject *tmp3 = NULL ;
6097 PyArrayObject *tmp4 = NULL ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 PyObject * obj2 = 0 ;
6101
6102 if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6103 {
6104 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6105 if ( tmp1 == NULL )
6106 return NULL;
6107 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6108 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6109 }
6110 {
6111 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6112 if ( tmp3 == NULL )
6113 return NULL;
6114 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6115 {
6116 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6117 return NULL;
6118 }
6119 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6120 }
6121 {
6122 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6123 if ( tmp4 == NULL )
6124 return NULL;
6125 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6126 {
6127 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6128 return NULL;
6129 }
6130 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6131 }
6132 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6133 resultobj = SWIG_Py_Void();
6134 {
6135 Py_CLEAR( tmp1 );
6136 }
6137 {
6138 Py_CLEAR( tmp3 );
6139 }
6140 {
6141 Py_CLEAR( tmp4 );
6142 }
6143 return resultobj;
6144 fail:
6145 {
6146 Py_CLEAR( tmp1 );
6147 }
6148 {
6149 Py_CLEAR( tmp3 );
6150 }
6151 {
6152 Py_CLEAR( tmp4 );
6153 }
6154 return NULL;
6155 }
6156
6157
6158 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159 PyObject *resultobj = 0;
6160 PLINT arg1 ;
6161 PLFLT *arg2 = (PLFLT *) 0 ;
6162 PLFLT *arg3 = (PLFLT *) 0 ;
6163 PLFLT *arg4 = (PLFLT *) 0 ;
6164 PyArrayObject *tmp1 = NULL ;
6165 PyArrayObject *tmp3 = NULL ;
6166 PyArrayObject *tmp4 = NULL ;
6167 PyObject * obj0 = 0 ;
6168 PyObject * obj1 = 0 ;
6169 PyObject * obj2 = 0 ;
6170
6171 if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6172 {
6173 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6174 if ( tmp1 == NULL )
6175 return NULL;
6176 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6177 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6178 }
6179 {
6180 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6181 if ( tmp3 == NULL )
6182 return NULL;
6183 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6184 {
6185 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6186 return NULL;
6187 }
6188 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6189 }
6190 {
6191 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6192 if ( tmp4 == NULL )
6193 return NULL;
6194 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6195 {
6196 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6197 return NULL;
6198 }
6199 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6200 }
6201 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6202 resultobj = SWIG_Py_Void();
6203 {
6204 Py_CLEAR( tmp1 );
6205 }
6206 {
6207 Py_CLEAR( tmp3 );
6208 }
6209 {
6210 Py_CLEAR( tmp4 );
6211 }
6212 return resultobj;
6213 fail:
6214 {
6215 Py_CLEAR( tmp1 );
6216 }
6217 {
6218 Py_CLEAR( tmp3 );
6219 }
6220 {
6221 Py_CLEAR( tmp4 );
6222 }
6223 return NULL;
6224 }
6225
6226
6227 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6228 PyObject *resultobj = 0;
6229
6230 if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6231 plfamadv();
6232 resultobj = SWIG_Py_Void();
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240 PyObject *resultobj = 0;
6241 PLINT arg1 ;
6242 PLFLT *arg2 = (PLFLT *) 0 ;
6243 PLFLT *arg3 = (PLFLT *) 0 ;
6244 PyArrayObject *tmp1 = NULL ;
6245 PyArrayObject *tmp3 = NULL ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6248
6249 if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6250 {
6251 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6252 if ( tmp1 == NULL )
6253 return NULL;
6254 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6255 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6256 }
6257 {
6258 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6259 if ( tmp3 == NULL )
6260 return NULL;
6261 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6262 {
6263 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6264 return NULL;
6265 }
6266 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6267 }
6268 plfill(arg1,(double const *)arg2,(double const *)arg3);
6269 resultobj = SWIG_Py_Void();
6270 {
6271 Py_CLEAR( tmp1 );
6272 }
6273 {
6274 Py_CLEAR( tmp3 );
6275 }
6276 return resultobj;
6277 fail:
6278 {
6279 Py_CLEAR( tmp1 );
6280 }
6281 {
6282 Py_CLEAR( tmp3 );
6283 }
6284 return NULL;
6285 }
6286
6287
6288 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6289 PyObject *resultobj = 0;
6290 PLINT arg1 ;
6291 PLFLT *arg2 = (PLFLT *) 0 ;
6292 PLFLT *arg3 = (PLFLT *) 0 ;
6293 PLFLT *arg4 = (PLFLT *) 0 ;
6294 PyArrayObject *tmp1 = NULL ;
6295 PyArrayObject *tmp3 = NULL ;
6296 PyArrayObject *tmp4 = NULL ;
6297 PyObject * obj0 = 0 ;
6298 PyObject * obj1 = 0 ;
6299 PyObject * obj2 = 0 ;
6300
6301 if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6302 {
6303 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6304 if ( tmp1 == NULL )
6305 return NULL;
6306 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6307 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6308 }
6309 {
6310 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6311 if ( tmp3 == NULL )
6312 return NULL;
6313 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6314 {
6315 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6316 return NULL;
6317 }
6318 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6319 }
6320 {
6321 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6322 if ( tmp4 == NULL )
6323 return NULL;
6324 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6325 {
6326 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6327 return NULL;
6328 }
6329 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6330 }
6331 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6332 resultobj = SWIG_Py_Void();
6333 {
6334 Py_CLEAR( tmp1 );
6335 }
6336 {
6337 Py_CLEAR( tmp3 );
6338 }
6339 {
6340 Py_CLEAR( tmp4 );
6341 }
6342 return resultobj;
6343 fail:
6344 {
6345 Py_CLEAR( tmp1 );
6346 }
6347 {
6348 Py_CLEAR( tmp3 );
6349 }
6350 {
6351 Py_CLEAR( tmp4 );
6352 }
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6358 PyObject *resultobj = 0;
6359 PLINT arg1 ;
6360 PLFLT *arg2 = (PLFLT *) 0 ;
6361 PLFLT *arg3 = (PLFLT *) 0 ;
6362 PLFLT arg4 ;
6363 PyArrayObject *tmp1 = NULL ;
6364 PyArrayObject *tmp3 = NULL ;
6365 double val4 ;
6366 int ecode4 = 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370
6371 if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6372 {
6373 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6374 if ( tmp1 == NULL )
6375 return NULL;
6376 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6377 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6378 }
6379 {
6380 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6381 if ( tmp3 == NULL )
6382 return NULL;
6383 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6384 {
6385 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6386 return NULL;
6387 }
6388 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6389 }
6390 ecode4 = SWIG_AsVal_double(obj2, &val4);
6391 if (!SWIG_IsOK(ecode4)) {
6392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6393 }
6394 arg4 = (PLFLT)(val4);
6395 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6396 resultobj = SWIG_Py_Void();
6397 {
6398 Py_CLEAR( tmp1 );
6399 }
6400 {
6401 Py_CLEAR( tmp3 );
6402 }
6403 return resultobj;
6404 fail:
6405 {
6406 Py_CLEAR( tmp1 );
6407 }
6408 {
6409 Py_CLEAR( tmp3 );
6410 }
6411 return NULL;
6412 }
6413
6414
6415 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6416 PyObject *resultobj = 0;
6417
6418 if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6419 plflush();
6420 resultobj = SWIG_Py_Void();
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6428 PyObject *resultobj = 0;
6429 PLINT arg1 ;
6430 int val1 ;
6431 int ecode1 = 0 ;
6432 PyObject * obj0 = 0 ;
6433
6434 if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6435 ecode1 = SWIG_AsVal_int(obj0, &val1);
6436 if (!SWIG_IsOK(ecode1)) {
6437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6438 }
6439 arg1 = (PLINT)(val1);
6440 plfont(arg1);
6441 resultobj = SWIG_Py_Void();
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6449 PyObject *resultobj = 0;
6450 PLINT arg1 ;
6451 int val1 ;
6452 int ecode1 = 0 ;
6453 PyObject * obj0 = 0 ;
6454
6455 if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6456 ecode1 = SWIG_AsVal_int(obj0, &val1);
6457 if (!SWIG_IsOK(ecode1)) {
6458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6459 }
6460 arg1 = (PLINT)(val1);
6461 plfontld(arg1);
6462 resultobj = SWIG_Py_Void();
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6470 PyObject *resultobj = 0;
6471 PLFLT *arg1 = (PLFLT *) 0 ;
6472 PLFLT *arg2 = (PLFLT *) 0 ;
6473 PLFLT temp1 ;
6474 int res1 = SWIG_TMPOBJ ;
6475 PLFLT temp2 ;
6476 int res2 = SWIG_TMPOBJ ;
6477
6478 arg1 = &temp1;
6479 arg2 = &temp2;
6480 if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6481 plgchr(arg1,arg2);
6482 resultobj = SWIG_Py_Void();
6483 if (SWIG_IsTmpObj(res1)) {
6484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6485 } else {
6486 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6488 }
6489 if (SWIG_IsTmpObj(res2)) {
6490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6491 } else {
6492 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6494 }
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6502 PyObject *resultobj = 0;
6503 PLINT arg1 ;
6504 PLINT *arg2 = (PLINT *) 0 ;
6505 PLINT *arg3 = (PLINT *) 0 ;
6506 PLINT *arg4 = (PLINT *) 0 ;
6507 int val1 ;
6508 int ecode1 = 0 ;
6509 PLINT temp2 ;
6510 int res2 = SWIG_TMPOBJ ;
6511 PLINT temp3 ;
6512 int res3 = SWIG_TMPOBJ ;
6513 PLINT temp4 ;
6514 int res4 = SWIG_TMPOBJ ;
6515 PyObject * obj0 = 0 ;
6516
6517 arg2 = &temp2;
6518 arg3 = &temp3;
6519 arg4 = &temp4;
6520 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6521 ecode1 = SWIG_AsVal_int(obj0, &val1);
6522 if (!SWIG_IsOK(ecode1)) {
6523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6524 }
6525 arg1 = (PLINT)(val1);
6526 plgcol0(arg1,arg2,arg3,arg4);
6527 resultobj = SWIG_Py_Void();
6528 if (SWIG_IsTmpObj(res2)) {
6529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6530 } else {
6531 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6533 }
6534 if (SWIG_IsTmpObj(res3)) {
6535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6536 } else {
6537 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6539 }
6540 if (SWIG_IsTmpObj(res4)) {
6541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6542 } else {
6543 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6545 }
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553 PyObject *resultobj = 0;
6554 PLINT arg1 ;
6555 PLINT *arg2 = (PLINT *) 0 ;
6556 PLINT *arg3 = (PLINT *) 0 ;
6557 PLINT *arg4 = (PLINT *) 0 ;
6558 PLFLT *arg5 = (PLFLT *) 0 ;
6559 int val1 ;
6560 int ecode1 = 0 ;
6561 PLINT temp2 ;
6562 int res2 = SWIG_TMPOBJ ;
6563 PLINT temp3 ;
6564 int res3 = SWIG_TMPOBJ ;
6565 PLINT temp4 ;
6566 int res4 = SWIG_TMPOBJ ;
6567 PLFLT temp5 ;
6568 int res5 = SWIG_TMPOBJ ;
6569 PyObject * obj0 = 0 ;
6570
6571 arg2 = &temp2;
6572 arg3 = &temp3;
6573 arg4 = &temp4;
6574 arg5 = &temp5;
6575 if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6576 ecode1 = SWIG_AsVal_int(obj0, &val1);
6577 if (!SWIG_IsOK(ecode1)) {
6578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6579 }
6580 arg1 = (PLINT)(val1);
6581 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6582 resultobj = SWIG_Py_Void();
6583 if (SWIG_IsTmpObj(res2)) {
6584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6585 } else {
6586 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6588 }
6589 if (SWIG_IsTmpObj(res3)) {
6590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6591 } else {
6592 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6594 }
6595 if (SWIG_IsTmpObj(res4)) {
6596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6597 } else {
6598 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6600 }
6601 if (SWIG_IsTmpObj(res5)) {
6602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6603 } else {
6604 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6606 }
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614 PyObject *resultobj = 0;
6615 PLINT *arg1 = (PLINT *) 0 ;
6616 PLINT *arg2 = (PLINT *) 0 ;
6617 PLINT *arg3 = (PLINT *) 0 ;
6618 PLINT temp1 ;
6619 int res1 = SWIG_TMPOBJ ;
6620 PLINT temp2 ;
6621 int res2 = SWIG_TMPOBJ ;
6622 PLINT temp3 ;
6623 int res3 = SWIG_TMPOBJ ;
6624
6625 arg1 = &temp1;
6626 arg2 = &temp2;
6627 arg3 = &temp3;
6628 if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6629 plgcolbg(arg1,arg2,arg3);
6630 resultobj = SWIG_Py_Void();
6631 if (SWIG_IsTmpObj(res1)) {
6632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6633 } else {
6634 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6636 }
6637 if (SWIG_IsTmpObj(res2)) {
6638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6639 } else {
6640 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6642 }
6643 if (SWIG_IsTmpObj(res3)) {
6644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6645 } else {
6646 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6648 }
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656 PyObject *resultobj = 0;
6657 PLINT *arg1 = (PLINT *) 0 ;
6658 PLINT *arg2 = (PLINT *) 0 ;
6659 PLINT *arg3 = (PLINT *) 0 ;
6660 PLFLT *arg4 = (PLFLT *) 0 ;
6661 PLINT temp1 ;
6662 int res1 = SWIG_TMPOBJ ;
6663 PLINT temp2 ;
6664 int res2 = SWIG_TMPOBJ ;
6665 PLINT temp3 ;
6666 int res3 = SWIG_TMPOBJ ;
6667 PLFLT temp4 ;
6668 int res4 = SWIG_TMPOBJ ;
6669
6670 arg1 = &temp1;
6671 arg2 = &temp2;
6672 arg3 = &temp3;
6673 arg4 = &temp4;
6674 if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6675 plgcolbga(arg1,arg2,arg3,arg4);
6676 resultobj = SWIG_Py_Void();
6677 if (SWIG_IsTmpObj(res1)) {
6678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6679 } else {
6680 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6682 }
6683 if (SWIG_IsTmpObj(res2)) {
6684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6685 } else {
6686 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6688 }
6689 if (SWIG_IsTmpObj(res3)) {
6690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6691 } else {
6692 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6694 }
6695 if (SWIG_IsTmpObj(res4)) {
6696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6697 } else {
6698 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6708 PyObject *resultobj = 0;
6709 PLINT *arg1 = (PLINT *) 0 ;
6710 PLINT temp1 ;
6711 int res1 = SWIG_TMPOBJ ;
6712
6713 arg1 = &temp1;
6714 if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6715 plgcompression(arg1);
6716 resultobj = SWIG_Py_Void();
6717 if (SWIG_IsTmpObj(res1)) {
6718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6719 } else {
6720 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6722 }
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 char *arg1 = (char *) 0 ;
6732 char buff1[1000] ;
6733
6734 {
6735 arg1 = buff1;
6736 }
6737 if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6738 plgdev(arg1);
6739 resultobj = SWIG_Py_Void();
6740 {
6741 PyObject *o = PyString_FromString( arg1 );
6742 resultobj = t_output_helper( resultobj, o );
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 PLFLT *arg1 = (PLFLT *) 0 ;
6753 PLFLT *arg2 = (PLFLT *) 0 ;
6754 PLFLT *arg3 = (PLFLT *) 0 ;
6755 PLFLT *arg4 = (PLFLT *) 0 ;
6756 PLFLT temp1 ;
6757 int res1 = SWIG_TMPOBJ ;
6758 PLFLT temp2 ;
6759 int res2 = SWIG_TMPOBJ ;
6760 PLFLT temp3 ;
6761 int res3 = SWIG_TMPOBJ ;
6762 PLFLT temp4 ;
6763 int res4 = SWIG_TMPOBJ ;
6764
6765 arg1 = &temp1;
6766 arg2 = &temp2;
6767 arg3 = &temp3;
6768 arg4 = &temp4;
6769 if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6770 plgdidev(arg1,arg2,arg3,arg4);
6771 resultobj = SWIG_Py_Void();
6772 if (SWIG_IsTmpObj(res1)) {
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6774 } else {
6775 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6777 }
6778 if (SWIG_IsTmpObj(res2)) {
6779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6780 } else {
6781 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6783 }
6784 if (SWIG_IsTmpObj(res3)) {
6785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6786 } else {
6787 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6789 }
6790 if (SWIG_IsTmpObj(res4)) {
6791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6792 } else {
6793 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6795 }
6796 return resultobj;
6797 fail:
6798 return NULL;
6799 }
6800
6801
6802 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6803 PyObject *resultobj = 0;
6804 PLFLT *arg1 = (PLFLT *) 0 ;
6805 PLFLT temp1 ;
6806 int res1 = SWIG_TMPOBJ ;
6807
6808 arg1 = &temp1;
6809 if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6810 plgdiori(arg1);
6811 resultobj = SWIG_Py_Void();
6812 if (SWIG_IsTmpObj(res1)) {
6813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6814 } else {
6815 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6817 }
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6825 PyObject *resultobj = 0;
6826 PLFLT *arg1 = (PLFLT *) 0 ;
6827 PLFLT *arg2 = (PLFLT *) 0 ;
6828 PLFLT *arg3 = (PLFLT *) 0 ;
6829 PLFLT *arg4 = (PLFLT *) 0 ;
6830 PLFLT temp1 ;
6831 int res1 = SWIG_TMPOBJ ;
6832 PLFLT temp2 ;
6833 int res2 = SWIG_TMPOBJ ;
6834 PLFLT temp3 ;
6835 int res3 = SWIG_TMPOBJ ;
6836 PLFLT temp4 ;
6837 int res4 = SWIG_TMPOBJ ;
6838
6839 arg1 = &temp1;
6840 arg2 = &temp2;
6841 arg3 = &temp3;
6842 arg4 = &temp4;
6843 if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6844 plgdiplt(arg1,arg2,arg3,arg4);
6845 resultobj = SWIG_Py_Void();
6846 if (SWIG_IsTmpObj(res1)) {
6847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6848 } else {
6849 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6851 }
6852 if (SWIG_IsTmpObj(res2)) {
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6854 } else {
6855 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6857 }
6858 if (SWIG_IsTmpObj(res3)) {
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6860 } else {
6861 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6863 }
6864 if (SWIG_IsTmpObj(res4)) {
6865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6866 } else {
6867 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6869 }
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 PLINT *arg1 = (PLINT *) 0 ;
6879 PLINT *arg2 = (PLINT *) 0 ;
6880 PLINT *arg3 = (PLINT *) 0 ;
6881 PLINT temp1 ;
6882 int res1 = SWIG_TMPOBJ ;
6883 PLINT temp2 ;
6884 int res2 = SWIG_TMPOBJ ;
6885 PLINT temp3 ;
6886 int res3 = SWIG_TMPOBJ ;
6887
6888 arg1 = &temp1;
6889 arg2 = &temp2;
6890 arg3 = &temp3;
6891 if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
6892 plgfam(arg1,arg2,arg3);
6893 resultobj = SWIG_Py_Void();
6894 if (SWIG_IsTmpObj(res1)) {
6895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6896 } else {
6897 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6899 }
6900 if (SWIG_IsTmpObj(res2)) {
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6902 } else {
6903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6905 }
6906 if (SWIG_IsTmpObj(res3)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919 PyObject *resultobj = 0;
6920 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6921 PLUNICODE temp1 ;
6922 int res1 = SWIG_TMPOBJ ;
6923
6924 arg1 = &temp1;
6925 if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
6926 plgfci(arg1);
6927 resultobj = SWIG_Py_Void();
6928 if (SWIG_IsTmpObj(res1)) {
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6930 } else {
6931 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6933 }
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941 PyObject *resultobj = 0;
6942 char *arg1 = (char *) 0 ;
6943 char buff1[1000] ;
6944
6945 {
6946 arg1 = buff1;
6947 }
6948 if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
6949 plgfnam(arg1);
6950 resultobj = SWIG_Py_Void();
6951 {
6952 PyObject *o = PyString_FromString( arg1 );
6953 resultobj = t_output_helper( resultobj, o );
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6962 PyObject *resultobj = 0;
6963 PLINT *arg1 = (PLINT *) 0 ;
6964 PLINT *arg2 = (PLINT *) 0 ;
6965 PLINT *arg3 = (PLINT *) 0 ;
6966 PLINT temp1 ;
6967 int res1 = SWIG_TMPOBJ ;
6968 PLINT temp2 ;
6969 int res2 = SWIG_TMPOBJ ;
6970 PLINT temp3 ;
6971 int res3 = SWIG_TMPOBJ ;
6972
6973 arg1 = &temp1;
6974 arg2 = &temp2;
6975 arg3 = &temp3;
6976 if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
6977 plgfont(arg1,arg2,arg3);
6978 resultobj = SWIG_Py_Void();
6979 if (SWIG_IsTmpObj(res1)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res2)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6990 }
6991 if (SWIG_IsTmpObj(res3)) {
6992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6993 } else {
6994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6996 }
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7004 PyObject *resultobj = 0;
7005 PLINT *arg1 = (PLINT *) 0 ;
7006 PLINT temp1 ;
7007 int res1 = SWIG_TMPOBJ ;
7008
7009 arg1 = &temp1;
7010 if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7011 plglevel(arg1);
7012 resultobj = SWIG_Py_Void();
7013 if (SWIG_IsTmpObj(res1)) {
7014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7015 } else {
7016 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7018 }
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7026 PyObject *resultobj = 0;
7027 PLFLT *arg1 = (PLFLT *) 0 ;
7028 PLFLT *arg2 = (PLFLT *) 0 ;
7029 PLINT *arg3 = (PLINT *) 0 ;
7030 PLINT *arg4 = (PLINT *) 0 ;
7031 PLINT *arg5 = (PLINT *) 0 ;
7032 PLINT *arg6 = (PLINT *) 0 ;
7033 PLFLT temp1 ;
7034 int res1 = SWIG_TMPOBJ ;
7035 PLFLT temp2 ;
7036 int res2 = SWIG_TMPOBJ ;
7037 PLINT temp3 ;
7038 int res3 = SWIG_TMPOBJ ;
7039 PLINT temp4 ;
7040 int res4 = SWIG_TMPOBJ ;
7041 PLINT temp5 ;
7042 int res5 = SWIG_TMPOBJ ;
7043 PLINT temp6 ;
7044 int res6 = SWIG_TMPOBJ ;
7045
7046 arg1 = &temp1;
7047 arg2 = &temp2;
7048 arg3 = &temp3;
7049 arg4 = &temp4;
7050 arg5 = &temp5;
7051 arg6 = &temp6;
7052 if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7053 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7054 resultobj = SWIG_Py_Void();
7055 if (SWIG_IsTmpObj(res1)) {
7056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7057 } else {
7058 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7060 }
7061 if (SWIG_IsTmpObj(res2)) {
7062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7063 } else {
7064 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7066 }
7067 if (SWIG_IsTmpObj(res3)) {
7068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7069 } else {
7070 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7072 }
7073 if (SWIG_IsTmpObj(res4)) {
7074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7075 } else {
7076 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7078 }
7079 if (SWIG_IsTmpObj(res5)) {
7080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7081 } else {
7082 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7084 }
7085 if (SWIG_IsTmpObj(res6)) {
7086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7087 } else {
7088 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7090 }
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099
7100 if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7101 plgra();
7102 resultobj = SWIG_Py_Void();
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7110 PyObject *resultobj = 0;
7111 PLFLT *arg1 = (PLFLT *) 0 ;
7112 PLFLT *arg2 = (PLFLT *) 0 ;
7113 PLFLT *arg3 = (PLFLT *) 0 ;
7114 PLINT arg4 ;
7115 PLFLT *arg5 = (PLFLT *) 0 ;
7116 PLINT arg6 ;
7117 PLFLT *arg7 = (PLFLT *) 0 ;
7118 PLINT arg8 ;
7119 PLFLT **arg9 = (PLFLT **) 0 ;
7120 PLINT arg10 ;
7121 PLFLT arg11 ;
7122 PyArrayObject *tmp1 = NULL ;
7123 PyArrayObject *tmp2 = NULL ;
7124 PyArrayObject *tmp3 = NULL ;
7125 PyArrayObject *tmp5 = NULL ;
7126 PyArrayObject *tmp7 = NULL ;
7127 PyObject *array7 = NULL ;
7128 int val10 ;
7129 int ecode10 = 0 ;
7130 double val11 ;
7131 int ecode11 = 0 ;
7132 PyObject * obj0 = 0 ;
7133 PyObject * obj1 = 0 ;
7134 PyObject * obj2 = 0 ;
7135 PyObject * obj3 = 0 ;
7136 PyObject * obj4 = 0 ;
7137 PyObject * obj5 = 0 ;
7138 PyObject * obj6 = 0 ;
7139
7140 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7141 {
7142 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7143 if ( tmp1 == NULL )
7144 return NULL;
7145 Alen = PyArray_DIMS( tmp1 )[0];
7146 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7147 }
7148 {
7149 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7150 if ( tmp2 == NULL )
7151 return NULL;
7152 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7153 {
7154 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7155 return NULL;
7156 }
7157 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7158 }
7159 {
7160 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7161 if ( tmp3 == NULL )
7162 return NULL;
7163 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7164 {
7165 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7166 return NULL;
7167 }
7168 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7169 arg4 = PyArray_DIMS( tmp3 )[0];
7170 }
7171 {
7172 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7173 if ( tmp5 == NULL )
7174 return NULL;
7175 Xlen = PyArray_DIMS( tmp5 )[0];
7176 arg6 = Xlen;
7177 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7178 }
7179 {
7180 int i, size;
7181 npy_intp dims[2];
7182 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7183 if ( tmp7 == NULL )
7184 return NULL;
7185 Ylen = PyArray_DIMS( tmp7 )[0];
7186 arg8 = Ylen;
7187 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7188 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7189 // list and this ArrayY.
7190 dims[0] = Xlen;
7191 dims[1] = Ylen;
7192 array7 = PyArray_SimpleNew( 2, dims, NPY_FLOAT64 );
7193 if ( !array7 )
7194 return NULL;
7195 size = Ylen;
7196 arg9 = (double **) malloc( sizeof ( double * ) * (size_t) Xlen );
7197 for ( i = 0; i < Xlen; i++ )
7198 arg9[i] = ( (double *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7199 }
7200 ecode10 = SWIG_AsVal_int(obj5, &val10);
7201 if (!SWIG_IsOK(ecode10)) {
7202 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7203 }
7204 arg10 = (PLINT)(val10);
7205 ecode11 = SWIG_AsVal_double(obj6, &val11);
7206 if (!SWIG_IsOK(ecode11)) {
7207 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7208 }
7209 arg11 = (PLFLT)(val11);
7210 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7211 resultobj = SWIG_Py_Void();
7212 {
7213 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7214 }
7215 {
7216 Py_CLEAR( tmp1 );
7217 }
7218 {
7219 Py_CLEAR( tmp2 );
7220 }
7221 {
7222 Py_CLEAR( tmp3 );
7223 }
7224 {
7225 Py_CLEAR( tmp5 );
7226 }
7227 {
7228 Py_CLEAR( tmp7 );
7229 free( arg9 );
7230 }
7231 return resultobj;
7232 fail:
7233 {
7234 Py_CLEAR( tmp1 );
7235 }
7236 {
7237 Py_CLEAR( tmp2 );
7238 }
7239 {
7240 Py_CLEAR( tmp3 );
7241 }
7242 {
7243 Py_CLEAR( tmp5 );
7244 }
7245 {
7246 Py_CLEAR( tmp7 );
7247 free( arg9 );
7248 }
7249 return NULL;
7250 }
7251
7252
7253 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7254 PyObject *resultobj = 0;
7255 PLFLT *arg1 = (PLFLT *) 0 ;
7256 PLFLT *arg2 = (PLFLT *) 0 ;
7257 PLFLT *arg3 = (PLFLT *) 0 ;
7258 PLFLT *arg4 = (PLFLT *) 0 ;
7259 PLFLT temp1 ;
7260 int res1 = SWIG_TMPOBJ ;
7261 PLFLT temp2 ;
7262 int res2 = SWIG_TMPOBJ ;
7263 PLFLT temp3 ;
7264 int res3 = SWIG_TMPOBJ ;
7265 PLFLT temp4 ;
7266 int res4 = SWIG_TMPOBJ ;
7267
7268 arg1 = &temp1;
7269 arg2 = &temp2;
7270 arg3 = &temp3;
7271 arg4 = &temp4;
7272 if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7273 plgspa(arg1,arg2,arg3,arg4);
7274 resultobj = SWIG_Py_Void();
7275 if (SWIG_IsTmpObj(res1)) {
7276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7277 } else {
7278 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7280 }
7281 if (SWIG_IsTmpObj(res2)) {
7282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7283 } else {
7284 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7286 }
7287 if (SWIG_IsTmpObj(res3)) {
7288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7289 } else {
7290 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7292 }
7293 if (SWIG_IsTmpObj(res4)) {
7294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7295 } else {
7296 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7298 }
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7306 PyObject *resultobj = 0;
7307 PLINT *arg1 = (PLINT *) 0 ;
7308 PLINT temp1 ;
7309 int res1 = SWIG_TMPOBJ ;
7310
7311 arg1 = &temp1;
7312 if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7313 plgstrm(arg1);
7314 resultobj = SWIG_Py_Void();
7315 if (SWIG_IsTmpObj(res1)) {
7316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7317 } else {
7318 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7320 }
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7328 PyObject *resultobj = 0;
7329 char *arg1 = (char *) 0 ;
7330 char buff1[1000] ;
7331
7332 {
7333 arg1 = buff1;
7334 }
7335 if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7336 plgver(arg1);
7337 resultobj = SWIG_Py_Void();
7338 {
7339 PyObject *o = PyString_FromString( arg1 );
7340 resultobj = t_output_helper( resultobj, o );
7341 }
7342 return resultobj;
7343 fail:
7344 return NULL;
7345 }
7346
7347
7348 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7349 PyObject *resultobj = 0;
7350 PLFLT *arg1 = (PLFLT *) 0 ;
7351 PLFLT *arg2 = (PLFLT *) 0 ;
7352 PLFLT *arg3 = (PLFLT *) 0 ;
7353 PLFLT *arg4 = (PLFLT *) 0 ;
7354 PLFLT temp1 ;
7355 int res1 = SWIG_TMPOBJ ;
7356 PLFLT temp2 ;
7357 int res2 = SWIG_TMPOBJ ;
7358 PLFLT temp3 ;
7359 int res3 = SWIG_TMPOBJ ;
7360 PLFLT temp4 ;
7361 int res4 = SWIG_TMPOBJ ;
7362
7363 arg1 = &temp1;
7364 arg2 = &temp2;
7365 arg3 = &temp3;
7366 arg4 = &temp4;
7367 if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7368 plgvpd(arg1,arg2,arg3,arg4);
7369 resultobj = SWIG_Py_Void();
7370 if (SWIG_IsTmpObj(res1)) {
7371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7372 } else {
7373 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7375 }
7376 if (SWIG_IsTmpObj(res2)) {
7377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7378 } else {
7379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7381 }
7382 if (SWIG_IsTmpObj(res3)) {
7383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7384 } else {
7385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7387 }
7388 if (SWIG_IsTmpObj(res4)) {
7389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7390 } else {
7391 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401 PyObject *resultobj = 0;
7402 PLFLT *arg1 = (PLFLT *) 0 ;
7403 PLFLT *arg2 = (PLFLT *) 0 ;
7404 PLFLT *arg3 = (PLFLT *) 0 ;
7405 PLFLT *arg4 = (PLFLT *) 0 ;
7406 PLFLT temp1 ;
7407 int res1 = SWIG_TMPOBJ ;
7408 PLFLT temp2 ;
7409 int res2 = SWIG_TMPOBJ ;
7410 PLFLT temp3 ;
7411 int res3 = SWIG_TMPOBJ ;
7412 PLFLT temp4 ;
7413 int res4 = SWIG_TMPOBJ ;
7414
7415 arg1 = &temp1;
7416 arg2 = &temp2;
7417 arg3 = &temp3;
7418 arg4 = &temp4;
7419 if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7420 plgvpw(arg1,arg2,arg3,arg4);
7421 resultobj = SWIG_Py_Void();
7422 if (SWIG_IsTmpObj(res1)) {
7423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7424 } else {
7425 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7427 }
7428 if (SWIG_IsTmpObj(res2)) {
7429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7430 } else {
7431 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7433 }
7434 if (SWIG_IsTmpObj(res3)) {
7435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7436 } else {
7437 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7439 }
7440 if (SWIG_IsTmpObj(res4)) {
7441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7442 } else {
7443 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7453 PyObject *resultobj = 0;
7454 PLINT *arg1 = (PLINT *) 0 ;
7455 PLINT *arg2 = (PLINT *) 0 ;
7456 PLINT temp1 ;
7457 int res1 = SWIG_TMPOBJ ;
7458 PLINT temp2 ;
7459 int res2 = SWIG_TMPOBJ ;
7460
7461 arg1 = &temp1;
7462 arg2 = &temp2;
7463 if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7464 plgxax(arg1,arg2);
7465 resultobj = SWIG_Py_Void();
7466 if (SWIG_IsTmpObj(res1)) {
7467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7468 } else {
7469 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7471 }
7472 if (SWIG_IsTmpObj(res2)) {
7473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7474 } else {
7475 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7477 }
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7485 PyObject *resultobj = 0;
7486 PLINT *arg1 = (PLINT *) 0 ;
7487 PLINT *arg2 = (PLINT *) 0 ;
7488 PLINT temp1 ;
7489 int res1 = SWIG_TMPOBJ ;
7490 PLINT temp2 ;
7491 int res2 = SWIG_TMPOBJ ;
7492
7493 arg1 = &temp1;
7494 arg2 = &temp2;
7495 if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7496 plgyax(arg1,arg2);
7497 resultobj = SWIG_Py_Void();
7498 if (SWIG_IsTmpObj(res1)) {
7499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7500 } else {
7501 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7503 }
7504 if (SWIG_IsTmpObj(res2)) {
7505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7506 } else {
7507 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7509 }
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *resultobj = 0;
7518 PLINT *arg1 = (PLINT *) 0 ;
7519 PLINT *arg2 = (PLINT *) 0 ;
7520 PLINT temp1 ;
7521 int res1 = SWIG_TMPOBJ ;
7522 PLINT temp2 ;
7523 int res2 = SWIG_TMPOBJ ;
7524
7525 arg1 = &temp1;
7526 arg2 = &temp2;
7527 if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7528 plgzax(arg1,arg2);
7529 resultobj = SWIG_Py_Void();
7530 if (SWIG_IsTmpObj(res1)) {
7531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7532 } else {
7533 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7535 }
7536 if (SWIG_IsTmpObj(res2)) {
7537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7538 } else {
7539 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7541 }
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7549 PyObject *resultobj = 0;
7550 PLINT arg1 ;
7551 PLFLT *arg2 = (PLFLT *) 0 ;
7552 PLFLT arg3 ;
7553 PLFLT arg4 ;
7554 PLINT arg5 ;
7555 PLINT arg6 ;
7556 PyArrayObject *tmp1 = NULL ;
7557 double val3 ;
7558 int ecode3 = 0 ;
7559 double val4 ;
7560 int ecode4 = 0 ;
7561 int val5 ;
7562 int ecode5 = 0 ;
7563 int val6 ;
7564 int ecode6 = 0 ;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 PyObject * obj2 = 0 ;
7568 PyObject * obj3 = 0 ;
7569 PyObject * obj4 = 0 ;
7570
7571 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7572 {
7573 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7574 if ( tmp1 == NULL )
7575 return NULL;
7576 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7577 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7578 }
7579 ecode3 = SWIG_AsVal_double(obj1, &val3);
7580 if (!SWIG_IsOK(ecode3)) {
7581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7582 }
7583 arg3 = (PLFLT)(val3);
7584 ecode4 = SWIG_AsVal_double(obj2, &val4);
7585 if (!SWIG_IsOK(ecode4)) {
7586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7587 }
7588 arg4 = (PLFLT)(val4);
7589 ecode5 = SWIG_AsVal_int(obj3, &val5);
7590 if (!SWIG_IsOK(ecode5)) {
7591 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7592 }
7593 arg5 = (PLINT)(val5);
7594 ecode6 = SWIG_AsVal_int(obj4, &val6);
7595 if (!SWIG_IsOK(ecode6)) {
7596 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7597 }
7598 arg6 = (PLINT)(val6);
7599 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7600 resultobj = SWIG_Py_Void();
7601 {
7602 Py_CLEAR( tmp1 );
7603 }
7604 return resultobj;
7605 fail:
7606 {
7607 Py_CLEAR( tmp1 );
7608 }
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7614 PyObject *resultobj = 0;
7615 PLFLT arg1 ;
7616 PLFLT arg2 ;
7617 PLFLT arg3 ;
7618 PLFLT *arg4 = (PLFLT *) 0 ;
7619 PLFLT *arg5 = (PLFLT *) 0 ;
7620 PLFLT *arg6 = (PLFLT *) 0 ;
7621 double val1 ;
7622 int ecode1 = 0 ;
7623 double val2 ;
7624 int ecode2 = 0 ;
7625 double val3 ;
7626 int ecode3 = 0 ;
7627 PLFLT temp4 ;
7628 int res4 = SWIG_TMPOBJ ;
7629 PLFLT temp5 ;
7630 int res5 = SWIG_TMPOBJ ;
7631 PLFLT temp6 ;
7632 int res6 = SWIG_TMPOBJ ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 PyObject * obj2 = 0 ;
7636
7637 arg4 = &temp4;
7638 arg5 = &temp5;
7639 arg6 = &temp6;
7640 if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7641 ecode1 = SWIG_AsVal_double(obj0, &val1);
7642 if (!SWIG_IsOK(ecode1)) {
7643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7644 }
7645 arg1 = (PLFLT)(val1);
7646 ecode2 = SWIG_AsVal_double(obj1, &val2);
7647 if (!SWIG_IsOK(ecode2)) {
7648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7649 }
7650 arg2 = (PLFLT)(val2);
7651 ecode3 = SWIG_AsVal_double(obj2, &val3);
7652 if (!SWIG_IsOK(ecode3)) {
7653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7654 }
7655 arg3 = (PLFLT)(val3);
7656 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7657 resultobj = SWIG_Py_Void();
7658 if (SWIG_IsTmpObj(res4)) {
7659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7660 } else {
7661 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7663 }
7664 if (SWIG_IsTmpObj(res5)) {
7665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7666 } else {
7667 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7669 }
7670 if (SWIG_IsTmpObj(res6)) {
7671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7672 } else {
7673 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7675 }
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683 PyObject *resultobj = 0;
7684
7685 if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7686 plinit();
7687 resultobj = SWIG_Py_Void();
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7695 PyObject *resultobj = 0;
7696 PLFLT arg1 ;
7697 PLFLT arg2 ;
7698 PLFLT arg3 ;
7699 PLFLT arg4 ;
7700 double val1 ;
7701 int ecode1 = 0 ;
7702 double val2 ;
7703 int ecode2 = 0 ;
7704 double val3 ;
7705 int ecode3 = 0 ;
7706 double val4 ;
7707 int ecode4 = 0 ;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 PyObject * obj2 = 0 ;
7711 PyObject * obj3 = 0 ;
7712
7713 if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7714 ecode1 = SWIG_AsVal_double(obj0, &val1);
7715 if (!SWIG_IsOK(ecode1)) {
7716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7717 }
7718 arg1 = (PLFLT)(val1);
7719 ecode2 = SWIG_AsVal_double(obj1, &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7722 }
7723 arg2 = (PLFLT)(val2);
7724 ecode3 = SWIG_AsVal_double(obj2, &val3);
7725 if (!SWIG_IsOK(ecode3)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7727 }
7728 arg3 = (PLFLT)(val3);
7729 ecode4 = SWIG_AsVal_double(obj3, &val4);
7730 if (!SWIG_IsOK(ecode4)) {
7731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7732 }
7733 arg4 = (PLFLT)(val4);
7734 pljoin(arg1,arg2,arg3,arg4);
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7743 PyObject *resultobj = 0;
7744 char *arg1 = (char *) 0 ;
7745 char *arg2 = (char *) 0 ;
7746 char *arg3 = (char *) 0 ;
7747 int res1 ;
7748 char *buf1 = 0 ;
7749 int alloc1 = 0 ;
7750 int res2 ;
7751 char *buf2 = 0 ;
7752 int alloc2 = 0 ;
7753 int res3 ;
7754 char *buf3 = 0 ;
7755 int alloc3 = 0 ;
7756 PyObject * obj0 = 0 ;
7757 PyObject * obj1 = 0 ;
7758 PyObject * obj2 = 0 ;
7759
7760 if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7761 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7764 }
7765 arg1 = (char *)(buf1);
7766 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7767 if (!SWIG_IsOK(res2)) {
7768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7769 }
7770 arg2 = (char *)(buf2);
7771 res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7772 if (!SWIG_IsOK(res3)) {
7773 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7774 }
7775 arg3 = (char *)(buf3);
7776 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7777 resultobj = SWIG_Py_Void();
7778 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7779 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7780 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7781 return resultobj;
7782 fail:
7783 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7784 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7785 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7786 return NULL;
7787 }
7788
7789
7790 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7791 PyObject *resultobj = 0;
7792 PLFLT *arg1 = (PLFLT *) 0 ;
7793 PLFLT *arg2 = (PLFLT *) 0 ;
7794 PLINT arg3 ;
7795 PLINT arg4 ;
7796 PLFLT arg5 ;
7797 PLFLT arg6 ;
7798 PLFLT arg7 ;
7799 PLINT arg8 ;
7800 PLINT arg9 ;
7801 PLINT arg10 ;
7802 PLINT arg11 ;
7803 PLINT arg12 ;
7804 PLINT arg13 ;
7805 PLINT *arg14 = (PLINT *) 0 ;
7806 PLFLT arg15 ;
7807 PLFLT arg16 ;
7808 PLFLT arg17 ;
7809 PLFLT arg18 ;
7810 PLINT *arg19 = (PLINT *) 0 ;
7811 char **arg20 = (char **) 0 ;
7812 PLINT *arg21 = (PLINT *) 0 ;
7813 PLINT *arg22 = (PLINT *) 0 ;
7814 PLFLT *arg23 = (PLFLT *) 0 ;
7815 PLFLT *arg24 = (PLFLT *) 0 ;
7816 PLINT *arg25 = (PLINT *) 0 ;
7817 PLINT *arg26 = (PLINT *) 0 ;
7818 PLFLT *arg27 = (PLFLT *) 0 ;
7819 PLINT *arg28 = (PLINT *) 0 ;
7820 PLFLT *arg29 = (PLFLT *) 0 ;
7821 PLINT *arg30 = (PLINT *) 0 ;
7822 char **arg31 = (char **) 0 ;
7823 PLFLT temp1 ;
7824 int res1 = SWIG_TMPOBJ ;
7825 PLFLT temp2 ;
7826 int res2 = SWIG_TMPOBJ ;
7827 int val3 ;
7828 int ecode3 = 0 ;
7829 int val4 ;
7830 int ecode4 = 0 ;
7831 double val5 ;
7832 int ecode5 = 0 ;
7833 double val6 ;
7834 int ecode6 = 0 ;
7835 double val7 ;
7836 int ecode7 = 0 ;
7837 int val8 ;
7838 int ecode8 = 0 ;
7839 int val9 ;
7840 int ecode9 = 0 ;
7841 int val10 ;
7842 int ecode10 = 0 ;
7843 int val11 ;
7844 int ecode11 = 0 ;
7845 int val12 ;
7846 int ecode12 = 0 ;
7847 PyArrayObject *tmp13 = NULL ;
7848 double val15 ;
7849 int ecode15 = 0 ;
7850 double val16 ;
7851 int ecode16 = 0 ;
7852 double val17 ;
7853 int ecode17 = 0 ;
7854 double val18 ;
7855 int ecode18 = 0 ;
7856 PyArrayObject *tmp19 = NULL ;
7857 PyArrayObject *tmp20 = NULL ;
7858 PyArrayObject *tmp21 = NULL ;
7859 PyArrayObject *tmp22 = NULL ;
7860 PyArrayObject *tmp23 = NULL ;
7861 PyArrayObject *tmp24 = NULL ;
7862 PyArrayObject *tmp25 = NULL ;
7863 PyArrayObject *tmp26 = NULL ;
7864 PyArrayObject *tmp27 = NULL ;
7865 PyArrayObject *tmp28 = NULL ;
7866 PyArrayObject *tmp29 = NULL ;
7867 PyArrayObject *tmp30 = NULL ;
7868 PyArrayObject *tmp31 = NULL ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 PyObject * obj2 = 0 ;
7872 PyObject * obj3 = 0 ;
7873 PyObject * obj4 = 0 ;
7874 PyObject * obj5 = 0 ;
7875 PyObject * obj6 = 0 ;
7876 PyObject * obj7 = 0 ;
7877 PyObject * obj8 = 0 ;
7878 PyObject * obj9 = 0 ;
7879 PyObject * obj10 = 0 ;
7880 PyObject * obj11 = 0 ;
7881 PyObject * obj12 = 0 ;
7882 PyObject * obj13 = 0 ;
7883 PyObject * obj14 = 0 ;
7884 PyObject * obj15 = 0 ;
7885 PyObject * obj16 = 0 ;
7886 PyObject * obj17 = 0 ;
7887 PyObject * obj18 = 0 ;
7888 PyObject * obj19 = 0 ;
7889 PyObject * obj20 = 0 ;
7890 PyObject * obj21 = 0 ;
7891 PyObject * obj22 = 0 ;
7892 PyObject * obj23 = 0 ;
7893 PyObject * obj24 = 0 ;
7894 PyObject * obj25 = 0 ;
7895 PyObject * obj26 = 0 ;
7896 PyObject * obj27 = 0 ;
7897
7898 arg1 = &temp1;
7899 arg2 = &temp2;
7900 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;
7901 ecode3 = SWIG_AsVal_int(obj0, &val3);
7902 if (!SWIG_IsOK(ecode3)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7904 }
7905 arg3 = (PLINT)(val3);
7906 ecode4 = SWIG_AsVal_int(obj1, &val4);
7907 if (!SWIG_IsOK(ecode4)) {
7908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7909 }
7910 arg4 = (PLINT)(val4);
7911 ecode5 = SWIG_AsVal_double(obj2, &val5);
7912 if (!SWIG_IsOK(ecode5)) {
7913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7914 }
7915 arg5 = (PLFLT)(val5);
7916 ecode6 = SWIG_AsVal_double(obj3, &val6);
7917 if (!SWIG_IsOK(ecode6)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7919 }
7920 arg6 = (PLFLT)(val6);
7921 ecode7 = SWIG_AsVal_double(obj4, &val7);
7922 if (!SWIG_IsOK(ecode7)) {
7923 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7924 }
7925 arg7 = (PLFLT)(val7);
7926 ecode8 = SWIG_AsVal_int(obj5, &val8);
7927 if (!SWIG_IsOK(ecode8)) {
7928 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7929 }
7930 arg8 = (PLINT)(val8);
7931 ecode9 = SWIG_AsVal_int(obj6, &val9);
7932 if (!SWIG_IsOK(ecode9)) {
7933 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7934 }
7935 arg9 = (PLINT)(val9);
7936 ecode10 = SWIG_AsVal_int(obj7, &val10);
7937 if (!SWIG_IsOK(ecode10)) {
7938 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7939 }
7940 arg10 = (PLINT)(val10);
7941 ecode11 = SWIG_AsVal_int(obj8, &val11);
7942 if (!SWIG_IsOK(ecode11)) {
7943 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7944 }
7945 arg11 = (PLINT)(val11);
7946 ecode12 = SWIG_AsVal_int(obj9, &val12);
7947 if (!SWIG_IsOK(ecode12)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7949 }
7950 arg12 = (PLINT)(val12);
7951 {
7952 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
7953 if ( tmp13 == NULL )
7954 return NULL;
7955 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7956 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7957 }
7958 ecode15 = SWIG_AsVal_double(obj11, &val15);
7959 if (!SWIG_IsOK(ecode15)) {
7960 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7961 }
7962 arg15 = (PLFLT)(val15);
7963 ecode16 = SWIG_AsVal_double(obj12, &val16);
7964 if (!SWIG_IsOK(ecode16)) {
7965 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7966 }
7967 arg16 = (PLFLT)(val16);
7968 ecode17 = SWIG_AsVal_double(obj13, &val17);
7969 if (!SWIG_IsOK(ecode17)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7971 }
7972 arg17 = (PLFLT)(val17);
7973 ecode18 = SWIG_AsVal_double(obj14, &val18);
7974 if (!SWIG_IsOK(ecode18)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7976 }
7977 arg18 = (PLFLT)(val18);
7978 {
7979 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
7980 if ( tmp19 == NULL )
7981 return NULL;
7982 if ( PyArray_DIMS( tmp19 )[0] != Alen )
7983 {
7984 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7985 return NULL;
7986 }
7987 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7988 }
7989 {
7990 int i;
7991 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7992 if ( tmp20 == NULL )
7993 return NULL;
7994 if ( PyArray_DIMS( tmp20 )[0] != Alen )
7995 {
7996 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7997 return NULL;
7998 }
7999 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8000 for ( i = 0; i < Alen; i++ )
8001 {
8002 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8003 if ( arg20[i] == NULL )
8004 {
8005 free( arg20 );
8006 return NULL;
8007 }
8008 }
8009 }
8010 {
8011 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8012 if ( tmp21 == NULL )
8013 return NULL;
8014 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8015 {
8016 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8017 return NULL;
8018 }
8019 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8020 }
8021 {
8022 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8023 if ( tmp22 == NULL )
8024 return NULL;
8025 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8026 {
8027 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8028 return NULL;
8029 }
8030 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8031 }
8032 {
8033 if ( obj19 != Py_None )
8034 {
8035 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8036 if ( tmp23 == NULL )
8037 return NULL;
8038 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8039 {
8040 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8041 return NULL;
8042 }
8043 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8044 }
8045 else
8046 {
8047 arg23 = NULL;
8048 }
8049 }
8050 {
8051 if ( obj20 != Py_None )
8052 {
8053 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8054 if ( tmp24 == NULL )
8055 return NULL;
8056 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8057 {
8058 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8059 return NULL;
8060 }
8061 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8062 }
8063 else
8064 {
8065 arg24 = NULL;
8066 }
8067 }
8068 {
8069 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8070 if ( tmp25 == NULL )
8071 return NULL;
8072 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8073 {
8074 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8075 return NULL;
8076 }
8077 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8078 }
8079 {
8080 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8081 if ( tmp26 == NULL )
8082 return NULL;
8083 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8084 {
8085 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8086 return NULL;
8087 }
8088 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8089 }
8090 {
8091 if ( obj23 != Py_None )
8092 {
8093 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8094 if ( tmp27 == NULL )
8095 return NULL;
8096 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8097 {
8098 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8099 return NULL;
8100 }
8101 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8102 }
8103 else
8104 {
8105 arg27 = NULL;
8106 }
8107 }
8108 {
8109 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8110 if ( tmp28 == NULL )
8111 return NULL;
8112 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8113 {
8114 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8115 return NULL;
8116 }
8117 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8118 }
8119 {
8120 if ( obj25 != Py_None )
8121 {
8122 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8123 if ( tmp29 == NULL )
8124 return NULL;
8125 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8126 {
8127 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8128 return NULL;
8129 }
8130 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8131 }
8132 else
8133 {
8134 arg29 = NULL;
8135 }
8136 }
8137 {
8138 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8139 if ( tmp30 == NULL )
8140 return NULL;
8141 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8142 {
8143 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8144 return NULL;
8145 }
8146 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8147 }
8148 {
8149 int i;
8150 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8151 if ( tmp31 == NULL )
8152 return NULL;
8153 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8154 {
8155 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8156 return NULL;
8157 }
8158 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8159 for ( i = 0; i < Alen; i++ )
8160 {
8161 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8162 if ( arg31[i] == NULL )
8163 {
8164 free( arg31 );
8165 return NULL;
8166 }
8167 }
8168 }
8169 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);
8170 resultobj = SWIG_Py_Void();
8171 if (SWIG_IsTmpObj(res1)) {
8172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8173 } else {
8174 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8176 }
8177 if (SWIG_IsTmpObj(res2)) {
8178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8179 } else {
8180 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8182 }
8183 {
8184 Py_CLEAR( tmp13 );
8185 }
8186 {
8187 Py_CLEAR( tmp19 );
8188 }
8189 {
8190 Py_CLEAR( tmp20 ); free( arg20 );
8191 }
8192 {
8193 Py_CLEAR( tmp21 );
8194 }
8195 {
8196 Py_CLEAR( tmp22 );
8197 }
8198 {
8199 Py_CLEAR( tmp23 );
8200 }
8201 {
8202 Py_CLEAR( tmp24 );
8203 }
8204 {
8205 Py_CLEAR( tmp25 );
8206 }
8207 {
8208 Py_CLEAR( tmp26 );
8209 }
8210 {
8211 Py_CLEAR( tmp27 );
8212 }
8213 {
8214 Py_CLEAR( tmp28 );
8215 }
8216 {
8217 Py_CLEAR( tmp29 );
8218 }
8219 {
8220 Py_CLEAR( tmp30 );
8221 }
8222 {
8223 Py_CLEAR( tmp31 ); free( arg31 );
8224 }
8225 return resultobj;
8226 fail:
8227 {
8228 Py_CLEAR( tmp13 );
8229 }
8230 {
8231 Py_CLEAR( tmp19 );
8232 }
8233 {
8234 Py_CLEAR( tmp20 ); free( arg20 );
8235 }
8236 {
8237 Py_CLEAR( tmp21 );
8238 }
8239 {
8240 Py_CLEAR( tmp22 );
8241 }
8242 {
8243 Py_CLEAR( tmp23 );
8244 }
8245 {
8246 Py_CLEAR( tmp24 );
8247 }
8248 {
8249 Py_CLEAR( tmp25 );
8250 }
8251 {
8252 Py_CLEAR( tmp26 );
8253 }
8254 {
8255 Py_CLEAR( tmp27 );
8256 }
8257 {
8258 Py_CLEAR( tmp28 );
8259 }
8260 {
8261 Py_CLEAR( tmp29 );
8262 }
8263 {
8264 Py_CLEAR( tmp30 );
8265 }
8266 {
8267 Py_CLEAR( tmp31 ); free( arg31 );
8268 }
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 PyObject *resultobj = 0;
8275 PLFLT *arg1 = (PLFLT *) 0 ;
8276 PLFLT *arg2 = (PLFLT *) 0 ;
8277 PLINT arg3 ;
8278 PLINT arg4 ;
8279 PLFLT arg5 ;
8280 PLFLT arg6 ;
8281 PLFLT arg7 ;
8282 PLFLT arg8 ;
8283 PLINT arg9 ;
8284 PLINT arg10 ;
8285 PLINT arg11 ;
8286 PLFLT arg12 ;
8287 PLFLT arg13 ;
8288 PLINT arg14 ;
8289 PLFLT arg15 ;
8290 PLINT arg16 ;
8291 PLINT *arg17 = (PLINT *) 0 ;
8292 char **arg18 = (char **) 0 ;
8293 PLINT arg19 ;
8294 char **arg20 = (char **) 0 ;
8295 PLFLT *arg21 = (PLFLT *) 0 ;
8296 PLINT *arg22 = (PLINT *) 0 ;
8297 PLINT *arg23 = (PLINT *) 0 ;
8298 PLFLT **arg24 = (PLFLT **) 0 ;
8299 PLFLT temp1 ;
8300 int res1 = SWIG_TMPOBJ ;
8301 PLFLT temp2 ;
8302 int res2 = SWIG_TMPOBJ ;
8303 int val3 ;
8304 int ecode3 = 0 ;
8305 int val4 ;
8306 int ecode4 = 0 ;
8307 double val5 ;
8308 int ecode5 = 0 ;
8309 double val6 ;
8310 int ecode6 = 0 ;
8311 double val7 ;
8312 int ecode7 = 0 ;
8313 double val8 ;
8314 int ecode8 = 0 ;
8315 int val9 ;
8316 int ecode9 = 0 ;
8317 int val10 ;
8318 int ecode10 = 0 ;
8319 int val11 ;
8320 int ecode11 = 0 ;
8321 double val12 ;
8322 int ecode12 = 0 ;
8323 double val13 ;
8324 int ecode13 = 0 ;
8325 int val14 ;
8326 int ecode14 = 0 ;
8327 double val15 ;
8328 int ecode15 = 0 ;
8329 PyArrayObject *tmp16 = NULL ;
8330 PyArrayObject *tmp18 = NULL ;
8331 PyArrayObject *tmp19 = NULL ;
8332 PyArrayObject *tmp21 = NULL ;
8333 PyArrayObject *tmp22 = NULL ;
8334 PyArrayObject *tmp23 = NULL ;
8335 PyArrayObject *tmp24 = NULL ;
8336 PyObject * obj0 = 0 ;
8337 PyObject * obj1 = 0 ;
8338 PyObject * obj2 = 0 ;
8339 PyObject * obj3 = 0 ;
8340 PyObject * obj4 = 0 ;
8341 PyObject * obj5 = 0 ;
8342 PyObject * obj6 = 0 ;
8343 PyObject * obj7 = 0 ;
8344 PyObject * obj8 = 0 ;
8345 PyObject * obj9 = 0 ;
8346 PyObject * obj10 = 0 ;
8347 PyObject * obj11 = 0 ;
8348 PyObject * obj12 = 0 ;
8349 PyObject * obj13 = 0 ;
8350 PyObject * obj14 = 0 ;
8351 PyObject * obj15 = 0 ;
8352 PyObject * obj16 = 0 ;
8353 PyObject * obj17 = 0 ;
8354 PyObject * obj18 = 0 ;
8355 PyObject * obj19 = 0 ;
8356
8357 arg1 = &temp1;
8358 arg2 = &temp2;
8359 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;
8360 ecode3 = SWIG_AsVal_int(obj0, &val3);
8361 if (!SWIG_IsOK(ecode3)) {
8362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8363 }
8364 arg3 = (PLINT)(val3);
8365 ecode4 = SWIG_AsVal_int(obj1, &val4);
8366 if (!SWIG_IsOK(ecode4)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8368 }
8369 arg4 = (PLINT)(val4);
8370 ecode5 = SWIG_AsVal_double(obj2, &val5);
8371 if (!SWIG_IsOK(ecode5)) {
8372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8373 }
8374 arg5 = (PLFLT)(val5);
8375 ecode6 = SWIG_AsVal_double(obj3, &val6);
8376 if (!SWIG_IsOK(ecode6)) {
8377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8378 }
8379 arg6 = (PLFLT)(val6);
8380 ecode7 = SWIG_AsVal_double(obj4, &val7);
8381 if (!SWIG_IsOK(ecode7)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8383 }
8384 arg7 = (PLFLT)(val7);
8385 ecode8 = SWIG_AsVal_double(obj5, &val8);
8386 if (!SWIG_IsOK(ecode8)) {
8387 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8388 }
8389 arg8 = (PLFLT)(val8);
8390 ecode9 = SWIG_AsVal_int(obj6, &val9);
8391 if (!SWIG_IsOK(ecode9)) {
8392 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8393 }
8394 arg9 = (PLINT)(val9);
8395 ecode10 = SWIG_AsVal_int(obj7, &val10);
8396 if (!SWIG_IsOK(ecode10)) {
8397 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8398 }
8399 arg10 = (PLINT)(val10);
8400 ecode11 = SWIG_AsVal_int(obj8, &val11);
8401 if (!SWIG_IsOK(ecode11)) {
8402 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8403 }
8404 arg11 = (PLINT)(val11);
8405 ecode12 = SWIG_AsVal_double(obj9, &val12);
8406 if (!SWIG_IsOK(ecode12)) {
8407 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8408 }
8409 arg12 = (PLFLT)(val12);
8410 ecode13 = SWIG_AsVal_double(obj10, &val13);
8411 if (!SWIG_IsOK(ecode13)) {
8412 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8413 }
8414 arg13 = (PLFLT)(val13);
8415 ecode14 = SWIG_AsVal_int(obj11, &val14);
8416 if (!SWIG_IsOK(ecode14)) {
8417 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8418 }
8419 arg14 = (PLINT)(val14);
8420 ecode15 = SWIG_AsVal_double(obj12, &val15);
8421 if (!SWIG_IsOK(ecode15)) {
8422 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8423 }
8424 arg15 = (PLFLT)(val15);
8425 {
8426 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8427 if ( tmp16 == NULL )
8428 return NULL;
8429 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8430 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8431 }
8432 {
8433 int i;
8434 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8435 if ( tmp18 == NULL )
8436 return NULL;
8437 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8438 {
8439 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8440 return NULL;
8441 }
8442 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8443 for ( i = 0; i < Alen; i++ )
8444 {
8445 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8446 if ( arg18[i] == NULL )
8447 {
8448 free( arg18 );
8449 return NULL;
8450 }
8451 }
8452 }
8453 {
8454 int i;
8455 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8456 if ( tmp19 == NULL )
8457 return NULL;
8458 Alen = PyArray_DIMS( tmp19 )[0];
8459 arg19 = Alen;
8460 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8461 for ( i = 0; i < Alen; i++ )
8462 {
8463 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8464 if ( arg20[i] == NULL )
8465 {
8466 free( arg20 );
8467 return NULL;
8468 }
8469 }
8470 }
8471 {
8472 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8473 if ( tmp21 == NULL )
8474 return NULL;
8475 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8476 {
8477 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8478 return NULL;
8479 }
8480 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8481 }
8482 {
8483 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8484 if ( tmp22 == NULL )
8485 return NULL;
8486 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8487 {
8488 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8489 return NULL;
8490 }
8491 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8492 }
8493 {
8494 int i;
8495 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8496 if ( tmp23 == NULL )
8497 return NULL;
8498 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8499 {
8500 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8501 return NULL;
8502 }
8503 Xlen = PyArray_DIMS( tmp23 )[0];
8504 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8505 Ylen = -1;
8506 for ( i = 0; i < Xlen; i++ )
8507 if ( arg23[i] > Ylen )
8508 Ylen = arg23[i];
8509 }
8510 {
8511 int i, size;
8512 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8513 if ( tmp24 == NULL )
8514 return NULL;
8515 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8516 {
8517 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8518 return NULL;
8519 }
8520 size = Ylen;
8521 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8522 for ( i = 0; i < Xlen; i++ )
8523 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8524 }
8525 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);
8526 resultobj = SWIG_Py_Void();
8527 if (SWIG_IsTmpObj(res1)) {
8528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8529 } else {
8530 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8532 }
8533 if (SWIG_IsTmpObj(res2)) {
8534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8535 } else {
8536 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8538 }
8539 {
8540 Py_CLEAR( tmp16 );
8541 }
8542 {
8543 Py_CLEAR( tmp18 ); free( arg18 );
8544 }
8545 {
8546 Py_CLEAR( tmp19 ); free( arg20 );
8547 }
8548 {
8549 Py_CLEAR( tmp21 );
8550 }
8551 {
8552 Py_CLEAR( tmp22 );
8553 }
8554 {
8555 Py_CLEAR( tmp23 );
8556 }
8557 {
8558 Py_CLEAR( tmp24 );
8559 free( arg24 );
8560 }
8561 return resultobj;
8562 fail:
8563 {
8564 Py_CLEAR( tmp16 );
8565 }
8566 {
8567 Py_CLEAR( tmp18 ); free( arg18 );
8568 }
8569 {
8570 Py_CLEAR( tmp19 ); free( arg20 );
8571 }
8572 {
8573 Py_CLEAR( tmp21 );
8574 }
8575 {
8576 Py_CLEAR( tmp22 );
8577 }
8578 {
8579 Py_CLEAR( tmp23 );
8580 }
8581 {
8582 Py_CLEAR( tmp24 );
8583 free( arg24 );
8584 }
8585 return NULL;
8586 }
8587
8588
8589 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8590 PyObject *resultobj = 0;
8591 PLFLT arg1 ;
8592 PLFLT arg2 ;
8593 PLFLT arg3 ;
8594 double val1 ;
8595 int ecode1 = 0 ;
8596 double val2 ;
8597 int ecode2 = 0 ;
8598 double val3 ;
8599 int ecode3 = 0 ;
8600 PyObject * obj0 = 0 ;
8601 PyObject * obj1 = 0 ;
8602 PyObject * obj2 = 0 ;
8603
8604 if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8605 ecode1 = SWIG_AsVal_double(obj0, &val1);
8606 if (!SWIG_IsOK(ecode1)) {
8607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8608 }
8609 arg1 = (PLFLT)(val1);
8610 ecode2 = SWIG_AsVal_double(obj1, &val2);
8611 if (!SWIG_IsOK(ecode2)) {
8612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8613 }
8614 arg2 = (PLFLT)(val2);
8615 ecode3 = SWIG_AsVal_double(obj2, &val3);
8616 if (!SWIG_IsOK(ecode3)) {
8617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8618 }
8619 arg3 = (PLFLT)(val3);
8620 pllightsource(arg1,arg2,arg3);
8621 resultobj = SWIG_Py_Void();
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8629 PyObject *resultobj = 0;
8630 PLINT arg1 ;
8631 PLFLT *arg2 = (PLFLT *) 0 ;
8632 PLFLT *arg3 = (PLFLT *) 0 ;
8633 PyArrayObject *tmp1 = NULL ;
8634 PyArrayObject *tmp3 = NULL ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637
8638 if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8639 {
8640 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8641 if ( tmp1 == NULL )
8642 return NULL;
8643 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8644 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8645 }
8646 {
8647 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8648 if ( tmp3 == NULL )
8649 return NULL;
8650 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8651 {
8652 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8653 return NULL;
8654 }
8655 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8656 }
8657 plline(arg1,(double const *)arg2,(double const *)arg3);
8658 resultobj = SWIG_Py_Void();
8659 {
8660 Py_CLEAR( tmp1 );
8661 }
8662 {
8663 Py_CLEAR( tmp3 );
8664 }
8665 return resultobj;
8666 fail:
8667 {
8668 Py_CLEAR( tmp1 );
8669 }
8670 {
8671 Py_CLEAR( tmp3 );
8672 }
8673 return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 PLINT arg1 ;
8680 PLFLT *arg2 = (PLFLT *) 0 ;
8681 PLFLT *arg3 = (PLFLT *) 0 ;
8682 PLFLT *arg4 = (PLFLT *) 0 ;
8683 PyArrayObject *tmp1 = NULL ;
8684 PyArrayObject *tmp3 = NULL ;
8685 PyArrayObject *tmp4 = NULL ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 PyObject * obj2 = 0 ;
8689
8690 if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8691 {
8692 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8693 if ( tmp1 == NULL )
8694 return NULL;
8695 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8696 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8697 }
8698 {
8699 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8700 if ( tmp3 == NULL )
8701 return NULL;
8702 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8703 {
8704 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8705 return NULL;
8706 }
8707 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8708 }
8709 {
8710 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8711 if ( tmp4 == NULL )
8712 return NULL;
8713 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8714 {
8715 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8716 return NULL;
8717 }
8718 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8719 }
8720 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8721 resultobj = SWIG_Py_Void();
8722 {
8723 Py_CLEAR( tmp1 );
8724 }
8725 {
8726 Py_CLEAR( tmp3 );
8727 }
8728 {
8729 Py_CLEAR( tmp4 );
8730 }
8731 return resultobj;
8732 fail:
8733 {
8734 Py_CLEAR( tmp1 );
8735 }
8736 {
8737 Py_CLEAR( tmp3 );
8738 }
8739 {
8740 Py_CLEAR( tmp4 );
8741 }
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747 PyObject *resultobj = 0;
8748 PLINT arg1 ;
8749 int val1 ;
8750 int ecode1 = 0 ;
8751 PyObject * obj0 = 0 ;
8752
8753 if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8754 ecode1 = SWIG_AsVal_int(obj0, &val1);
8755 if (!SWIG_IsOK(ecode1)) {
8756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8757 }
8758 arg1 = (PLINT)(val1);
8759 pllsty(arg1);
8760 resultobj = SWIG_Py_Void();
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 PLFLT *arg1 = (PLFLT *) 0 ;
8770 PLFLT *arg2 = (PLFLT *) 0 ;
8771 PLFLT **arg3 = (PLFLT **) 0 ;
8772 PLINT arg4 ;
8773 PLINT arg5 ;
8774 PLINT arg6 ;
8775 PyArrayObject *tmp1 = NULL ;
8776 PyArrayObject *tmp2 = NULL ;
8777 PyArrayObject *tmp3 = NULL ;
8778 int val6 ;
8779 int ecode6 = 0 ;
8780 PyObject * obj0 = 0 ;
8781 PyObject * obj1 = 0 ;
8782 PyObject * obj2 = 0 ;
8783 PyObject * obj3 = 0 ;
8784
8785 if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8786 {
8787 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8788 if ( tmp1 == NULL )
8789 return NULL;
8790 Xlen = PyArray_DIMS( tmp1 )[0];
8791 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8792 }
8793 {
8794 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8795 if ( tmp2 == NULL )
8796 return NULL;
8797 Ylen = PyArray_DIMS( tmp2 )[0];
8798 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8799 }
8800 {
8801 int i, size;
8802 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8803 if ( tmp3 == NULL )
8804 return NULL;
8805 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8806 {
8807 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8808 return NULL;
8809 }
8810 arg4 = PyArray_DIMS( tmp3 )[0];
8811 arg5 = PyArray_DIMS( tmp3 )[1];
8812 size = arg5;
8813 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8814 for ( i = 0; i < arg4; i++ )
8815 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8816 }
8817 ecode6 = SWIG_AsVal_int(obj3, &val6);
8818 if (!SWIG_IsOK(ecode6)) {
8819 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8820 }
8821 arg6 = (PLINT)(val6);
8822 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8823 resultobj = SWIG_Py_Void();
8824 {
8825 Py_CLEAR( tmp1 );
8826 }
8827 {
8828 Py_CLEAR( tmp2 );
8829 }
8830 {
8831 Py_CLEAR( tmp3 );
8832 free( arg3 );
8833 }
8834 return resultobj;
8835 fail:
8836 {
8837 Py_CLEAR( tmp1 );
8838 }
8839 {
8840 Py_CLEAR( tmp2 );
8841 }
8842 {
8843 Py_CLEAR( tmp3 );
8844 free( arg3 );
8845 }
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851 PyObject *resultobj = 0;
8852 PLFLT *arg1 = (PLFLT *) 0 ;
8853 PLFLT *arg2 = (PLFLT *) 0 ;
8854 PLFLT **arg3 = (PLFLT **) 0 ;
8855 PLINT arg4 ;
8856 PLINT arg5 ;
8857 PLINT arg6 ;
8858 PLFLT *arg7 = (PLFLT *) 0 ;
8859 PLINT arg8 ;
8860 PyArrayObject *tmp1 = NULL ;
8861 PyArrayObject *tmp2 = NULL ;
8862 PyArrayObject *tmp3 = NULL ;
8863 int val6 ;
8864 int ecode6 = 0 ;
8865 PyArrayObject *tmp7 = NULL ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 PyObject * obj3 = 0 ;
8870 PyObject * obj4 = 0 ;
8871
8872 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8873 {
8874 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8875 if ( tmp1 == NULL )
8876 return NULL;
8877 Xlen = PyArray_DIMS( tmp1 )[0];
8878 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8879 }
8880 {
8881 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8882 if ( tmp2 == NULL )
8883 return NULL;
8884 Ylen = PyArray_DIMS( tmp2 )[0];
8885 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8886 }
8887 {
8888 int i, size;
8889 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8890 if ( tmp3 == NULL )
8891 return NULL;
8892 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8893 {
8894 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8895 return NULL;
8896 }
8897 arg4 = PyArray_DIMS( tmp3 )[0];
8898 arg5 = PyArray_DIMS( tmp3 )[1];
8899 size = arg5;
8900 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8901 for ( i = 0; i < arg4; i++ )
8902 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8903 }
8904 ecode6 = SWIG_AsVal_int(obj3, &val6);
8905 if (!SWIG_IsOK(ecode6)) {
8906 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8907 }
8908 arg6 = (PLINT)(val6);
8909 {
8910 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
8911 if ( tmp7 == NULL )
8912 return NULL;
8913 arg8 = PyArray_DIMS( tmp7 )[0];
8914 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8915 }
8916 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8917 resultobj = SWIG_Py_Void();
8918 {
8919 Py_CLEAR( tmp1 );
8920 }
8921 {
8922 Py_CLEAR( tmp2 );
8923 }
8924 {
8925 Py_CLEAR( tmp3 );
8926 free( arg3 );
8927 }
8928 {
8929 Py_CLEAR( tmp7 );
8930 }
8931 return resultobj;
8932 fail:
8933 {
8934 Py_CLEAR( tmp1 );
8935 }
8936 {
8937 Py_CLEAR( tmp2 );
8938 }
8939 {
8940 Py_CLEAR( tmp3 );
8941 free( arg3 );
8942 }
8943 {
8944 Py_CLEAR( tmp7 );
8945 }
8946 return NULL;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 PyObject *resultobj = 0;
8952 PLINT *arg1 = (PLINT *) 0 ;
8953 PLINT temp1 ;
8954 int res1 = SWIG_TMPOBJ ;
8955
8956 arg1 = &temp1;
8957 if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
8958 plmkstrm(arg1);
8959 resultobj = SWIG_Py_Void();
8960 if (SWIG_IsTmpObj(res1)) {
8961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8962 } else {
8963 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8965 }
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8973 PyObject *resultobj = 0;
8974 char *arg1 = (char *) 0 ;
8975 PLFLT arg2 ;
8976 PLFLT arg3 ;
8977 PLFLT arg4 ;
8978 char *arg5 = (char *) 0 ;
8979 int res1 ;
8980 char *buf1 = 0 ;
8981 int alloc1 = 0 ;
8982 double val2 ;
8983 int ecode2 = 0 ;
8984 double val3 ;
8985 int ecode3 = 0 ;
8986 double val4 ;
8987 int ecode4 = 0 ;
8988 int res5 ;
8989 char *buf5 = 0 ;
8990 int alloc5 = 0 ;
8991 PyObject * obj0 = 0 ;
8992 PyObject * obj1 = 0 ;
8993 PyObject * obj2 = 0 ;
8994 PyObject * obj3 = 0 ;
8995 PyObject * obj4 = 0 ;
8996
8997 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8998 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9001 }
9002 arg1 = (char *)(buf1);
9003 ecode2 = SWIG_AsVal_double(obj1, &val2);
9004 if (!SWIG_IsOK(ecode2)) {
9005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9006 }
9007 arg2 = (PLFLT)(val2);
9008 ecode3 = SWIG_AsVal_double(obj2, &val3);
9009 if (!SWIG_IsOK(ecode3)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9011 }
9012 arg3 = (PLFLT)(val3);
9013 ecode4 = SWIG_AsVal_double(obj3, &val4);
9014 if (!SWIG_IsOK(ecode4)) {
9015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9016 }
9017 arg4 = (PLFLT)(val4);
9018 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9019 if (!SWIG_IsOK(res5)) {
9020 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9021 }
9022 arg5 = (char *)(buf5);
9023 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9024 resultobj = SWIG_Py_Void();
9025 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9026 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9027 return resultobj;
9028 fail:
9029 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9030 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9031 return NULL;
9032 }
9033
9034
9035 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036 PyObject *resultobj = 0;
9037 char *arg1 = (char *) 0 ;
9038 PLFLT arg2 ;
9039 PLFLT arg3 ;
9040 PLFLT arg4 ;
9041 char *arg5 = (char *) 0 ;
9042 int res1 ;
9043 char *buf1 = 0 ;
9044 int alloc1 = 0 ;
9045 double val2 ;
9046 int ecode2 = 0 ;
9047 double val3 ;
9048 int ecode3 = 0 ;
9049 double val4 ;
9050 int ecode4 = 0 ;
9051 int res5 ;
9052 char *buf5 = 0 ;
9053 int alloc5 = 0 ;
9054 PyObject * obj0 = 0 ;
9055 PyObject * obj1 = 0 ;
9056 PyObject * obj2 = 0 ;
9057 PyObject * obj3 = 0 ;
9058 PyObject * obj4 = 0 ;
9059
9060 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9061 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9062 if (!SWIG_IsOK(res1)) {
9063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9064 }
9065 arg1 = (char *)(buf1);
9066 ecode2 = SWIG_AsVal_double(obj1, &val2);
9067 if (!SWIG_IsOK(ecode2)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9069 }
9070 arg2 = (PLFLT)(val2);
9071 ecode3 = SWIG_AsVal_double(obj2, &val3);
9072 if (!SWIG_IsOK(ecode3)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9074 }
9075 arg3 = (PLFLT)(val3);
9076 ecode4 = SWIG_AsVal_double(obj3, &val4);
9077 if (!SWIG_IsOK(ecode4)) {
9078 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9079 }
9080 arg4 = (PLFLT)(val4);
9081 res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9082 if (!SWIG_IsOK(res5)) {
9083 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9084 }
9085 arg5 = (char *)(buf5);
9086 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9087 resultobj = SWIG_Py_Void();
9088 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9089 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9090 return resultobj;
9091 fail:
9092 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9093 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9094 return NULL;
9095 }
9096
9097
9098 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099 PyObject *resultobj = 0;
9100 PLFLT *arg1 = (PLFLT *) 0 ;
9101 PLFLT *arg2 = (PLFLT *) 0 ;
9102 PLFLT **arg3 = (PLFLT **) 0 ;
9103 PLINT arg4 ;
9104 PLINT arg5 ;
9105 PLINT arg6 ;
9106 PLBOOL arg7 ;
9107 PyArrayObject *tmp1 = NULL ;
9108 PyArrayObject *tmp2 = NULL ;
9109 PyArrayObject *tmp3 = NULL ;
9110 int val6 ;
9111 int ecode6 = 0 ;
9112 int val7 ;
9113 int ecode7 = 0 ;
9114 PyObject * obj0 = 0 ;
9115 PyObject * obj1 = 0 ;
9116 PyObject * obj2 = 0 ;
9117 PyObject * obj3 = 0 ;
9118 PyObject * obj4 = 0 ;
9119
9120 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9121 {
9122 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9123 if ( tmp1 == NULL )
9124 return NULL;
9125 Xlen = PyArray_DIMS( tmp1 )[0];
9126 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9127 }
9128 {
9129 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9130 if ( tmp2 == NULL )
9131 return NULL;
9132 Ylen = PyArray_DIMS( tmp2 )[0];
9133 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9134 }
9135 {
9136 int i, size;
9137 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9138 if ( tmp3 == NULL )
9139 return NULL;
9140 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9141 {
9142 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9143 return NULL;
9144 }
9145 arg4 = PyArray_DIMS( tmp3 )[0];
9146 arg5 = PyArray_DIMS( tmp3 )[1];
9147 size = arg5;
9148 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9149 for ( i = 0; i < arg4; i++ )
9150 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9151 }
9152 ecode6 = SWIG_AsVal_int(obj3, &val6);
9153 if (!SWIG_IsOK(ecode6)) {
9154 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9155 }
9156 arg6 = (PLINT)(val6);
9157 ecode7 = SWIG_AsVal_int(obj4, &val7);
9158 if (!SWIG_IsOK(ecode7)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9160 }
9161 arg7 = (PLBOOL)(val7);
9162 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9163 resultobj = SWIG_Py_Void();
9164 {
9165 Py_CLEAR( tmp1 );
9166 }
9167 {
9168 Py_CLEAR( tmp2 );
9169 }
9170 {
9171 Py_CLEAR( tmp3 );
9172 free( arg3 );
9173 }
9174 return resultobj;
9175 fail:
9176 {
9177 Py_CLEAR( tmp1 );
9178 }
9179 {
9180 Py_CLEAR( tmp2 );
9181 }
9182 {
9183 Py_CLEAR( tmp3 );
9184 free( arg3 );
9185 }
9186 return NULL;
9187 }
9188
9189
9190 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9191 PyObject *resultobj = 0;
9192 PLFLT *arg1 = (PLFLT *) 0 ;
9193 PLFLT *arg2 = (PLFLT *) 0 ;
9194 PLFLT **arg3 = (PLFLT **) 0 ;
9195 PLINT arg4 ;
9196 PLINT arg5 ;
9197 PLINT arg6 ;
9198 PLFLT *arg7 = (PLFLT *) 0 ;
9199 PLINT arg8 ;
9200 PyArrayObject *tmp1 = NULL ;
9201 PyArrayObject *tmp2 = NULL ;
9202 PyArrayObject *tmp3 = NULL ;
9203 int val6 ;
9204 int ecode6 = 0 ;
9205 PyArrayObject *tmp7 = NULL ;
9206 PyObject * obj0 = 0 ;
9207 PyObject * obj1 = 0 ;
9208 PyObject * obj2 = 0 ;
9209 PyObject * obj3 = 0 ;
9210 PyObject * obj4 = 0 ;
9211
9212 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9213 {
9214 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9215 if ( tmp1 == NULL )
9216 return NULL;
9217 Xlen = PyArray_DIMS( tmp1 )[0];
9218 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9219 }
9220 {
9221 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9222 if ( tmp2 == NULL )
9223 return NULL;
9224 Ylen = PyArray_DIMS( tmp2 )[0];
9225 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9226 }
9227 {
9228 int i, size;
9229 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9230 if ( tmp3 == NULL )
9231 return NULL;
9232 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9233 {
9234 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9235 return NULL;
9236 }
9237 arg4 = PyArray_DIMS( tmp3 )[0];
9238 arg5 = PyArray_DIMS( tmp3 )[1];
9239 size = arg5;
9240 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9241 for ( i = 0; i < arg4; i++ )
9242 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9243 }
9244 ecode6 = SWIG_AsVal_int(obj3, &val6);
9245 if (!SWIG_IsOK(ecode6)) {
9246 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9247 }
9248 arg6 = (PLINT)(val6);
9249 {
9250 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9251 if ( tmp7 == NULL )
9252 return NULL;
9253 arg8 = PyArray_DIMS( tmp7 )[0];
9254 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9255 }
9256 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9257 resultobj = SWIG_Py_Void();
9258 {
9259 Py_CLEAR( tmp1 );
9260 }
9261 {
9262 Py_CLEAR( tmp2 );
9263 }
9264 {
9265 Py_CLEAR( tmp3 );
9266 free( arg3 );
9267 }
9268 {
9269 Py_CLEAR( tmp7 );
9270 }
9271 return resultobj;
9272 fail:
9273 {
9274 Py_CLEAR( tmp1 );
9275 }
9276 {
9277 Py_CLEAR( tmp2 );
9278 }
9279 {
9280 Py_CLEAR( tmp3 );
9281 free( arg3 );
9282 }
9283 {
9284 Py_CLEAR( tmp7 );
9285 }
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 PLFLT *arg1 = (PLFLT *) 0 ;
9293 PLFLT *arg2 = (PLFLT *) 0 ;
9294 PLFLT **arg3 = (PLFLT **) 0 ;
9295 PLINT arg4 ;
9296 PLINT arg5 ;
9297 PLINT arg6 ;
9298 PLFLT *arg7 = (PLFLT *) 0 ;
9299 PLINT arg8 ;
9300 PLINT arg9 ;
9301 PLINT arg10 ;
9302 PLINT *arg11 = (PLINT *) 0 ;
9303 PLINT *arg12 = (PLINT *) 0 ;
9304 PyArrayObject *tmp1 = NULL ;
9305 PyArrayObject *tmp2 = NULL ;
9306 PyArrayObject *tmp3 = NULL ;
9307 int val6 ;
9308 int ecode6 = 0 ;
9309 PyArrayObject *tmp7 = NULL ;
9310 int val9 ;
9311 int ecode9 = 0 ;
9312 PyArrayObject *tmp10 = NULL ;
9313 PyArrayObject *tmp12 = NULL ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 PyObject * obj2 = 0 ;
9317 PyObject * obj3 = 0 ;
9318 PyObject * obj4 = 0 ;
9319 PyObject * obj5 = 0 ;
9320 PyObject * obj6 = 0 ;
9321 PyObject * obj7 = 0 ;
9322
9323 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9324 {
9325 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9326 if ( tmp1 == NULL )
9327 return NULL;
9328 Xlen = PyArray_DIMS( tmp1 )[0];
9329 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9330 }
9331 {
9332 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9333 if ( tmp2 == NULL )
9334 return NULL;
9335 Ylen = PyArray_DIMS( tmp2 )[0];
9336 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9337 }
9338 {
9339 int i, size;
9340 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9341 if ( tmp3 == NULL )
9342 return NULL;
9343 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9344 {
9345 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9346 return NULL;
9347 }
9348 arg4 = PyArray_DIMS( tmp3 )[0];
9349 arg5 = PyArray_DIMS( tmp3 )[1];
9350 size = arg5;
9351 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9352 for ( i = 0; i < arg4; i++ )
9353 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9354 }
9355 ecode6 = SWIG_AsVal_int(obj3, &val6);
9356 if (!SWIG_IsOK(ecode6)) {
9357 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9358 }
9359 arg6 = (PLINT)(val6);
9360 {
9361 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9362 if ( tmp7 == NULL )
9363 return NULL;
9364 arg8 = PyArray_DIMS( tmp7 )[0];
9365 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9366 }
9367 ecode9 = SWIG_AsVal_int(obj5, &val9);
9368 if (!SWIG_IsOK(ecode9)) {
9369 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9370 }
9371 arg9 = (PLINT)(val9);
9372 {
9373 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9374 if ( tmp10 == NULL )
9375 return NULL;
9376 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9377 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9378 }
9379 {
9380 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9381 if ( tmp12 == NULL )
9382 return NULL;
9383 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9384 {
9385 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9386 return NULL;
9387 }
9388 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9389 }
9390 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);
9391 resultobj = SWIG_Py_Void();
9392 {
9393 Py_CLEAR( tmp1 );
9394 }
9395 {
9396 Py_CLEAR( tmp2 );
9397 }
9398 {
9399 Py_CLEAR( tmp3 );
9400 free( arg3 );
9401 }
9402 {
9403 Py_CLEAR( tmp7 );
9404 }
9405 {
9406 Py_CLEAR( tmp10 );
9407 }
9408 {
9409 Py_CLEAR( tmp12 );
9410 }
9411 return resultobj;
9412 fail:
9413 {
9414 Py_CLEAR( tmp1 );
9415 }
9416 {
9417 Py_CLEAR( tmp2 );
9418 }
9419 {
9420 Py_CLEAR( tmp3 );
9421 free( arg3 );
9422 }
9423 {
9424 Py_CLEAR( tmp7 );
9425 }
9426 {
9427 Py_CLEAR( tmp10 );
9428 }
9429 {
9430 Py_CLEAR( tmp12 );
9431 }
9432 return NULL;
9433 }
9434
9435
9436 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9437 PyObject *resultobj = 0;
9438 PLFLT *arg1 = (PLFLT *) 0 ;
9439 PLFLT *arg2 = (PLFLT *) 0 ;
9440 PLFLT **arg3 = (PLFLT **) 0 ;
9441 PLINT arg4 ;
9442 PLINT arg5 ;
9443 PLINT arg6 ;
9444 PLFLT *arg7 = (PLFLT *) 0 ;
9445 PLINT arg8 ;
9446 PyArrayObject *tmp1 = NULL ;
9447 PyArrayObject *tmp2 = NULL ;
9448 PyArrayObject *tmp3 = NULL ;
9449 int val6 ;
9450 int ecode6 = 0 ;
9451 PyArrayObject *tmp7 = NULL ;
9452 PyObject * obj0 = 0 ;
9453 PyObject * obj1 = 0 ;
9454 PyObject * obj2 = 0 ;
9455 PyObject * obj3 = 0 ;
9456 PyObject * obj4 = 0 ;
9457
9458 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9459 {
9460 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9461 if ( tmp1 == NULL )
9462 return NULL;
9463 Xlen = PyArray_DIMS( tmp1 )[0];
9464 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9465 }
9466 {
9467 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9468 if ( tmp2 == NULL )
9469 return NULL;
9470 Ylen = PyArray_DIMS( tmp2 )[0];
9471 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9472 }
9473 {
9474 int i, size;
9475 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9476 if ( tmp3 == NULL )
9477 return NULL;
9478 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9479 {
9480 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9481 return NULL;
9482 }
9483 arg4 = PyArray_DIMS( tmp3 )[0];
9484 arg5 = PyArray_DIMS( tmp3 )[1];
9485 size = arg5;
9486 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9487 for ( i = 0; i < arg4; i++ )
9488 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9489 }
9490 ecode6 = SWIG_AsVal_int(obj3, &val6);
9491 if (!SWIG_IsOK(ecode6)) {
9492 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9493 }
9494 arg6 = (PLINT)(val6);
9495 {
9496 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9497 if ( tmp7 == NULL )
9498 return NULL;
9499 arg8 = PyArray_DIMS( tmp7 )[0];
9500 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9501 }
9502 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9503 resultobj = SWIG_Py_Void();
9504 {
9505 Py_CLEAR( tmp1 );
9506 }
9507 {
9508 Py_CLEAR( tmp2 );
9509 }
9510 {
9511 Py_CLEAR( tmp3 );
9512 free( arg3 );
9513 }
9514 {
9515 Py_CLEAR( tmp7 );
9516 }
9517 return resultobj;
9518 fail:
9519 {
9520 Py_CLEAR( tmp1 );
9521 }
9522 {
9523 Py_CLEAR( tmp2 );
9524 }
9525 {
9526 Py_CLEAR( tmp3 );
9527 free( arg3 );
9528 }
9529 {
9530 Py_CLEAR( tmp7 );
9531 }
9532 return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 PyObject *resultobj = 0;
9538 PLFLT *arg1 = (PLFLT *) 0 ;
9539 PLFLT *arg2 = (PLFLT *) 0 ;
9540 PLFLT **arg3 = (PLFLT **) 0 ;
9541 PLINT arg4 ;
9542 PLINT arg5 ;
9543 PLINT arg6 ;
9544 PLFLT *arg7 = (PLFLT *) 0 ;
9545 PLINT arg8 ;
9546 PLINT arg9 ;
9547 PLINT arg10 ;
9548 PLINT *arg11 = (PLINT *) 0 ;
9549 PLINT *arg12 = (PLINT *) 0 ;
9550 PyArrayObject *tmp1 = NULL ;
9551 PyArrayObject *tmp2 = NULL ;
9552 PyArrayObject *tmp3 = NULL ;
9553 int val6 ;
9554 int ecode6 = 0 ;
9555 PyArrayObject *tmp7 = NULL ;
9556 int val9 ;
9557 int ecode9 = 0 ;
9558 PyArrayObject *tmp10 = NULL ;
9559 PyArrayObject *tmp12 = NULL ;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 PyObject * obj2 = 0 ;
9563 PyObject * obj3 = 0 ;
9564 PyObject * obj4 = 0 ;
9565 PyObject * obj5 = 0 ;
9566 PyObject * obj6 = 0 ;
9567 PyObject * obj7 = 0 ;
9568
9569 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9570 {
9571 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9572 if ( tmp1 == NULL )
9573 return NULL;
9574 Xlen = PyArray_DIMS( tmp1 )[0];
9575 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9576 }
9577 {
9578 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9579 if ( tmp2 == NULL )
9580 return NULL;
9581 Ylen = PyArray_DIMS( tmp2 )[0];
9582 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9583 }
9584 {
9585 int i, size;
9586 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9587 if ( tmp3 == NULL )
9588 return NULL;
9589 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9590 {
9591 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9592 return NULL;
9593 }
9594 arg4 = PyArray_DIMS( tmp3 )[0];
9595 arg5 = PyArray_DIMS( tmp3 )[1];
9596 size = arg5;
9597 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9598 for ( i = 0; i < arg4; i++ )
9599 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9600 }
9601 ecode6 = SWIG_AsVal_int(obj3, &val6);
9602 if (!SWIG_IsOK(ecode6)) {
9603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9604 }
9605 arg6 = (PLINT)(val6);
9606 {
9607 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9608 if ( tmp7 == NULL )
9609 return NULL;
9610 arg8 = PyArray_DIMS( tmp7 )[0];
9611 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9612 }
9613 ecode9 = SWIG_AsVal_int(obj5, &val9);
9614 if (!SWIG_IsOK(ecode9)) {
9615 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9616 }
9617 arg9 = (PLINT)(val9);
9618 {
9619 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9620 if ( tmp10 == NULL )
9621 return NULL;
9622 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9623 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9624 }
9625 {
9626 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9627 if ( tmp12 == NULL )
9628 return NULL;
9629 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9630 {
9631 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9632 return NULL;
9633 }
9634 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9635 }
9636 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);
9637 resultobj = SWIG_Py_Void();
9638 {
9639 Py_CLEAR( tmp1 );
9640 }
9641 {
9642 Py_CLEAR( tmp2 );
9643 }
9644 {
9645 Py_CLEAR( tmp3 );
9646 free( arg3 );
9647 }
9648 {
9649 Py_CLEAR( tmp7 );
9650 }
9651 {
9652 Py_CLEAR( tmp10 );
9653 }
9654 {
9655 Py_CLEAR( tmp12 );
9656 }
9657 return resultobj;
9658 fail:
9659 {
9660 Py_CLEAR( tmp1 );
9661 }
9662 {
9663 Py_CLEAR( tmp2 );
9664 }
9665 {
9666 Py_CLEAR( tmp3 );
9667 free( arg3 );
9668 }
9669 {
9670 Py_CLEAR( tmp7 );
9671 }
9672 {
9673 Py_CLEAR( tmp10 );
9674 }
9675 {
9676 Py_CLEAR( tmp12 );
9677 }
9678 return NULL;
9679 }
9680
9681
9682 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9683 PyObject *resultobj = 0;
9684 int *arg1 = (int *) 0 ;
9685 char **arg2 = (char **) 0 ;
9686 PLINT arg3 ;
9687 int tmp1 ;
9688 int val3 ;
9689 int ecode3 = 0 ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9692 PLINT result;
9693
9694 if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9695 {
9696 int i;
9697 if ( !PyList_Check( obj0 ) )
9698 {
9699 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9700 return NULL;
9701 }
9702 tmp1 = PyList_Size( obj0 );
9703 arg1 = &tmp1;
9704 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9705 for ( i = 0; i < tmp1; i++ )
9706 {
9707 PyObject *s = PyList_GetItem( obj0, i );
9708 if ( !PyString_Check( s ) )
9709 {
9710 free( arg2 );
9711 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9712 return NULL;
9713 }
9714 arg2[i] = PyString_AsString( s );
9715 }
9716 arg2[i] = 0;
9717 }
9718 ecode3 = SWIG_AsVal_int(obj1, &val3);
9719 if (!SWIG_IsOK(ecode3)) {
9720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9721 }
9722 arg3 = (PLINT)(val3);
9723 result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
9724 resultobj = SWIG_From_int((int)(result));
9725 {
9726 if ( arg2 )
9727 free( arg2 );
9728 }
9729 return resultobj;
9730 fail:
9731 {
9732 if ( arg2 )
9733 free( arg2 );
9734 }
9735 return NULL;
9736 }
9737
9738
9739 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9740 PyObject *resultobj = 0;
9741 PLINT arg1 ;
9742 PLINT *arg2 = (PLINT *) 0 ;
9743 PLINT *arg3 = (PLINT *) 0 ;
9744 PyArrayObject *tmp1 = NULL ;
9745 PyArrayObject *tmp3 = NULL ;
9746 PyObject * obj0 = 0 ;
9747 PyObject * obj1 = 0 ;
9748
9749 if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9750 {
9751 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9752 if ( tmp1 == NULL )
9753 return NULL;
9754 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9755 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9756 }
9757 {
9758 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9759 if ( tmp3 == NULL )
9760 return NULL;
9761 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9762 {
9763 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9764 return NULL;
9765 }
9766 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9767 }
9768 plpat(arg1,(int const *)arg2,(int const *)arg3);
9769 resultobj = SWIG_Py_Void();
9770 {
9771 Py_CLEAR( tmp1 );
9772 }
9773 {
9774 Py_CLEAR( tmp3 );
9775 }
9776 return resultobj;
9777 fail:
9778 {
9779 Py_CLEAR( tmp1 );
9780 }
9781 {
9782 Py_CLEAR( tmp3 );
9783 }
9784 return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9789 PyObject *resultobj = 0;
9790 PLINT arg1 ;
9791 PLFLT arg2 ;
9792 PLFLT arg3 ;
9793 PLFLT arg4 ;
9794 PLFLT arg5 ;
9795 int val1 ;
9796 int ecode1 = 0 ;
9797 double val2 ;
9798 int ecode2 = 0 ;
9799 double val3 ;
9800 int ecode3 = 0 ;
9801 double val4 ;
9802 int ecode4 = 0 ;
9803 double val5 ;
9804 int ecode5 = 0 ;
9805 PyObject * obj0 = 0 ;
9806 PyObject * obj1 = 0 ;
9807 PyObject * obj2 = 0 ;
9808 PyObject * obj3 = 0 ;
9809 PyObject * obj4 = 0 ;
9810
9811 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9812 ecode1 = SWIG_AsVal_int(obj0, &val1);
9813 if (!SWIG_IsOK(ecode1)) {
9814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9815 }
9816 arg1 = (PLINT)(val1);
9817 ecode2 = SWIG_AsVal_double(obj1, &val2);
9818 if (!SWIG_IsOK(ecode2)) {
9819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9820 }
9821 arg2 = (PLFLT)(val2);
9822 ecode3 = SWIG_AsVal_double(obj2, &val3);
9823 if (!SWIG_IsOK(ecode3)) {
9824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9825 }
9826 arg3 = (PLFLT)(val3);
9827 ecode4 = SWIG_AsVal_double(obj3, &val4);
9828 if (!SWIG_IsOK(ecode4)) {
9829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9830 }
9831 arg4 = (PLFLT)(val4);
9832 ecode5 = SWIG_AsVal_double(obj4, &val5);
9833 if (!SWIG_IsOK(ecode5)) {
9834 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9835 }
9836 arg5 = (PLFLT)(val5);
9837 plpath(arg1,arg2,arg3,arg4,arg5);
9838 resultobj = SWIG_Py_Void();
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 PyObject *resultobj = 0;
9847 PLINT arg1 ;
9848 PLFLT *arg2 = (PLFLT *) 0 ;
9849 PLFLT *arg3 = (PLFLT *) 0 ;
9850 PLINT arg4 ;
9851 PyArrayObject *tmp1 = NULL ;
9852 PyArrayObject *tmp3 = NULL ;
9853 int val4 ;
9854 int ecode4 = 0 ;
9855 PyObject * obj0 = 0 ;
9856 PyObject * obj1 = 0 ;
9857 PyObject * obj2 = 0 ;
9858
9859 if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
9860 {
9861 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9862 if ( tmp1 == NULL )
9863 return NULL;
9864 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9865 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9866 }
9867 {
9868 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9869 if ( tmp3 == NULL )
9870 return NULL;
9871 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9872 {
9873 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9874 return NULL;
9875 }
9876 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9877 }
9878 ecode4 = SWIG_AsVal_int(obj2, &val4);
9879 if (!SWIG_IsOK(ecode4)) {
9880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9881 }
9882 arg4 = (PLINT)(val4);
9883 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9884 resultobj = SWIG_Py_Void();
9885 {
9886 Py_CLEAR( tmp1 );
9887 }
9888 {
9889 Py_CLEAR( tmp3 );
9890 }
9891 return resultobj;
9892 fail:
9893 {
9894 Py_CLEAR( tmp1 );
9895 }
9896 {
9897 Py_CLEAR( tmp3 );
9898 }
9899 return NULL;
9900 }
9901
9902
9903 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9904 PyObject *resultobj = 0;
9905 PLINT arg1 ;
9906 PLFLT *arg2 = (PLFLT *) 0 ;
9907 PLFLT *arg3 = (PLFLT *) 0 ;
9908 PLFLT *arg4 = (PLFLT *) 0 ;
9909 PLINT arg5 ;
9910 PyArrayObject *tmp1 = NULL ;
9911 PyArrayObject *tmp3 = NULL ;
9912 PyArrayObject *tmp4 = NULL ;
9913 int val5 ;
9914 int ecode5 = 0 ;
9915 PyObject * obj0 = 0 ;
9916 PyObject * obj1 = 0 ;
9917 PyObject * obj2 = 0 ;
9918 PyObject * obj3 = 0 ;
9919
9920 if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9921 {
9922 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9923 if ( tmp1 == NULL )
9924 return NULL;
9925 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9926 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9927 }
9928 {
9929 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9930 if ( tmp3 == NULL )
9931 return NULL;
9932 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9933 {
9934 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9935 return NULL;
9936 }
9937 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9938 }
9939 {
9940 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9941 if ( tmp4 == NULL )
9942 return NULL;
9943 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9944 {
9945 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9946 return NULL;
9947 }
9948 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9949 }
9950 ecode5 = SWIG_AsVal_int(obj3, &val5);
9951 if (!SWIG_IsOK(ecode5)) {
9952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9953 }
9954 arg5 = (PLINT)(val5);
9955 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9956 resultobj = SWIG_Py_Void();
9957 {
9958 Py_CLEAR( tmp1 );
9959 }
9960 {
9961 Py_CLEAR( tmp3 );
9962 }
9963 {
9964 Py_CLEAR( tmp4 );
9965 }
9966 return resultobj;
9967 fail:
9968 {
9969 Py_CLEAR( tmp1 );
9970 }
9971 {
9972 Py_CLEAR( tmp3 );
9973 }
9974 {
9975 Py_CLEAR( tmp4 );
9976 }
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9982 PyObject *resultobj = 0;
9983 PLINT arg1 ;
9984 PLFLT *arg2 = (PLFLT *) 0 ;
9985 PLFLT *arg3 = (PLFLT *) 0 ;
9986 PLFLT *arg4 = (PLFLT *) 0 ;
9987 PLBOOL *arg5 = (PLBOOL *) 0 ;
9988 PLBOOL arg6 ;
9989 PyArrayObject *tmp1 = NULL ;
9990 PyArrayObject *tmp3 = NULL ;
9991 PyArrayObject *tmp4 = NULL ;
9992 PyArrayObject *tmp5 = NULL ;
9993 int val6 ;
9994 int ecode6 = 0 ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 PyObject * obj2 = 0 ;
9998 PyObject * obj3 = 0 ;
9999 PyObject * obj4 = 0 ;
10000
10001 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10002 {
10003 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10004 if ( tmp1 == NULL )
10005 return NULL;
10006 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10007 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10008 }
10009 {
10010 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10011 if ( tmp3 == NULL )
10012 return NULL;
10013 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10014 {
10015 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10016 return NULL;
10017 }
10018 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10019 }
10020 {
10021 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10022 if ( tmp4 == NULL )
10023 return NULL;
10024 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10025 {
10026 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10027 return NULL;
10028 }
10029 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10030 }
10031 {
10032 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10033 if ( tmp5 == NULL )
10034 return NULL;
10035 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10036 {
10037 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10038 return NULL;
10039 }
10040 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10041 }
10042 ecode6 = SWIG_AsVal_int(obj4, &val6);
10043 if (!SWIG_IsOK(ecode6)) {
10044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10045 }
10046 arg6 = (PLBOOL)(val6);
10047 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10048 resultobj = SWIG_Py_Void();
10049 {
10050 Py_CLEAR( tmp1 );
10051 }
10052 {
10053 Py_CLEAR( tmp3 );
10054 }
10055 {
10056 Py_CLEAR( tmp4 );
10057 }
10058 {
10059 Py_CLEAR( tmp5 );
10060 }
10061 return resultobj;
10062 fail:
10063 {
10064 Py_CLEAR( tmp1 );
10065 }
10066 {
10067 Py_CLEAR( tmp3 );
10068 }
10069 {
10070 Py_CLEAR( tmp4 );
10071 }
10072 {
10073 Py_CLEAR( tmp5 );
10074 }
10075 return NULL;
10076 }
10077
10078
10079 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10080 PyObject *resultobj = 0;
10081 PLINT arg1 ;
10082 PLINT arg2 ;
10083 int val1 ;
10084 int ecode1 = 0 ;
10085 int val2 ;
10086 int ecode2 = 0 ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089
10090 if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10091 ecode1 = SWIG_AsVal_int(obj0, &val1);
10092 if (!SWIG_IsOK(ecode1)) {
10093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10094 }
10095 arg1 = (PLINT)(val1);
10096 ecode2 = SWIG_AsVal_int(obj1, &val2);
10097 if (!SWIG_IsOK(ecode2)) {
10098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10099 }
10100 arg2 = (PLINT)(val2);
10101 plprec(arg1,arg2);
10102 resultobj = SWIG_Py_Void();
10103 return resultobj;
10104 fail:
10105 return NULL;
10106 }
10107
10108
10109 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10110 PyObject *resultobj = 0;
10111 PLINT arg1 ;
10112 int val1 ;
10113 int ecode1 = 0 ;
10114 PyObject * obj0 = 0 ;
10115
10116 if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10117 ecode1 = SWIG_AsVal_int(obj0, &val1);
10118 if (!SWIG_IsOK(ecode1)) {
10119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10120 }
10121 arg1 = (PLINT)(val1);
10122 plpsty(arg1);
10123 resultobj = SWIG_Py_Void();
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131 PyObject *resultobj = 0;
10132 PLFLT arg1 ;
10133 PLFLT arg2 ;
10134 PLFLT arg3 ;
10135 PLFLT arg4 ;
10136 PLFLT arg5 ;
10137 char *arg6 = (char *) 0 ;
10138 double val1 ;
10139 int ecode1 = 0 ;
10140 double val2 ;
10141 int ecode2 = 0 ;
10142 double val3 ;
10143 int ecode3 = 0 ;
10144 double val4 ;
10145 int ecode4 = 0 ;
10146 double val5 ;
10147 int ecode5 = 0 ;
10148 int res6 ;
10149 char *buf6 = 0 ;
10150 int alloc6 = 0 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 PyObject * obj2 = 0 ;
10154 PyObject * obj3 = 0 ;
10155 PyObject * obj4 = 0 ;
10156 PyObject * obj5 = 0 ;
10157
10158 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10159 ecode1 = SWIG_AsVal_double(obj0, &val1);
10160 if (!SWIG_IsOK(ecode1)) {
10161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10162 }
10163 arg1 = (PLFLT)(val1);
10164 ecode2 = SWIG_AsVal_double(obj1, &val2);
10165 if (!SWIG_IsOK(ecode2)) {
10166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10167 }
10168 arg2 = (PLFLT)(val2);
10169 ecode3 = SWIG_AsVal_double(obj2, &val3);
10170 if (!SWIG_IsOK(ecode3)) {
10171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10172 }
10173 arg3 = (PLFLT)(val3);
10174 ecode4 = SWIG_AsVal_double(obj3, &val4);
10175 if (!SWIG_IsOK(ecode4)) {
10176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10177 }
10178 arg4 = (PLFLT)(val4);
10179 ecode5 = SWIG_AsVal_double(obj4, &val5);
10180 if (!SWIG_IsOK(ecode5)) {
10181 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10182 }
10183 arg5 = (PLFLT)(val5);
10184 res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10185 if (!SWIG_IsOK(res6)) {
10186 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10187 }
10188 arg6 = (char *)(buf6);
10189 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10190 resultobj = SWIG_Py_Void();
10191 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10192 return resultobj;
10193 fail:
10194 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10195 return NULL;
10196 }
10197
10198
10199 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200 PyObject *resultobj = 0;
10201 PLFLT arg1 ;
10202 PLFLT arg2 ;
10203 PLFLT arg3 ;
10204 PLFLT arg4 ;
10205 PLFLT arg5 ;
10206 PLFLT arg6 ;
10207 PLFLT arg7 ;
10208 PLFLT arg8 ;
10209 PLFLT arg9 ;
10210 PLFLT arg10 ;
10211 char *arg11 = (char *) 0 ;
10212 double val1 ;
10213 int ecode1 = 0 ;
10214 double val2 ;
10215 int ecode2 = 0 ;
10216 double val3 ;
10217 int ecode3 = 0 ;
10218 double val4 ;
10219 int ecode4 = 0 ;
10220 double val5 ;
10221 int ecode5 = 0 ;
10222 double val6 ;
10223 int ecode6 = 0 ;
10224 double val7 ;
10225 int ecode7 = 0 ;
10226 double val8 ;
10227 int ecode8 = 0 ;
10228 double val9 ;
10229 int ecode9 = 0 ;
10230 double val10 ;
10231 int ecode10 = 0 ;
10232 int res11 ;
10233 char *buf11 = 0 ;
10234 int alloc11 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 PyObject * obj2 = 0 ;
10238 PyObject * obj3 = 0 ;
10239 PyObject * obj4 = 0 ;
10240 PyObject * obj5 = 0 ;
10241 PyObject * obj6 = 0 ;
10242 PyObject * obj7 = 0 ;
10243 PyObject * obj8 = 0 ;
10244 PyObject * obj9 = 0 ;
10245 PyObject * obj10 = 0 ;
10246
10247 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10248 ecode1 = SWIG_AsVal_double(obj0, &val1);
10249 if (!SWIG_IsOK(ecode1)) {
10250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10251 }
10252 arg1 = (PLFLT)(val1);
10253 ecode2 = SWIG_AsVal_double(obj1, &val2);
10254 if (!SWIG_IsOK(ecode2)) {
10255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10256 }
10257 arg2 = (PLFLT)(val2);
10258 ecode3 = SWIG_AsVal_double(obj2, &val3);
10259 if (!SWIG_IsOK(ecode3)) {
10260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10261 }
10262 arg3 = (PLFLT)(val3);
10263 ecode4 = SWIG_AsVal_double(obj3, &val4);
10264 if (!SWIG_IsOK(ecode4)) {
10265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10266 }
10267 arg4 = (PLFLT)(val4);
10268 ecode5 = SWIG_AsVal_double(obj4, &val5);
10269 if (!SWIG_IsOK(ecode5)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10271 }
10272 arg5 = (PLFLT)(val5);
10273 ecode6 = SWIG_AsVal_double(obj5, &val6);
10274 if (!SWIG_IsOK(ecode6)) {
10275 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10276 }
10277 arg6 = (PLFLT)(val6);
10278 ecode7 = SWIG_AsVal_double(obj6, &val7);
10279 if (!SWIG_IsOK(ecode7)) {
10280 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10281 }
10282 arg7 = (PLFLT)(val7);
10283 ecode8 = SWIG_AsVal_double(obj7, &val8);
10284 if (!SWIG_IsOK(ecode8)) {
10285 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10286 }
10287 arg8 = (PLFLT)(val8);
10288 ecode9 = SWIG_AsVal_double(obj8, &val9);
10289 if (!SWIG_IsOK(ecode9)) {
10290 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10291 }
10292 arg9 = (PLFLT)(val9);
10293 ecode10 = SWIG_AsVal_double(obj9, &val10);
10294 if (!SWIG_IsOK(ecode10)) {
10295 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10296 }
10297 arg10 = (PLFLT)(val10);
10298 res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10299 if (!SWIG_IsOK(res11)) {
10300 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10301 }
10302 arg11 = (char *)(buf11);
10303 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10304 resultobj = SWIG_Py_Void();
10305 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10306 return resultobj;
10307 fail:
10308 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10309 return NULL;
10310 }
10311
10312
10313 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314 PyObject *resultobj = 0;
10315 PLFLT result;
10316
10317 if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10318 result = (PLFLT)plrandd();
10319 resultobj = SWIG_From_double((double)(result));
10320 return resultobj;
10321 fail:
10322 return NULL;
10323 }
10324
10325
10326 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10327 PyObject *resultobj = 0;
10328
10329 if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10330 plreplot();
10331 resultobj = SWIG_Py_Void();
10332 return resultobj;
10333 fail:
10334 return NULL;
10335 }
10336
10337
10338 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10339 PyObject *resultobj = 0;
10340 PLFLT arg1 ;
10341 PLFLT arg2 ;
10342 PLFLT arg3 ;
10343 PLFLT *arg4 = (PLFLT *) 0 ;
10344 PLFLT *arg5 = (PLFLT *) 0 ;
10345 PLFLT *arg6 = (PLFLT *) 0 ;
10346 double val1 ;
10347 int ecode1 = 0 ;
10348 double val2 ;
10349 int ecode2 = 0 ;
10350 double val3 ;
10351 int ecode3 = 0 ;
10352 PLFLT temp4 ;
10353 int res4 = SWIG_TMPOBJ ;
10354 PLFLT temp5 ;
10355 int res5 = SWIG_TMPOBJ ;
10356 PLFLT temp6 ;
10357 int res6 = SWIG_TMPOBJ ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 PyObject * obj2 = 0 ;
10361
10362 arg4 = &temp4;
10363 arg5 = &temp5;
10364 arg6 = &temp6;
10365 if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10366 ecode1 = SWIG_AsVal_double(obj0, &val1);
10367 if (!SWIG_IsOK(ecode1)) {
10368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10369 }
10370 arg1 = (PLFLT)(val1);
10371 ecode2 = SWIG_AsVal_double(obj1, &val2);
10372 if (!SWIG_IsOK(ecode2)) {
10373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10374 }
10375 arg2 = (PLFLT)(val2);
10376 ecode3 = SWIG_AsVal_double(obj2, &val3);
10377 if (!SWIG_IsOK(ecode3)) {
10378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10379 }
10380 arg3 = (PLFLT)(val3);
10381 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10382 resultobj = SWIG_Py_Void();
10383 if (SWIG_IsTmpObj(res4)) {
10384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10385 } else {
10386 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10388 }
10389 if (SWIG_IsTmpObj(res5)) {
10390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10391 } else {
10392 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10394 }
10395 if (SWIG_IsTmpObj(res6)) {
10396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10397 } else {
10398 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10400 }
10401 return resultobj;
10402 fail:
10403 return NULL;
10404 }
10405
10406
10407 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10408 PyObject *resultobj = 0;
10409 PLFLT arg1 ;
10410 PLFLT arg2 ;
10411 double val1 ;
10412 int ecode1 = 0 ;
10413 double val2 ;
10414 int ecode2 = 0 ;
10415 PyObject * obj0 = 0 ;
10416 PyObject * obj1 = 0 ;
10417
10418 if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10419 ecode1 = SWIG_AsVal_double(obj0, &val1);
10420 if (!SWIG_IsOK(ecode1)) {
10421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10422 }
10423 arg1 = (PLFLT)(val1);
10424 ecode2 = SWIG_AsVal_double(obj1, &val2);
10425 if (!SWIG_IsOK(ecode2)) {
10426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10427 }
10428 arg2 = (PLFLT)(val2);
10429 plschr(arg1,arg2);
10430 resultobj = SWIG_Py_Void();
10431 return resultobj;
10432 fail:
10433 return NULL;
10434 }
10435
10436
10437 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10438 PyObject *resultobj = 0;
10439 PLINT *arg1 = (PLINT *) 0 ;
10440 PLINT *arg2 = (PLINT *) 0 ;
10441 PLINT *arg3 = (PLINT *) 0 ;
10442 PLINT arg4 ;
10443 PyArrayObject *tmp1 = NULL ;
10444 PyArrayObject *tmp2 = NULL ;
10445 PyArrayObject *tmp3 = NULL ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 PyObject * obj2 = 0 ;
10449
10450 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10451 {
10452 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10453 if ( tmp1 == NULL )
10454 return NULL;
10455 Alen = PyArray_DIMS( tmp1 )[0];
10456 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10457 }
10458 {
10459 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10460 if ( tmp2 == NULL )
10461 return NULL;
10462 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10463 {
10464 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10465 return NULL;
10466 }
10467 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10468 }
10469 {
10470 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10471 if ( tmp3 == NULL )
10472 return NULL;
10473 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10474 {
10475 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10476 return NULL;
10477 }
10478 arg4 = PyArray_DIMS( tmp3 )[0];
10479 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10480 }
10481 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10482 resultobj = SWIG_Py_Void();
10483 {
10484 Py_CLEAR( tmp1 );
10485 }
10486 {
10487 Py_CLEAR( tmp2 );
10488 }
10489 {
10490 Py_CLEAR( tmp3 );
10491 }
10492 return resultobj;
10493 fail:
10494 {
10495 Py_CLEAR( tmp1 );
10496 }
10497 {
10498 Py_CLEAR( tmp2 );
10499 }
10500 {
10501 Py_CLEAR( tmp3 );
10502 }
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508 PyObject *resultobj = 0;
10509 PLINT *arg1 = (PLINT *) 0 ;
10510 PLINT *arg2 = (PLINT *) 0 ;
10511 PLINT *arg3 = (PLINT *) 0 ;
10512 PLFLT *arg4 = (PLFLT *) 0 ;
10513 PLINT arg5 ;
10514 PyArrayObject *tmp1 = NULL ;
10515 PyArrayObject *tmp2 = NULL ;
10516 PyArrayObject *tmp3 = NULL ;
10517 PyArrayObject *tmp4 = NULL ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 PyObject * obj2 = 0 ;
10521 PyObject * obj3 = 0 ;
10522
10523 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10524 {
10525 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10526 if ( tmp1 == NULL )
10527 return NULL;
10528 Alen = PyArray_DIMS( tmp1 )[0];
10529 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10530 }
10531 {
10532 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10533 if ( tmp2 == NULL )
10534 return NULL;
10535 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10536 {
10537 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10538 return NULL;
10539 }
10540 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10541 }
10542 {
10543 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10544 if ( tmp3 == NULL )
10545 return NULL;
10546 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10547 {
10548 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10549 return NULL;
10550 }
10551 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10552 }
10553 {
10554 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10555 if ( tmp4 == NULL )
10556 return NULL;
10557 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10558 {
10559 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10560 return NULL;
10561 }
10562 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10563 arg5 = PyArray_DIMS( tmp4 )[0];
10564 }
10565 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10566 resultobj = SWIG_Py_Void();
10567 {
10568 Py_CLEAR( tmp1 );
10569 }
10570 {
10571 Py_CLEAR( tmp2 );
10572 }
10573 {
10574 Py_CLEAR( tmp3 );
10575 }
10576 {
10577 Py_CLEAR( tmp4 );
10578 }
10579 return resultobj;
10580 fail:
10581 {
10582 Py_CLEAR( tmp1 );
10583 }
10584 {
10585 Py_CLEAR( tmp2 );
10586 }
10587 {
10588 Py_CLEAR( tmp3 );
10589 }
10590 {
10591 Py_CLEAR( tmp4 );
10592 }
10593 return NULL;
10594 }
10595
10596
10597 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598 PyObject *resultobj = 0;
10599 PLINT arg1 ;
10600 int val1 ;
10601 int ecode1 = 0 ;
10602 PyObject * obj0 = 0 ;
10603
10604 if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10605 ecode1 = SWIG_AsVal_int(obj0, &val1);
10606 if (!SWIG_IsOK(ecode1)) {
10607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10608 }
10609 arg1 = (PLINT)(val1);
10610 plscmap0n(arg1);
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10619 PyObject *resultobj = 0;
10620 PLINT *arg1 = (PLINT *) 0 ;
10621 PLINT *arg2 = (PLINT *) 0 ;
10622 PLINT *arg3 = (PLINT *) 0 ;
10623 PLINT arg4 ;
10624 PyArrayObject *tmp1 = NULL ;
10625 PyArrayObject *tmp2 = NULL ;
10626 PyArrayObject *tmp3 = NULL ;
10627 PyObject * obj0 = 0 ;
10628 PyObject * obj1 = 0 ;
10629 PyObject * obj2 = 0 ;
10630
10631 if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10632 {
10633 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10634 if ( tmp1 == NULL )
10635 return NULL;
10636 Alen = PyArray_DIMS( tmp1 )[0];
10637 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10638 }
10639 {
10640 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10641 if ( tmp2 == NULL )
10642 return NULL;
10643 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10644 {
10645 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10646 return NULL;
10647 }
10648 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10649 }
10650 {
10651 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10652 if ( tmp3 == NULL )
10653 return NULL;
10654 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10655 {
10656 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10657 return NULL;
10658 }
10659 arg4 = PyArray_DIMS( tmp3 )[0];
10660 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10661 }
10662 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10663 resultobj = SWIG_Py_Void();
10664 {
10665 Py_CLEAR( tmp1 );
10666 }
10667 {
10668 Py_CLEAR( tmp2 );
10669 }
10670 {
10671 Py_CLEAR( tmp3 );
10672 }
10673 return resultobj;
10674 fail:
10675 {
10676 Py_CLEAR( tmp1 );
10677 }
10678 {
10679 Py_CLEAR( tmp2 );
10680 }
10681 {
10682 Py_CLEAR( tmp3 );
10683 }
10684 return NULL;
10685 }
10686
10687
10688 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10689 PyObject *resultobj = 0;
10690 PLINT *arg1 = (PLINT *) 0 ;
10691 PLINT *arg2 = (PLINT *) 0 ;
10692 PLINT *arg3 = (PLINT *) 0 ;
10693 PLFLT *arg4 = (PLFLT *) 0 ;
10694 PLINT arg5 ;
10695 PyArrayObject *tmp1 = NULL ;
10696 PyArrayObject *tmp2 = NULL ;
10697 PyArrayObject *tmp3 = NULL ;
10698 PyArrayObject *tmp4 = NULL ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10703
10704 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10705 {
10706 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10707 if ( tmp1 == NULL )
10708 return NULL;
10709 Alen = PyArray_DIMS( tmp1 )[0];
10710 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10711 }
10712 {
10713 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10714 if ( tmp2 == NULL )
10715 return NULL;
10716 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10717 {
10718 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10719 return NULL;
10720 }
10721 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10722 }
10723 {
10724 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10725 if ( tmp3 == NULL )
10726 return NULL;
10727 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10728 {
10729 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10730 return NULL;
10731 }
10732 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10733 }
10734 {
10735 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10736 if ( tmp4 == NULL )
10737 return NULL;
10738 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10739 {
10740 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10741 return NULL;
10742 }
10743 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10744 arg5 = PyArray_DIMS( tmp4 )[0];
10745 }
10746 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10747 resultobj = SWIG_Py_Void();
10748 {
10749 Py_CLEAR( tmp1 );
10750 }
10751 {
10752 Py_CLEAR( tmp2 );
10753 }
10754 {
10755 Py_CLEAR( tmp3 );
10756 }
10757 {
10758 Py_CLEAR( tmp4 );
10759 }
10760 return resultobj;
10761 fail:
10762 {
10763 Py_CLEAR( tmp1 );
10764 }
10765 {
10766 Py_CLEAR( tmp2 );
10767 }
10768 {
10769 Py_CLEAR( tmp3 );
10770 }
10771 {
10772 Py_CLEAR( tmp4 );
10773 }
10774 return NULL;
10775 }
10776
10777
10778 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *resultobj = 0;
10780 PLBOOL arg1 ;
10781 PLINT arg2 ;
10782 PLFLT *arg3 = (PLFLT *) 0 ;
10783 PLFLT *arg4 = (PLFLT *) 0 ;
10784 PLFLT *arg5 = (PLFLT *) 0 ;
10785 PLFLT *arg6 = (PLFLT *) 0 ;
10786 PLBOOL *arg7 = (PLBOOL *) 0 ;
10787 int val1 ;
10788 int ecode1 = 0 ;
10789 PyArrayObject *tmp2 = NULL ;
10790 PyArrayObject *tmp4 = NULL ;
10791 PyArrayObject *tmp5 = NULL ;
10792 PyArrayObject *tmp6 = NULL ;
10793 PyArrayObject *tmp7 = NULL ;
10794 PyObject * obj0 = 0 ;
10795 PyObject * obj1 = 0 ;
10796 PyObject * obj2 = 0 ;
10797 PyObject * obj3 = 0 ;
10798 PyObject * obj4 = 0 ;
10799 PyObject * obj5 = 0 ;
10800
10801 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10802 ecode1 = SWIG_AsVal_int(obj0, &val1);
10803 if (!SWIG_IsOK(ecode1)) {
10804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10805 }
10806 arg1 = (PLBOOL)(val1);
10807 {
10808 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10809 if ( tmp2 == NULL )
10810 return NULL;
10811 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10812 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10813 }
10814 {
10815 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10816 if ( tmp4 == NULL )
10817 return NULL;
10818 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10819 {
10820 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10821 return NULL;
10822 }
10823 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10824 }
10825 {
10826 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10827 if ( tmp5 == NULL )
10828 return NULL;
10829 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10830 {
10831 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10832 return NULL;
10833 }
10834 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10835 }
10836 {
10837 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10838 if ( tmp6 == NULL )
10839 return NULL;
10840 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10841 {
10842 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10843 return NULL;
10844 }
10845 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10846 }
10847 {
10848 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10849 if ( tmp7 == NULL )
10850 return NULL;
10851 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10852 {
10853 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10854 return NULL;
10855 }
10856 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10857 }
10858 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10859 resultobj = SWIG_Py_Void();
10860 {
10861 Py_CLEAR( tmp2 );
10862 }
10863 {
10864 Py_CLEAR( tmp4 );
10865 }
10866 {
10867 Py_CLEAR( tmp5 );
10868 }
10869 {
10870 Py_CLEAR( tmp6 );
10871 }
10872 {
10873 Py_CLEAR( tmp7 );
10874 }
10875 return resultobj;
10876 fail:
10877 {
10878 Py_CLEAR( tmp2 );
10879 }
10880 {
10881 Py_CLEAR( tmp4 );
10882 }
10883 {
10884 Py_CLEAR( tmp5 );
10885 }
10886 {
10887 Py_CLEAR( tmp6 );
10888 }
10889 {
10890 Py_CLEAR( tmp7 );
10891 }
10892 return NULL;
10893 }
10894
10895
10896 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10897 PyObject *resultobj = 0;
10898 PLBOOL arg1 ;
10899 PLINT arg2 ;
10900 PLFLT *arg3 = (PLFLT *) 0 ;
10901 PLFLT *arg4 = (PLFLT *) 0 ;
10902 PLFLT *arg5 = (PLFLT *) 0 ;
10903 PLFLT *arg6 = (PLFLT *) 0 ;
10904 PLFLT *arg7 = (PLFLT *) 0 ;
10905 PLBOOL *arg8 = (PLBOOL *) 0 ;
10906 int val1 ;
10907 int ecode1 = 0 ;
10908 PyArrayObject *tmp2 = NULL ;
10909 PyArrayObject *tmp4 = NULL ;
10910 PyArrayObject *tmp5 = NULL ;
10911 PyArrayObject *tmp6 = NULL ;
10912 PyArrayObject *tmp7 = NULL ;
10913 PyArrayObject *tmp8 = NULL ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 PyObject * obj2 = 0 ;
10917 PyObject * obj3 = 0 ;
10918 PyObject * obj4 = 0 ;
10919 PyObject * obj5 = 0 ;
10920 PyObject * obj6 = 0 ;
10921
10922 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10923 ecode1 = SWIG_AsVal_int(obj0, &val1);
10924 if (!SWIG_IsOK(ecode1)) {
10925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10926 }
10927 arg1 = (PLBOOL)(val1);
10928 {
10929 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10930 if ( tmp2 == NULL )
10931 return NULL;
10932 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10933 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10934 }
10935 {
10936 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10937 if ( tmp4 == NULL )
10938 return NULL;
10939 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10940 {
10941 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10942 return NULL;
10943 }
10944 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10945 }
10946 {
10947 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10948 if ( tmp5 == NULL )
10949 return NULL;
10950 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10951 {
10952 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10953 return NULL;
10954 }
10955 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10956 }
10957 {
10958 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10959 if ( tmp6 == NULL )
10960 return NULL;
10961 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10962 {
10963 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10964 return NULL;
10965 }
10966 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10967 }
10968 {
10969 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10970 if ( tmp7 == NULL )
10971 return NULL;
10972 if ( PyArray_DIMS( tmp7 )[0] != Alen )
10973 {
10974 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10975 return NULL;
10976 }
10977 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10978 }
10979 {
10980 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10981 if ( tmp8 == NULL )
10982 return NULL;
10983 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10984 {
10985 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10986 return NULL;
10987 }
10988 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10989 }
10990 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10991 resultobj = SWIG_Py_Void();
10992 {
10993 Py_CLEAR( tmp2 );
10994 }
10995 {
10996 Py_CLEAR( tmp4 );
10997 }
10998 {
10999 Py_CLEAR( tmp5 );
11000 }
11001 {
11002 Py_CLEAR( tmp6 );
11003 }
11004 {
11005 Py_CLEAR( tmp7 );
11006 }
11007 {
11008 Py_CLEAR( tmp8 );
11009 }
11010 return resultobj;
11011 fail:
11012 {
11013 Py_CLEAR( tmp2 );
11014 }
11015 {
11016 Py_CLEAR( tmp4 );
11017 }
11018 {
11019 Py_CLEAR( tmp5 );
11020 }
11021 {
11022 Py_CLEAR( tmp6 );
11023 }
11024 {
11025 Py_CLEAR( tmp7 );
11026 }
11027 {
11028 Py_CLEAR( tmp8 );
11029 }
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11035 PyObject *resultobj = 0;
11036 PLINT arg1 ;
11037 int val1 ;
11038 int ecode1 = 0 ;
11039 PyObject * obj0 = 0 ;
11040
11041 if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11042 ecode1 = SWIG_AsVal_int(obj0, &val1);
11043 if (!SWIG_IsOK(ecode1)) {
11044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11045 }
11046 arg1 = (PLINT)(val1);
11047 plscmap1n(arg1);
11048 resultobj = SWIG_Py_Void();
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *resultobj = 0;
11057 PLFLT arg1 ;
11058 PLFLT arg2 ;
11059 double val1 ;
11060 int ecode1 = 0 ;
11061 double val2 ;
11062 int ecode2 = 0 ;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065
11066 if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11067 ecode1 = SWIG_AsVal_double(obj0, &val1);
11068 if (!SWIG_IsOK(ecode1)) {
11069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11070 }
11071 arg1 = (PLFLT)(val1);
11072 ecode2 = SWIG_AsVal_double(obj1, &val2);
11073 if (!SWIG_IsOK(ecode2)) {
11074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11075 }
11076 arg2 = (PLFLT)(val2);
11077 plscmap1_range(arg1,arg2);
11078 resultobj = SWIG_Py_Void();
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11086 PyObject *resultobj = 0;
11087 PLFLT *arg1 = (PLFLT *) 0 ;
11088 PLFLT *arg2 = (PLFLT *) 0 ;
11089 PLFLT temp1 ;
11090 int res1 = SWIG_TMPOBJ ;
11091 PLFLT temp2 ;
11092 int res2 = SWIG_TMPOBJ ;
11093
11094 arg1 = &temp1;
11095 arg2 = &temp2;
11096 if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11097 plgcmap1_range(arg1,arg2);
11098 resultobj = SWIG_Py_Void();
11099 if (SWIG_IsTmpObj(res1)) {
11100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11101 } else {
11102 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11104 }
11105 if (SWIG_IsTmpObj(res2)) {
11106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11107 } else {
11108 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11110 }
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 PLINT arg1 ;
11120 PLINT arg2 ;
11121 PLINT arg3 ;
11122 PLINT arg4 ;
11123 int val1 ;
11124 int ecode1 = 0 ;
11125 int val2 ;
11126 int ecode2 = 0 ;
11127 int val3 ;
11128 int ecode3 = 0 ;
11129 int val4 ;
11130 int ecode4 = 0 ;
11131 PyObject * obj0 = 0 ;
11132 PyObject * obj1 = 0 ;
11133 PyObject * obj2 = 0 ;
11134 PyObject * obj3 = 0 ;
11135
11136 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11137 ecode1 = SWIG_AsVal_int(obj0, &val1);
11138 if (!SWIG_IsOK(ecode1)) {
11139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11140 }
11141 arg1 = (PLINT)(val1);
11142 ecode2 = SWIG_AsVal_int(obj1, &val2);
11143 if (!SWIG_IsOK(ecode2)) {
11144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11145 }
11146 arg2 = (PLINT)(val2);
11147 ecode3 = SWIG_AsVal_int(obj2, &val3);
11148 if (!SWIG_IsOK(ecode3)) {
11149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11150 }
11151 arg3 = (PLINT)(val3);
11152 ecode4 = SWIG_AsVal_int(obj3, &val4);
11153 if (!SWIG_IsOK(ecode4)) {
11154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11155 }
11156 arg4 = (PLINT)(val4);
11157 plscol0(arg1,arg2,arg3,arg4);
11158 resultobj = SWIG_Py_Void();
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11166 PyObject *resultobj = 0;
11167 PLINT arg1 ;
11168 PLINT arg2 ;
11169 PLINT arg3 ;
11170 PLINT arg4 ;
11171 PLFLT arg5 ;
11172 int val1 ;
11173 int ecode1 = 0 ;
11174 int val2 ;
11175 int ecode2 = 0 ;
11176 int val3 ;
11177 int ecode3 = 0 ;
11178 int val4 ;
11179 int ecode4 = 0 ;
11180 double val5 ;
11181 int ecode5 = 0 ;
11182 PyObject * obj0 = 0 ;
11183 PyObject * obj1 = 0 ;
11184 PyObject * obj2 = 0 ;
11185 PyObject * obj3 = 0 ;
11186 PyObject * obj4 = 0 ;
11187
11188 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11189 ecode1 = SWIG_AsVal_int(obj0, &val1);
11190 if (!SWIG_IsOK(ecode1)) {
11191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11192 }
11193 arg1 = (PLINT)(val1);
11194 ecode2 = SWIG_AsVal_int(obj1, &val2);
11195 if (!SWIG_IsOK(ecode2)) {
11196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11197 }
11198 arg2 = (PLINT)(val2);
11199 ecode3 = SWIG_AsVal_int(obj2, &val3);
11200 if (!SWIG_IsOK(ecode3)) {
11201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11202 }
11203 arg3 = (PLINT)(val3);
11204 ecode4 = SWIG_AsVal_int(obj3, &val4);
11205 if (!SWIG_IsOK(ecode4)) {
11206 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11207 }
11208 arg4 = (PLINT)(val4);
11209 ecode5 = SWIG_AsVal_double(obj4, &val5);
11210 if (!SWIG_IsOK(ecode5)) {
11211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11212 }
11213 arg5 = (PLFLT)(val5);
11214 plscol0a(arg1,arg2,arg3,arg4,arg5);
11215 resultobj = SWIG_Py_Void();
11216 return resultobj;
11217 fail:
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11223 PyObject *resultobj = 0;
11224 PLINT arg1 ;
11225 PLINT arg2 ;
11226 PLINT arg3 ;
11227 int val1 ;
11228 int ecode1 = 0 ;
11229 int val2 ;
11230 int ecode2 = 0 ;
11231 int val3 ;
11232 int ecode3 = 0 ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236
11237 if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11238 ecode1 = SWIG_AsVal_int(obj0, &val1);
11239 if (!SWIG_IsOK(ecode1)) {
11240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11241 }
11242 arg1 = (PLINT)(val1);
11243 ecode2 = SWIG_AsVal_int(obj1, &val2);
11244 if (!SWIG_IsOK(ecode2)) {
11245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11246 }
11247 arg2 = (PLINT)(val2);
11248 ecode3 = SWIG_AsVal_int(obj2, &val3);
11249 if (!SWIG_IsOK(ecode3)) {
11250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11251 }
11252 arg3 = (PLINT)(val3);
11253 plscolbg(arg1,arg2,arg3);
11254 resultobj = SWIG_Py_Void();
11255 return resultobj;
11256 fail:
11257 return NULL;
11258 }
11259
11260
11261 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11262 PyObject *resultobj = 0;
11263 PLINT arg1 ;
11264 PLINT arg2 ;
11265 PLINT arg3 ;
11266 PLFLT arg4 ;
11267 int val1 ;
11268 int ecode1 = 0 ;
11269 int val2 ;
11270 int ecode2 = 0 ;
11271 int val3 ;
11272 int ecode3 = 0 ;
11273 double val4 ;
11274 int ecode4 = 0 ;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 PyObject * obj3 = 0 ;
11279
11280 if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11281 ecode1 = SWIG_AsVal_int(obj0, &val1);
11282 if (!SWIG_IsOK(ecode1)) {
11283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11284 }
11285 arg1 = (PLINT)(val1);
11286 ecode2 = SWIG_AsVal_int(obj1, &val2);
11287 if (!SWIG_IsOK(ecode2)) {
11288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11289 }
11290 arg2 = (PLINT)(val2);
11291 ecode3 = SWIG_AsVal_int(obj2, &val3);
11292 if (!SWIG_IsOK(ecode3)) {
11293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11294 }
11295 arg3 = (PLINT)(val3);
11296 ecode4 = SWIG_AsVal_double(obj3, &val4);
11297 if (!SWIG_IsOK(ecode4)) {
11298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11299 }
11300 arg4 = (PLFLT)(val4);
11301 plscolbga(arg1,arg2,arg3,arg4);
11302 resultobj = SWIG_Py_Void();
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310 PyObject *resultobj = 0;
11311 PLINT arg1 ;
11312 int val1 ;
11313 int ecode1 = 0 ;
11314 PyObject * obj0 = 0 ;
11315
11316 if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11317 ecode1 = SWIG_AsVal_int(obj0, &val1);
11318 if (!SWIG_IsOK(ecode1)) {
11319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11320 }
11321 arg1 = (PLINT)(val1);
11322 plscolor(arg1);
11323 resultobj = SWIG_Py_Void();
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11331 PyObject *resultobj = 0;
11332 PLINT arg1 ;
11333 int val1 ;
11334 int ecode1 = 0 ;
11335 PyObject * obj0 = 0 ;
11336
11337 if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11338 ecode1 = SWIG_AsVal_int(obj0, &val1);
11339 if (!SWIG_IsOK(ecode1)) {
11340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11341 }
11342 arg1 = (PLINT)(val1);
11343 plscompression(arg1);
11344 resultobj = SWIG_Py_Void();
11345 return resultobj;
11346 fail:
11347 return NULL;
11348 }
11349
11350
11351 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11352 PyObject *resultobj = 0;
11353 char *arg1 = (char *) 0 ;
11354 int res1 ;
11355 char *buf1 = 0 ;
11356 int alloc1 = 0 ;
11357 PyObject * obj0 = 0 ;
11358
11359 if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11360 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11361 if (!SWIG_IsOK(res1)) {
11362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11363 }
11364 arg1 = (char *)(buf1);
11365 plsdev((char const *)arg1);
11366 resultobj = SWIG_Py_Void();
11367 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11368 return resultobj;
11369 fail:
11370 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11376 PyObject *resultobj = 0;
11377 PLFLT arg1 ;
11378 PLFLT arg2 ;
11379 PLFLT arg3 ;
11380 PLFLT arg4 ;
11381 double val1 ;
11382 int ecode1 = 0 ;
11383 double val2 ;
11384 int ecode2 = 0 ;
11385 double val3 ;
11386 int ecode3 = 0 ;
11387 double val4 ;
11388 int ecode4 = 0 ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 PyObject * obj2 = 0 ;
11392 PyObject * obj3 = 0 ;
11393
11394 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11395 ecode1 = SWIG_AsVal_double(obj0, &val1);
11396 if (!SWIG_IsOK(ecode1)) {
11397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11398 }
11399 arg1 = (PLFLT)(val1);
11400 ecode2 = SWIG_AsVal_double(obj1, &val2);
11401 if (!SWIG_IsOK(ecode2)) {
11402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11403 }
11404 arg2 = (PLFLT)(val2);
11405 ecode3 = SWIG_AsVal_double(obj2, &val3);
11406 if (!SWIG_IsOK(ecode3)) {
11407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11408 }
11409 arg3 = (PLFLT)(val3);
11410 ecode4 = SWIG_AsVal_double(obj3, &val4);
11411 if (!SWIG_IsOK(ecode4)) {
11412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11413 }
11414 arg4 = (PLFLT)(val4);
11415 plsdidev(arg1,arg2,arg3,arg4);
11416 resultobj = SWIG_Py_Void();
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11424 PyObject *resultobj = 0;
11425 PLINT arg1 ;
11426 PLINT arg2 ;
11427 PLINT arg3 ;
11428 PLINT arg4 ;
11429 PLFLT arg5 ;
11430 PLFLT arg6 ;
11431 int val1 ;
11432 int ecode1 = 0 ;
11433 int val2 ;
11434 int ecode2 = 0 ;
11435 int val3 ;
11436 int ecode3 = 0 ;
11437 int val4 ;
11438 int ecode4 = 0 ;
11439 double val5 ;
11440 int ecode5 = 0 ;
11441 double val6 ;
11442 int ecode6 = 0 ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 PyObject * obj2 = 0 ;
11446 PyObject * obj3 = 0 ;
11447 PyObject * obj4 = 0 ;
11448 PyObject * obj5 = 0 ;
11449
11450 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11451 ecode1 = SWIG_AsVal_int(obj0, &val1);
11452 if (!SWIG_IsOK(ecode1)) {
11453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11454 }
11455 arg1 = (PLINT)(val1);
11456 ecode2 = SWIG_AsVal_int(obj1, &val2);
11457 if (!SWIG_IsOK(ecode2)) {
11458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11459 }
11460 arg2 = (PLINT)(val2);
11461 ecode3 = SWIG_AsVal_int(obj2, &val3);
11462 if (!SWIG_IsOK(ecode3)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11464 }
11465 arg3 = (PLINT)(val3);
11466 ecode4 = SWIG_AsVal_int(obj3, &val4);
11467 if (!SWIG_IsOK(ecode4)) {
11468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11469 }
11470 arg4 = (PLINT)(val4);
11471 ecode5 = SWIG_AsVal_double(obj4, &val5);
11472 if (!SWIG_IsOK(ecode5)) {
11473 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11474 }
11475 arg5 = (PLFLT)(val5);
11476 ecode6 = SWIG_AsVal_double(obj5, &val6);
11477 if (!SWIG_IsOK(ecode6)) {
11478 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11479 }
11480 arg6 = (PLFLT)(val6);
11481 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11482 resultobj = SWIG_Py_Void();
11483 return resultobj;
11484 fail:
11485 return NULL;
11486 }
11487
11488
11489 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11490 PyObject *resultobj = 0;
11491 PLFLT arg1 ;
11492 double val1 ;
11493 int ecode1 = 0 ;
11494 PyObject * obj0 = 0 ;
11495
11496 if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11497 ecode1 = SWIG_AsVal_double(obj0, &val1);
11498 if (!SWIG_IsOK(ecode1)) {
11499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11500 }
11501 arg1 = (PLFLT)(val1);
11502 plsdiori(arg1);
11503 resultobj = SWIG_Py_Void();
11504 return resultobj;
11505 fail:
11506 return NULL;
11507 }
11508
11509
11510 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11511 PyObject *resultobj = 0;
11512 PLFLT arg1 ;
11513 PLFLT arg2 ;
11514 PLFLT arg3 ;
11515 PLFLT arg4 ;
11516 double val1 ;
11517 int ecode1 = 0 ;
11518 double val2 ;
11519 int ecode2 = 0 ;
11520 double val3 ;
11521 int ecode3 = 0 ;
11522 double val4 ;
11523 int ecode4 = 0 ;
11524 PyObject * obj0 = 0 ;
11525 PyObject * obj1 = 0 ;
11526 PyObject * obj2 = 0 ;
11527 PyObject * obj3 = 0 ;
11528
11529 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11530 ecode1 = SWIG_AsVal_double(obj0, &val1);
11531 if (!SWIG_IsOK(ecode1)) {
11532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11533 }
11534 arg1 = (PLFLT)(val1);
11535 ecode2 = SWIG_AsVal_double(obj1, &val2);
11536 if (!SWIG_IsOK(ecode2)) {
11537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11538 }
11539 arg2 = (PLFLT)(val2);
11540 ecode3 = SWIG_AsVal_double(obj2, &val3);
11541 if (!SWIG_IsOK(ecode3)) {
11542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11543 }
11544 arg3 = (PLFLT)(val3);
11545 ecode4 = SWIG_AsVal_double(obj3, &val4);
11546 if (!SWIG_IsOK(ecode4)) {
11547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11548 }
11549 arg4 = (PLFLT)(val4);
11550 plsdiplt(arg1,arg2,arg3,arg4);
11551 resultobj = SWIG_Py_Void();
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11559 PyObject *resultobj = 0;
11560 PLFLT arg1 ;
11561 PLFLT arg2 ;
11562 PLFLT arg3 ;
11563 PLFLT arg4 ;
11564 double val1 ;
11565 int ecode1 = 0 ;
11566 double val2 ;
11567 int ecode2 = 0 ;
11568 double val3 ;
11569 int ecode3 = 0 ;
11570 double val4 ;
11571 int ecode4 = 0 ;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 PyObject * obj2 = 0 ;
11575 PyObject * obj3 = 0 ;
11576
11577 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11578 ecode1 = SWIG_AsVal_double(obj0, &val1);
11579 if (!SWIG_IsOK(ecode1)) {
11580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11581 }
11582 arg1 = (PLFLT)(val1);
11583 ecode2 = SWIG_AsVal_double(obj1, &val2);
11584 if (!SWIG_IsOK(ecode2)) {
11585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11586 }
11587 arg2 = (PLFLT)(val2);
11588 ecode3 = SWIG_AsVal_double(obj2, &val3);
11589 if (!SWIG_IsOK(ecode3)) {
11590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11591 }
11592 arg3 = (PLFLT)(val3);
11593 ecode4 = SWIG_AsVal_double(obj3, &val4);
11594 if (!SWIG_IsOK(ecode4)) {
11595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11596 }
11597 arg4 = (PLFLT)(val4);
11598 plsdiplz(arg1,arg2,arg3,arg4);
11599 resultobj = SWIG_Py_Void();
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 unsigned int arg1 ;
11609 unsigned int val1 ;
11610 int ecode1 = 0 ;
11611 PyObject * obj0 = 0 ;
11612
11613 if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11614 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11615 if (!SWIG_IsOK(ecode1)) {
11616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11617 }
11618 arg1 = (unsigned int)(val1);
11619 plseed(arg1);
11620 resultobj = SWIG_Py_Void();
11621 return resultobj;
11622 fail:
11623 return NULL;
11624 }
11625
11626
11627 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11628 PyObject *resultobj = 0;
11629 char arg1 ;
11630 char val1 ;
11631 int ecode1 = 0 ;
11632 PyObject * obj0 = 0 ;
11633
11634 if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11635 ecode1 = SWIG_AsVal_char(obj0, &val1);
11636 if (!SWIG_IsOK(ecode1)) {
11637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11638 }
11639 arg1 = (char)(val1);
11640 plsesc(arg1);
11641 resultobj = SWIG_Py_Void();
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649 PyObject *resultobj = 0;
11650 char *arg1 = (char *) 0 ;
11651 char *arg2 = (char *) 0 ;
11652 int res1 ;
11653 char *buf1 = 0 ;
11654 int alloc1 = 0 ;
11655 int res2 ;
11656 char *buf2 = 0 ;
11657 int alloc2 = 0 ;
11658 PyObject * obj0 = 0 ;
11659 PyObject * obj1 = 0 ;
11660 PLINT result;
11661
11662 if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11663 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11664 if (!SWIG_IsOK(res1)) {
11665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11666 }
11667 arg1 = (char *)(buf1);
11668 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11669 if (!SWIG_IsOK(res2)) {
11670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11671 }
11672 arg2 = (char *)(buf2);
11673 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11674 resultobj = SWIG_From_int((int)(result));
11675 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11676 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11677 return resultobj;
11678 fail:
11679 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11680 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 PyObject *resultobj = 0;
11687 PLINT arg1 ;
11688 PLINT arg2 ;
11689 PLINT arg3 ;
11690 int val1 ;
11691 int ecode1 = 0 ;
11692 int val2 ;
11693 int ecode2 = 0 ;
11694 int val3 ;
11695 int ecode3 = 0 ;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11698 PyObject * obj2 = 0 ;
11699
11700 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11701 ecode1 = SWIG_AsVal_int(obj0, &val1);
11702 if (!SWIG_IsOK(ecode1)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11704 }
11705 arg1 = (PLINT)(val1);
11706 ecode2 = SWIG_AsVal_int(obj1, &val2);
11707 if (!SWIG_IsOK(ecode2)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11709 }
11710 arg2 = (PLINT)(val2);
11711 ecode3 = SWIG_AsVal_int(obj2, &val3);
11712 if (!SWIG_IsOK(ecode3)) {
11713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11714 }
11715 arg3 = (PLINT)(val3);
11716 plsfam(arg1,arg2,arg3);
11717 resultobj = SWIG_Py_Void();
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 PyObject *resultobj = 0;
11726 PLUNICODE arg1 ;
11727 unsigned int val1 ;
11728 int ecode1 = 0 ;
11729 PyObject * obj0 = 0 ;
11730
11731 if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11732 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11733 if (!SWIG_IsOK(ecode1)) {
11734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11735 }
11736 arg1 = (PLUNICODE)(val1);
11737 plsfci(arg1);
11738 resultobj = SWIG_Py_Void();
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11746 PyObject *resultobj = 0;
11747 char *arg1 = (char *) 0 ;
11748 int res1 ;
11749 char *buf1 = 0 ;
11750 int alloc1 = 0 ;
11751 PyObject * obj0 = 0 ;
11752
11753 if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11754 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11755 if (!SWIG_IsOK(res1)) {
11756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11757 }
11758 arg1 = (char *)(buf1);
11759 plsfnam((char const *)arg1);
11760 resultobj = SWIG_Py_Void();
11761 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11762 return resultobj;
11763 fail:
11764 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11765 return NULL;
11766 }
11767
11768
11769 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770 PyObject *resultobj = 0;
11771 PLINT arg1 ;
11772 PLINT arg2 ;
11773 PLINT arg3 ;
11774 int val1 ;
11775 int ecode1 = 0 ;
11776 int val2 ;
11777 int ecode2 = 0 ;
11778 int val3 ;
11779 int ecode3 = 0 ;
11780 PyObject * obj0 = 0 ;
11781 PyObject * obj1 = 0 ;
11782 PyObject * obj2 = 0 ;
11783
11784 if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11785 ecode1 = SWIG_AsVal_int(obj0, &val1);
11786 if (!SWIG_IsOK(ecode1)) {
11787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11788 }
11789 arg1 = (PLINT)(val1);
11790 ecode2 = SWIG_AsVal_int(obj1, &val2);
11791 if (!SWIG_IsOK(ecode2)) {
11792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11793 }
11794 arg2 = (PLINT)(val2);
11795 ecode3 = SWIG_AsVal_int(obj2, &val3);
11796 if (!SWIG_IsOK(ecode3)) {
11797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11798 }
11799 arg3 = (PLINT)(val3);
11800 plsfont(arg1,arg2,arg3);
11801 resultobj = SWIG_Py_Void();
11802 return resultobj;
11803 fail:
11804 return NULL;
11805 }
11806
11807
11808 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809 PyObject *resultobj = 0;
11810 PLFLT **arg1 = (PLFLT **) 0 ;
11811 PLINT arg2 ;
11812 PLINT arg3 ;
11813 defined_func arg4 = (defined_func) 0 ;
11814 PLFLT arg5 ;
11815 PLFLT arg6 ;
11816 PLFLT arg7 ;
11817 PLFLT arg8 ;
11818 PLFLT *arg9 = (PLFLT *) 0 ;
11819 PLINT arg10 ;
11820 PLFLT arg11 ;
11821 PLINT arg12 ;
11822 PLFLT arg13 ;
11823 fill_func arg14 = (fill_func) 0 ;
11824 PLBOOL arg15 ;
11825 pltr_func arg16 = (pltr_func) 0 ;
11826 PLPointer arg17 = (PLPointer) 0 ;
11827 PyArrayObject *tmp1 = NULL ;
11828 double val5 ;
11829 int ecode5 = 0 ;
11830 double val6 ;
11831 int ecode6 = 0 ;
11832 double val7 ;
11833 int ecode7 = 0 ;
11834 double val8 ;
11835 int ecode8 = 0 ;
11836 PyArrayObject *tmp9 = NULL ;
11837 double val11 ;
11838 int ecode11 = 0 ;
11839 int val12 ;
11840 int ecode12 = 0 ;
11841 double val13 ;
11842 int ecode13 = 0 ;
11843 int val15 ;
11844 int ecode15 = 0 ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 PyObject * obj2 = 0 ;
11848 PyObject * obj3 = 0 ;
11849 PyObject * obj4 = 0 ;
11850 PyObject * obj5 = 0 ;
11851 PyObject * obj6 = 0 ;
11852 PyObject * obj7 = 0 ;
11853 PyObject * obj8 = 0 ;
11854 PyObject * obj9 = 0 ;
11855 PyObject * obj10 = 0 ;
11856 PyObject * obj11 = 0 ;
11857
11858 {
11859 python_pltr = 0;
11860 arg16 = NULL;
11861 }
11862 {
11863 arg17 = NULL;
11864 }
11865 {
11866 arg4 = NULL;
11867 }
11868 {
11869 arg14 = plfill;
11870 }
11871 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11872 {
11873 int i, size;
11874 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11875 if ( tmp1 == NULL )
11876 return NULL;
11877 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11878 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11879 size = arg3;
11880 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11881 for ( i = 0; i < arg2; i++ )
11882 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11883 }
11884 ecode5 = SWIG_AsVal_double(obj1, &val5);
11885 if (!SWIG_IsOK(ecode5)) {
11886 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11887 }
11888 arg5 = (PLFLT)(val5);
11889 ecode6 = SWIG_AsVal_double(obj2, &val6);
11890 if (!SWIG_IsOK(ecode6)) {
11891 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11892 }
11893 arg6 = (PLFLT)(val6);
11894 ecode7 = SWIG_AsVal_double(obj3, &val7);
11895 if (!SWIG_IsOK(ecode7)) {
11896 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11897 }
11898 arg7 = (PLFLT)(val7);
11899 ecode8 = SWIG_AsVal_double(obj4, &val8);
11900 if (!SWIG_IsOK(ecode8)) {
11901 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11902 }
11903 arg8 = (PLFLT)(val8);
11904 {
11905 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11906 if ( tmp9 == NULL )
11907 return NULL;
11908 arg10 = PyArray_DIMS( tmp9 )[0];
11909 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11910 }
11911 ecode11 = SWIG_AsVal_double(obj6, &val11);
11912 if (!SWIG_IsOK(ecode11)) {
11913 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11914 }
11915 arg11 = (PLFLT)(val11);
11916 ecode12 = SWIG_AsVal_int(obj7, &val12);
11917 if (!SWIG_IsOK(ecode12)) {
11918 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11919 }
11920 arg12 = (PLINT)(val12);
11921 ecode13 = SWIG_AsVal_double(obj8, &val13);
11922 if (!SWIG_IsOK(ecode13)) {
11923 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11924 }
11925 arg13 = (PLFLT)(val13);
11926 ecode15 = SWIG_AsVal_int(obj9, &val15);
11927 if (!SWIG_IsOK(ecode15)) {
11928 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11929 }
11930 arg15 = (PLBOOL)(val15);
11931 if (obj10) {
11932 {
11933 // it must be a callable or None
11934 if ( obj10 == Py_None )
11935 {
11936 arg16 = NULL;
11937 }
11938 else
11939 {
11940 if ( !PyCallable_Check( (PyObject *) obj10 ) )
11941 {
11942 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11943 return NULL;
11944 }
11945 arg16 = marshal_pltr( obj10 );
11946 }
11947 }
11948 }
11949 if (obj11) {
11950 {
11951 if ( obj11 == Py_None )
11952 arg17 = NULL;
11953 else
11954 {
11955 arg17 = marshal_PLPointer( obj11, 0 );
11956 }
11957 }
11958 }
11959 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11960 resultobj = SWIG_Py_Void();
11961 {
11962 Py_CLEAR( tmp1 );
11963 free( arg1 );
11964 }
11965 {
11966 Py_CLEAR( tmp9 );
11967 }
11968 {
11969 cleanup_pltr();
11970 }
11971 {
11972 cleanup_PLPointer();
11973 }
11974 return resultobj;
11975 fail:
11976 {
11977 Py_CLEAR( tmp1 );
11978 free( arg1 );
11979 }
11980 {
11981 Py_CLEAR( tmp9 );
11982 }
11983 {
11984 cleanup_pltr();
11985 }
11986 {
11987 cleanup_PLPointer();
11988 }
11989 return NULL;
11990 }
11991
11992
11993 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11994 PyObject *resultobj = 0;
11995 PLFLT **arg1 = (PLFLT **) 0 ;
11996 PLINT arg2 ;
11997 PLINT arg3 ;
11998 defined_func arg4 = (defined_func) 0 ;
11999 PLFLT arg5 ;
12000 PLFLT arg6 ;
12001 PLFLT arg7 ;
12002 PLFLT arg8 ;
12003 PLFLT arg9 ;
12004 PLFLT arg10 ;
12005 PLINT arg11 ;
12006 PLFLT arg12 ;
12007 PLFLT arg13 ;
12008 PLINT arg14 ;
12009 PLFLT arg15 ;
12010 PLINT arg16 ;
12011 PLFLT arg17 ;
12012 fill_func arg18 = (fill_func) 0 ;
12013 PLBOOL arg19 ;
12014 pltr_func arg20 = (pltr_func) 0 ;
12015 PLPointer arg21 = (PLPointer) 0 ;
12016 PyArrayObject *tmp1 = NULL ;
12017 double val5 ;
12018 int ecode5 = 0 ;
12019 double val6 ;
12020 int ecode6 = 0 ;
12021 double val7 ;
12022 int ecode7 = 0 ;
12023 double val8 ;
12024 int ecode8 = 0 ;
12025 double val9 ;
12026 int ecode9 = 0 ;
12027 double val10 ;
12028 int ecode10 = 0 ;
12029 int val11 ;
12030 int ecode11 = 0 ;
12031 double val12 ;
12032 int ecode12 = 0 ;
12033 double val13 ;
12034 int ecode13 = 0 ;
12035 int val14 ;
12036 int ecode14 = 0 ;
12037 double val15 ;
12038 int ecode15 = 0 ;
12039 int val16 ;
12040 int ecode16 = 0 ;
12041 double val17 ;
12042 int ecode17 = 0 ;
12043 int val19 ;
12044 int ecode19 = 0 ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 PyObject * obj2 = 0 ;
12048 PyObject * obj3 = 0 ;
12049 PyObject * obj4 = 0 ;
12050 PyObject * obj5 = 0 ;
12051 PyObject * obj6 = 0 ;
12052 PyObject * obj7 = 0 ;
12053 PyObject * obj8 = 0 ;
12054 PyObject * obj9 = 0 ;
12055 PyObject * obj10 = 0 ;
12056 PyObject * obj11 = 0 ;
12057 PyObject * obj12 = 0 ;
12058 PyObject * obj13 = 0 ;
12059 PyObject * obj14 = 0 ;
12060 PyObject * obj15 = 0 ;
12061 PyObject * obj16 = 0 ;
12062
12063 {
12064 python_pltr = 0;
12065 arg20 = NULL;
12066 }
12067 {
12068 arg21 = NULL;
12069 }
12070 {
12071 arg4 = NULL;
12072 }
12073 {
12074 arg18 = plfill;
12075 }
12076 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;
12077 {
12078 int i, size;
12079 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12080 if ( tmp1 == NULL )
12081 return NULL;
12082 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12083 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12084 size = arg3;
12085 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12086 for ( i = 0; i < arg2; i++ )
12087 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12088 }
12089 ecode5 = SWIG_AsVal_double(obj1, &val5);
12090 if (!SWIG_IsOK(ecode5)) {
12091 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12092 }
12093 arg5 = (PLFLT)(val5);
12094 ecode6 = SWIG_AsVal_double(obj2, &val6);
12095 if (!SWIG_IsOK(ecode6)) {
12096 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12097 }
12098 arg6 = (PLFLT)(val6);
12099 ecode7 = SWIG_AsVal_double(obj3, &val7);
12100 if (!SWIG_IsOK(ecode7)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12102 }
12103 arg7 = (PLFLT)(val7);
12104 ecode8 = SWIG_AsVal_double(obj4, &val8);
12105 if (!SWIG_IsOK(ecode8)) {
12106 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12107 }
12108 arg8 = (PLFLT)(val8);
12109 ecode9 = SWIG_AsVal_double(obj5, &val9);
12110 if (!SWIG_IsOK(ecode9)) {
12111 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12112 }
12113 arg9 = (PLFLT)(val9);
12114 ecode10 = SWIG_AsVal_double(obj6, &val10);
12115 if (!SWIG_IsOK(ecode10)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12117 }
12118 arg10 = (PLFLT)(val10);
12119 ecode11 = SWIG_AsVal_int(obj7, &val11);
12120 if (!SWIG_IsOK(ecode11)) {
12121 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12122 }
12123 arg11 = (PLINT)(val11);
12124 ecode12 = SWIG_AsVal_double(obj8, &val12);
12125 if (!SWIG_IsOK(ecode12)) {
12126 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12127 }
12128 arg12 = (PLFLT)(val12);
12129 ecode13 = SWIG_AsVal_double(obj9, &val13);
12130 if (!SWIG_IsOK(ecode13)) {
12131 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12132 }
12133 arg13 = (PLFLT)(val13);
12134 ecode14 = SWIG_AsVal_int(obj10, &val14);
12135 if (!SWIG_IsOK(ecode14)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12137 }
12138 arg14 = (PLINT)(val14);
12139 ecode15 = SWIG_AsVal_double(obj11, &val15);
12140 if (!SWIG_IsOK(ecode15)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12142 }
12143 arg15 = (PLFLT)(val15);
12144 ecode16 = SWIG_AsVal_int(obj12, &val16);
12145 if (!SWIG_IsOK(ecode16)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12147 }
12148 arg16 = (PLINT)(val16);
12149 ecode17 = SWIG_AsVal_double(obj13, &val17);
12150 if (!SWIG_IsOK(ecode17)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12152 }
12153 arg17 = (PLFLT)(val17);
12154 ecode19 = SWIG_AsVal_int(obj14, &val19);
12155 if (!SWIG_IsOK(ecode19)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12157 }
12158 arg19 = (PLBOOL)(val19);
12159 if (obj15) {
12160 {
12161 // it must be a callable or None
12162 if ( obj15 == Py_None )
12163 {
12164 arg20 = NULL;
12165 }
12166 else
12167 {
12168 if ( !PyCallable_Check( (PyObject *) obj15 ) )
12169 {
12170 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12171 return NULL;
12172 }
12173 arg20 = marshal_pltr( obj15 );
12174 }
12175 }
12176 }
12177 if (obj16) {
12178 {
12179 if ( obj16 == Py_None )
12180 arg21 = NULL;
12181 else
12182 {
12183 arg21 = marshal_PLPointer( obj16, 0 );
12184 }
12185 }
12186 }
12187 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12188 resultobj = SWIG_Py_Void();
12189 {
12190 Py_CLEAR( tmp1 );
12191 free( arg1 );
12192 }
12193 {
12194 cleanup_pltr();
12195 }
12196 {
12197 cleanup_PLPointer();
12198 }
12199 return resultobj;
12200 fail:
12201 {
12202 Py_CLEAR( tmp1 );
12203 free( arg1 );
12204 }
12205 {
12206 cleanup_pltr();
12207 }
12208 {
12209 cleanup_PLPointer();
12210 }
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12216 PyObject *resultobj = 0;
12217 label_func arg1 = (label_func) 0 ;
12218 PLPointer arg2 = (PLPointer) 0 ;
12219 int res2 ;
12220 PyObject * obj0 = 0 ;
12221 PyObject * obj1 = 0 ;
12222
12223 if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12224 {
12225 // Release reference to previous function if applicable
12226 if ( python_label )
12227 {
12228 Py_CLEAR( python_label );
12229 python_label = 0;
12230 }
12231 // it must be a callable or None
12232 if ( obj0 == Py_None )
12233 {
12234 arg1 = NULL;
12235 }
12236 else
12237 {
12238 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12239 {
12240 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12241 return NULL;
12242 }
12243 // hold a reference to it
12244 Py_XINCREF( (PyObject *) obj0 );
12245 python_label = (PyObject *) obj0;
12246 // this function handles calling the python function
12247 arg1 = do_label_callback;
12248 }
12249 }
12250 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12251 if (!SWIG_IsOK(res2)) {
12252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12253 }
12254 plslabelfunc(arg1,arg2);
12255 resultobj = SWIG_Py_Void();
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12263 PyObject *resultobj = 0;
12264 PLFLT arg1 ;
12265 PLFLT arg2 ;
12266 double val1 ;
12267 int ecode1 = 0 ;
12268 double val2 ;
12269 int ecode2 = 0 ;
12270 PyObject * obj0 = 0 ;
12271 PyObject * obj1 = 0 ;
12272
12273 if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12274 ecode1 = SWIG_AsVal_double(obj0, &val1);
12275 if (!SWIG_IsOK(ecode1)) {
12276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12277 }
12278 arg1 = (PLFLT)(val1);
12279 ecode2 = SWIG_AsVal_double(obj1, &val2);
12280 if (!SWIG_IsOK(ecode2)) {
12281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12282 }
12283 arg2 = (PLFLT)(val2);
12284 plsmaj(arg1,arg2);
12285 resultobj = SWIG_Py_Void();
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12293 PyObject *resultobj = 0;
12294 PLINT arg1 ;
12295 PLINT arg2 ;
12296 void *arg3 = (void *) 0 ;
12297 int val1 ;
12298 int ecode1 = 0 ;
12299 int val2 ;
12300 int ecode2 = 0 ;
12301 int res3 ;
12302 Py_ssize_t size3 = 0 ;
12303 void *buf3 = 0 ;
12304 PyObject * obj0 = 0 ;
12305 PyObject * obj1 = 0 ;
12306 PyObject * obj2 = 0 ;
12307
12308 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12309 ecode1 = SWIG_AsVal_int(obj0, &val1);
12310 if (!SWIG_IsOK(ecode1)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12312 }
12313 arg1 = (PLINT)(val1);
12314 ecode2 = SWIG_AsVal_int(obj1, &val2);
12315 if (!SWIG_IsOK(ecode2)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12317 }
12318 arg2 = (PLINT)(val2);
12319 {
12320 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12321 if (res3<0) {
12322 PyErr_Clear();
12323 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12324 }
12325 arg3 = (void *) buf3;
12326 }
12327 plsmem(arg1,arg2,arg3);
12328 resultobj = SWIG_Py_Void();
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336 PyObject *resultobj = 0;
12337 PLINT arg1 ;
12338 PLINT arg2 ;
12339 void *arg3 = (void *) 0 ;
12340 int val1 ;
12341 int ecode1 = 0 ;
12342 int val2 ;
12343 int ecode2 = 0 ;
12344 int res3 ;
12345 Py_ssize_t size3 = 0 ;
12346 void *buf3 = 0 ;
12347 PyObject * obj0 = 0 ;
12348 PyObject * obj1 = 0 ;
12349 PyObject * obj2 = 0 ;
12350
12351 if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12352 ecode1 = SWIG_AsVal_int(obj0, &val1);
12353 if (!SWIG_IsOK(ecode1)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12355 }
12356 arg1 = (PLINT)(val1);
12357 ecode2 = SWIG_AsVal_int(obj1, &val2);
12358 if (!SWIG_IsOK(ecode2)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12360 }
12361 arg2 = (PLINT)(val2);
12362 {
12363 res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12364 if (res3<0) {
12365 PyErr_Clear();
12366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12367 }
12368 arg3 = (void *) buf3;
12369 }
12370 plsmema(arg1,arg2,arg3);
12371 resultobj = SWIG_Py_Void();
12372 return resultobj;
12373 fail:
12374 return NULL;
12375 }
12376
12377
12378 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12379 PyObject *resultobj = 0;
12380 PLFLT arg1 ;
12381 PLFLT arg2 ;
12382 double val1 ;
12383 int ecode1 = 0 ;
12384 double val2 ;
12385 int ecode2 = 0 ;
12386 PyObject * obj0 = 0 ;
12387 PyObject * obj1 = 0 ;
12388
12389 if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12390 ecode1 = SWIG_AsVal_double(obj0, &val1);
12391 if (!SWIG_IsOK(ecode1)) {
12392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12393 }
12394 arg1 = (PLFLT)(val1);
12395 ecode2 = SWIG_AsVal_double(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12398 }
12399 arg2 = (PLFLT)(val2);
12400 plsmin(arg1,arg2);
12401 resultobj = SWIG_Py_Void();
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409 PyObject *resultobj = 0;
12410 PLINT arg1 ;
12411 int val1 ;
12412 int ecode1 = 0 ;
12413 PyObject * obj0 = 0 ;
12414
12415 if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12416 ecode1 = SWIG_AsVal_int(obj0, &val1);
12417 if (!SWIG_IsOK(ecode1)) {
12418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12419 }
12420 arg1 = (PLINT)(val1);
12421 plsori(arg1);
12422 resultobj = SWIG_Py_Void();
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430 PyObject *resultobj = 0;
12431 PLFLT arg1 ;
12432 PLFLT arg2 ;
12433 PLINT arg3 ;
12434 PLINT arg4 ;
12435 PLINT arg5 ;
12436 PLINT arg6 ;
12437 double val1 ;
12438 int ecode1 = 0 ;
12439 double val2 ;
12440 int ecode2 = 0 ;
12441 int val3 ;
12442 int ecode3 = 0 ;
12443 int val4 ;
12444 int ecode4 = 0 ;
12445 int val5 ;
12446 int ecode5 = 0 ;
12447 int val6 ;
12448 int ecode6 = 0 ;
12449 PyObject * obj0 = 0 ;
12450 PyObject * obj1 = 0 ;
12451 PyObject * obj2 = 0 ;
12452 PyObject * obj3 = 0 ;
12453 PyObject * obj4 = 0 ;
12454 PyObject * obj5 = 0 ;
12455
12456 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12457 ecode1 = SWIG_AsVal_double(obj0, &val1);
12458 if (!SWIG_IsOK(ecode1)) {
12459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12460 }
12461 arg1 = (PLFLT)(val1);
12462 ecode2 = SWIG_AsVal_double(obj1, &val2);
12463 if (!SWIG_IsOK(ecode2)) {
12464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12465 }
12466 arg2 = (PLFLT)(val2);
12467 ecode3 = SWIG_AsVal_int(obj2, &val3);
12468 if (!SWIG_IsOK(ecode3)) {
12469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12470 }
12471 arg3 = (PLINT)(val3);
12472 ecode4 = SWIG_AsVal_int(obj3, &val4);
12473 if (!SWIG_IsOK(ecode4)) {
12474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12475 }
12476 arg4 = (PLINT)(val4);
12477 ecode5 = SWIG_AsVal_int(obj4, &val5);
12478 if (!SWIG_IsOK(ecode5)) {
12479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12480 }
12481 arg5 = (PLINT)(val5);
12482 ecode6 = SWIG_AsVal_int(obj5, &val6);
12483 if (!SWIG_IsOK(ecode6)) {
12484 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12485 }
12486 arg6 = (PLINT)(val6);
12487 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12488 resultobj = SWIG_Py_Void();
12489 return resultobj;
12490 fail:
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 PyObject *resultobj = 0;
12497 char *arg1 = (char *) 0 ;
12498 int res1 ;
12499 char *buf1 = 0 ;
12500 int alloc1 = 0 ;
12501 PyObject * obj0 = 0 ;
12502
12503 if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12504 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12505 if (!SWIG_IsOK(res1)) {
12506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12507 }
12508 arg1 = (char *)(buf1);
12509 plspal0((char const *)arg1);
12510 resultobj = SWIG_Py_Void();
12511 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12512 return resultobj;
12513 fail:
12514 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12515 return NULL;
12516 }
12517
12518
12519 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12520 PyObject *resultobj = 0;
12521 char *arg1 = (char *) 0 ;
12522 PLBOOL arg2 ;
12523 int res1 ;
12524 char *buf1 = 0 ;
12525 int alloc1 = 0 ;
12526 int val2 ;
12527 int ecode2 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530
12531 if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12532 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12533 if (!SWIG_IsOK(res1)) {
12534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12535 }
12536 arg1 = (char *)(buf1);
12537 ecode2 = SWIG_AsVal_int(obj1, &val2);
12538 if (!SWIG_IsOK(ecode2)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12540 }
12541 arg2 = (PLBOOL)(val2);
12542 plspal1((char const *)arg1,arg2);
12543 resultobj = SWIG_Py_Void();
12544 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12545 return resultobj;
12546 fail:
12547 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12548 return NULL;
12549 }
12550
12551
12552 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12553 PyObject *resultobj = 0;
12554 PLBOOL arg1 ;
12555 int val1 ;
12556 int ecode1 = 0 ;
12557 PyObject * obj0 = 0 ;
12558
12559 if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12560 ecode1 = SWIG_AsVal_int(obj0, &val1);
12561 if (!SWIG_IsOK(ecode1)) {
12562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12563 }
12564 arg1 = (PLBOOL)(val1);
12565 plspause(arg1);
12566 resultobj = SWIG_Py_Void();
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 PyObject *resultobj = 0;
12575 PLINT arg1 ;
12576 int val1 ;
12577 int ecode1 = 0 ;
12578 PyObject * obj0 = 0 ;
12579
12580 if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12581 ecode1 = SWIG_AsVal_int(obj0, &val1);
12582 if (!SWIG_IsOK(ecode1)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12584 }
12585 arg1 = (PLINT)(val1);
12586 plsstrm(arg1);
12587 resultobj = SWIG_Py_Void();
12588 return resultobj;
12589 fail:
12590 return NULL;
12591 }
12592
12593
12594 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12595 PyObject *resultobj = 0;
12596 PLINT arg1 ;
12597 PLINT arg2 ;
12598 int val1 ;
12599 int ecode1 = 0 ;
12600 int val2 ;
12601 int ecode2 = 0 ;
12602 PyObject * obj0 = 0 ;
12603 PyObject * obj1 = 0 ;
12604
12605 if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12606 ecode1 = SWIG_AsVal_int(obj0, &val1);
12607 if (!SWIG_IsOK(ecode1)) {
12608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12609 }
12610 arg1 = (PLINT)(val1);
12611 ecode2 = SWIG_AsVal_int(obj1, &val2);
12612 if (!SWIG_IsOK(ecode2)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12614 }
12615 arg2 = (PLINT)(val2);
12616 plssub(arg1,arg2);
12617 resultobj = SWIG_Py_Void();
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625 PyObject *resultobj = 0;
12626 PLFLT arg1 ;
12627 PLFLT arg2 ;
12628 double val1 ;
12629 int ecode1 = 0 ;
12630 double val2 ;
12631 int ecode2 = 0 ;
12632 PyObject * obj0 = 0 ;
12633 PyObject * obj1 = 0 ;
12634
12635 if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12636 ecode1 = SWIG_AsVal_double(obj0, &val1);
12637 if (!SWIG_IsOK(ecode1)) {
12638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12639 }
12640 arg1 = (PLFLT)(val1);
12641 ecode2 = SWIG_AsVal_double(obj1, &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12644 }
12645 arg2 = (PLFLT)(val2);
12646 plssym(arg1,arg2);
12647 resultobj = SWIG_Py_Void();
12648 return resultobj;
12649 fail:
12650 return NULL;
12651 }
12652
12653
12654 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12655 PyObject *resultobj = 0;
12656 PLINT arg1 ;
12657 PLINT arg2 ;
12658 int val1 ;
12659 int ecode1 = 0 ;
12660 int val2 ;
12661 int ecode2 = 0 ;
12662 PyObject * obj0 = 0 ;
12663 PyObject * obj1 = 0 ;
12664
12665 if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12666 ecode1 = SWIG_AsVal_int(obj0, &val1);
12667 if (!SWIG_IsOK(ecode1)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12669 }
12670 arg1 = (PLINT)(val1);
12671 ecode2 = SWIG_AsVal_int(obj1, &val2);
12672 if (!SWIG_IsOK(ecode2)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12674 }
12675 arg2 = (PLINT)(val2);
12676 plstar(arg1,arg2);
12677 resultobj = SWIG_Py_Void();
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 char *arg1 = (char *) 0 ;
12687 PLINT arg2 ;
12688 PLINT arg3 ;
12689 int res1 ;
12690 char *buf1 = 0 ;
12691 int alloc1 = 0 ;
12692 int val2 ;
12693 int ecode2 = 0 ;
12694 int val3 ;
12695 int ecode3 = 0 ;
12696 PyObject * obj0 = 0 ;
12697 PyObject * obj1 = 0 ;
12698 PyObject * obj2 = 0 ;
12699
12700 if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12701 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12702 if (!SWIG_IsOK(res1)) {
12703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12704 }
12705 arg1 = (char *)(buf1);
12706 ecode2 = SWIG_AsVal_int(obj1, &val2);
12707 if (!SWIG_IsOK(ecode2)) {
12708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12709 }
12710 arg2 = (PLINT)(val2);
12711 ecode3 = SWIG_AsVal_int(obj2, &val3);
12712 if (!SWIG_IsOK(ecode3)) {
12713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12714 }
12715 arg3 = (PLINT)(val3);
12716 plstart((char const *)arg1,arg2,arg3);
12717 resultobj = SWIG_Py_Void();
12718 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12719 return resultobj;
12720 fail:
12721 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727 PyObject *resultobj = 0;
12728 ct_func arg1 = (ct_func) 0 ;
12729 PLPointer arg2 = (PLPointer) 0 ;
12730 int res2 ;
12731 PyObject * obj0 = 0 ;
12732 PyObject * obj1 = 0 ;
12733
12734 {
12735 python_ct = 0;
12736 arg1 = NULL;
12737 }
12738 if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12739 if (obj0) {
12740 {
12741 if ( python_ct )
12742 cleanup_ct();
12743 // it must be a callable or none
12744 if ( obj0 == Py_None )
12745 {
12746 arg1 = NULL;
12747 }
12748 else
12749 {
12750 if ( !PyCallable_Check( (PyObject *) obj0 ) )
12751 {
12752 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12753 return NULL;
12754 }
12755 arg1 = marshal_ct( obj0 );
12756 }
12757 }
12758 }
12759 if (obj1) {
12760 res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12761 if (!SWIG_IsOK(res2)) {
12762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12763 }
12764 }
12765 plstransform(arg1,arg2);
12766 resultobj = SWIG_Py_Void();
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774 PyObject *resultobj = 0;
12775 PLINT arg1 ;
12776 PLFLT *arg2 = (PLFLT *) 0 ;
12777 PLFLT *arg3 = (PLFLT *) 0 ;
12778 char *arg4 = (char *) 0 ;
12779 PyArrayObject *tmp1 = NULL ;
12780 PyArrayObject *tmp3 = NULL ;
12781 int res4 ;
12782 char *buf4 = 0 ;
12783 int alloc4 = 0 ;
12784 PyObject * obj0 = 0 ;
12785 PyObject * obj1 = 0 ;
12786 PyObject * obj2 = 0 ;
12787
12788 if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12789 {
12790 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12791 if ( tmp1 == NULL )
12792 return NULL;
12793 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12794 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12795 }
12796 {
12797 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12798 if ( tmp3 == NULL )
12799 return NULL;
12800 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12801 {
12802 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12803 return NULL;
12804 }
12805 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12806 }
12807 res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12808 if (!SWIG_IsOK(res4)) {
12809 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12810 }
12811 arg4 = (char *)(buf4);
12812 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12813 resultobj = SWIG_Py_Void();
12814 {
12815 Py_CLEAR( tmp1 );
12816 }
12817 {
12818 Py_CLEAR( tmp3 );
12819 }
12820 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12821 return resultobj;
12822 fail:
12823 {
12824 Py_CLEAR( tmp1 );
12825 }
12826 {
12827 Py_CLEAR( tmp3 );
12828 }
12829 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 PyObject *resultobj = 0;
12836 PLINT arg1 ;
12837 PLFLT *arg2 = (PLFLT *) 0 ;
12838 PLFLT *arg3 = (PLFLT *) 0 ;
12839 PLFLT *arg4 = (PLFLT *) 0 ;
12840 char *arg5 = (char *) 0 ;
12841 PyArrayObject *tmp1 = NULL ;
12842 PyArrayObject *tmp3 = NULL ;
12843 PyArrayObject *tmp4 = NULL ;
12844 int res5 ;
12845 char *buf5 = 0 ;
12846 int alloc5 = 0 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 PyObject * obj3 = 0 ;
12851
12852 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12853 {
12854 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12855 if ( tmp1 == NULL )
12856 return NULL;
12857 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12858 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12859 }
12860 {
12861 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12862 if ( tmp3 == NULL )
12863 return NULL;
12864 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12865 {
12866 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12867 return NULL;
12868 }
12869 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12870 }
12871 {
12872 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12873 if ( tmp4 == NULL )
12874 return NULL;
12875 if ( PyArray_DIMS( tmp4 )[0] != Alen )
12876 {
12877 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12878 return NULL;
12879 }
12880 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12881 }
12882 res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12883 if (!SWIG_IsOK(res5)) {
12884 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12885 }
12886 arg5 = (char *)(buf5);
12887 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12888 resultobj = SWIG_Py_Void();
12889 {
12890 Py_CLEAR( tmp1 );
12891 }
12892 {
12893 Py_CLEAR( tmp3 );
12894 }
12895 {
12896 Py_CLEAR( tmp4 );
12897 }
12898 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12899 return resultobj;
12900 fail:
12901 {
12902 Py_CLEAR( tmp1 );
12903 }
12904 {
12905 Py_CLEAR( tmp3 );
12906 }
12907 {
12908 Py_CLEAR( tmp4 );
12909 }
12910 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12911 return NULL;
12912 }
12913
12914
12915 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 PyObject *resultobj = 0;
12917 PLINT arg1 ;
12918 PLINT arg2 ;
12919 PLFLT arg3 ;
12920 PLFLT arg4 ;
12921 int val1 ;
12922 int ecode1 = 0 ;
12923 int val2 ;
12924 int ecode2 = 0 ;
12925 double val3 ;
12926 int ecode3 = 0 ;
12927 double val4 ;
12928 int ecode4 = 0 ;
12929 PyObject * obj0 = 0 ;
12930 PyObject * obj1 = 0 ;
12931 PyObject * obj2 = 0 ;
12932 PyObject * obj3 = 0 ;
12933
12934 if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12935 ecode1 = SWIG_AsVal_int(obj0, &val1);
12936 if (!SWIG_IsOK(ecode1)) {
12937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12938 }
12939 arg1 = (PLINT)(val1);
12940 ecode2 = SWIG_AsVal_int(obj1, &val2);
12941 if (!SWIG_IsOK(ecode2)) {
12942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12943 }
12944 arg2 = (PLINT)(val2);
12945 ecode3 = SWIG_AsVal_double(obj2, &val3);
12946 if (!SWIG_IsOK(ecode3)) {
12947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12948 }
12949 arg3 = (PLFLT)(val3);
12950 ecode4 = SWIG_AsVal_double(obj3, &val4);
12951 if (!SWIG_IsOK(ecode4)) {
12952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12953 }
12954 arg4 = (PLFLT)(val4);
12955 plstripa(arg1,arg2,arg3,arg4);
12956 resultobj = SWIG_Py_Void();
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 PyObject *resultobj = 0;
12965 PLINT *arg1 = (PLINT *) 0 ;
12966 char *arg2 = (char *) 0 ;
12967 char *arg3 = (char *) 0 ;
12968 PLFLT arg4 ;
12969 PLFLT arg5 ;
12970 PLFLT arg6 ;
12971 PLFLT arg7 ;
12972 PLFLT arg8 ;
12973 PLFLT arg9 ;
12974 PLFLT arg10 ;
12975 PLBOOL arg11 ;
12976 PLBOOL arg12 ;
12977 PLINT arg13 ;
12978 PLINT arg14 ;
12979 PLINT *arg15 = (PLINT *) 0 ;
12980 PLINT *arg16 = (PLINT *) 0 ;
12981 char **arg17 ;
12982 char *arg18 = (char *) 0 ;
12983 char *arg19 = (char *) 0 ;
12984 char *arg20 = (char *) 0 ;
12985 PLINT temp1 ;
12986 int res1 = SWIG_TMPOBJ ;
12987 int res2 ;
12988 char *buf2 = 0 ;
12989 int alloc2 = 0 ;
12990 int res3 ;
12991 char *buf3 = 0 ;
12992 int alloc3 = 0 ;
12993 double val4 ;
12994 int ecode4 = 0 ;
12995 double val5 ;
12996 int ecode5 = 0 ;
12997 double val6 ;
12998 int ecode6 = 0 ;
12999 double val7 ;
13000 int ecode7 = 0 ;
13001 double val8 ;
13002 int ecode8 = 0 ;
13003 double val9 ;
13004 int ecode9 = 0 ;
13005 double val10 ;
13006 int ecode10 = 0 ;
13007 int val11 ;
13008 int ecode11 = 0 ;
13009 int val12 ;
13010 int ecode12 = 0 ;
13011 int val13 ;
13012 int ecode13 = 0 ;
13013 int val14 ;
13014 int ecode14 = 0 ;
13015 PyArrayObject *tmp15 = NULL ;
13016 PyArrayObject *tmp16 = NULL ;
13017 char **tmp17 = NULL ;
13018 int res18 ;
13019 char *buf18 = 0 ;
13020 int alloc18 = 0 ;
13021 int res19 ;
13022 char *buf19 = 0 ;
13023 int alloc19 = 0 ;
13024 int res20 ;
13025 char *buf20 = 0 ;
13026 int alloc20 = 0 ;
13027 PyObject * obj0 = 0 ;
13028 PyObject * obj1 = 0 ;
13029 PyObject * obj2 = 0 ;
13030 PyObject * obj3 = 0 ;
13031 PyObject * obj4 = 0 ;
13032 PyObject * obj5 = 0 ;
13033 PyObject * obj6 = 0 ;
13034 PyObject * obj7 = 0 ;
13035 PyObject * obj8 = 0 ;
13036 PyObject * obj9 = 0 ;
13037 PyObject * obj10 = 0 ;
13038 PyObject * obj11 = 0 ;
13039 PyObject * obj12 = 0 ;
13040 PyObject * obj13 = 0 ;
13041 PyObject * obj14 = 0 ;
13042 PyObject * obj15 = 0 ;
13043 PyObject * obj16 = 0 ;
13044 PyObject * obj17 = 0 ;
13045 PyObject * obj18 = 0 ;
13046
13047 arg1 = &temp1;
13048 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;
13049 res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13050 if (!SWIG_IsOK(res2)) {
13051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13052 }
13053 arg2 = (char *)(buf2);
13054 res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13055 if (!SWIG_IsOK(res3)) {
13056 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13057 }
13058 arg3 = (char *)(buf3);
13059 ecode4 = SWIG_AsVal_double(obj2, &val4);
13060 if (!SWIG_IsOK(ecode4)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13062 }
13063 arg4 = (PLFLT)(val4);
13064 ecode5 = SWIG_AsVal_double(obj3, &val5);
13065 if (!SWIG_IsOK(ecode5)) {
13066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13067 }
13068 arg5 = (PLFLT)(val5);
13069 ecode6 = SWIG_AsVal_double(obj4, &val6);
13070 if (!SWIG_IsOK(ecode6)) {
13071 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13072 }
13073 arg6 = (PLFLT)(val6);
13074 ecode7 = SWIG_AsVal_double(obj5, &val7);
13075 if (!SWIG_IsOK(ecode7)) {
13076 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13077 }
13078 arg7 = (PLFLT)(val7);
13079 ecode8 = SWIG_AsVal_double(obj6, &val8);
13080 if (!SWIG_IsOK(ecode8)) {
13081 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13082 }
13083 arg8 = (PLFLT)(val8);
13084 ecode9 = SWIG_AsVal_double(obj7, &val9);
13085 if (!SWIG_IsOK(ecode9)) {
13086 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13087 }
13088 arg9 = (PLFLT)(val9);
13089 ecode10 = SWIG_AsVal_double(obj8, &val10);
13090 if (!SWIG_IsOK(ecode10)) {
13091 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13092 }
13093 arg10 = (PLFLT)(val10);
13094 ecode11 = SWIG_AsVal_int(obj9, &val11);
13095 if (!SWIG_IsOK(ecode11)) {
13096 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13097 }
13098 arg11 = (PLBOOL)(val11);
13099 ecode12 = SWIG_AsVal_int(obj10, &val12);
13100 if (!SWIG_IsOK(ecode12)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13102 }
13103 arg12 = (PLBOOL)(val12);
13104 ecode13 = SWIG_AsVal_int(obj11, &val13);
13105 if (!SWIG_IsOK(ecode13)) {
13106 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13107 }
13108 arg13 = (PLINT)(val13);
13109 ecode14 = SWIG_AsVal_int(obj12, &val14);
13110 if (!SWIG_IsOK(ecode14)) {
13111 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13112 }
13113 arg14 = (PLINT)(val14);
13114 {
13115 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13116 if ( tmp15 == NULL )
13117 return NULL;
13118 Alen = PyArray_DIMS( tmp15 )[0];
13119 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13120 }
13121 {
13122 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13123 if ( tmp16 == NULL )
13124 return NULL;
13125 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13126 {
13127 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13128 return NULL;
13129 }
13130 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13131 }
13132 {
13133 int i;
13134 if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13135 {
13136 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13137 return NULL;
13138 }
13139 if ( Alen != 4 )
13140 {
13141 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13142 return NULL;
13143 }
13144 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13145 if ( tmp17 == NULL )
13146 return NULL;
13147 arg17 = tmp17;
13148 for ( i = 0; i < 4; i++ )
13149 {
13150 arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13151 if ( arg17[i] == NULL )
13152 {
13153 free( tmp17 );
13154 return NULL;
13155 }
13156 }
13157 }
13158 res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13159 if (!SWIG_IsOK(res18)) {
13160 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13161 }
13162 arg18 = (char *)(buf18);
13163 res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13164 if (!SWIG_IsOK(res19)) {
13165 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13166 }
13167 arg19 = (char *)(buf19);
13168 res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13169 if (!SWIG_IsOK(res20)) {
13170 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13171 }
13172 arg20 = (char *)(buf20);
13173 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);
13174 resultobj = SWIG_Py_Void();
13175 if (SWIG_IsTmpObj(res1)) {
13176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13177 } else {
13178 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13180 }
13181 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13182 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13183 {
13184 Py_CLEAR( tmp15 );
13185 }
13186 {
13187 Py_CLEAR( tmp16 );
13188 }
13189 {
13190 free( tmp17 );
13191 }
13192 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13193 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13194 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13195 return resultobj;
13196 fail:
13197 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13198 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13199 {
13200 Py_CLEAR( tmp15 );
13201 }
13202 {
13203 Py_CLEAR( tmp16 );
13204 }
13205 {
13206 free( tmp17 );
13207 }
13208 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13209 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13210 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13211 return NULL;
13212 }
13213
13214
13215 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13216 PyObject *resultobj = 0;
13217 PLINT arg1 ;
13218 int val1 ;
13219 int ecode1 = 0 ;
13220 PyObject * obj0 = 0 ;
13221
13222 if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13223 ecode1 = SWIG_AsVal_int(obj0, &val1);
13224 if (!SWIG_IsOK(ecode1)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13226 }
13227 arg1 = (PLINT)(val1);
13228 plstripd(arg1);
13229 resultobj = SWIG_Py_Void();
13230 return resultobj;
13231 fail:
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13237 PyObject *resultobj = 0;
13238 PLINT arg1 ;
13239 PLINT *arg2 = (PLINT *) 0 ;
13240 PLINT *arg3 = (PLINT *) 0 ;
13241 PyArrayObject *tmp1 = NULL ;
13242 PyArrayObject *tmp3 = NULL ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245
13246 if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13247 {
13248 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13249 if ( tmp1 == NULL )
13250 return NULL;
13251 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13252 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13253 }
13254 {
13255 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13256 if ( tmp3 == NULL )
13257 return NULL;
13258 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13259 {
13260 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13261 return NULL;
13262 }
13263 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13264 }
13265 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13266 resultobj = SWIG_Py_Void();
13267 {
13268 Py_CLEAR( tmp1 );
13269 }
13270 {
13271 Py_CLEAR( tmp3 );
13272 }
13273 return resultobj;
13274 fail:
13275 {
13276 Py_CLEAR( tmp1 );
13277 }
13278 {
13279 Py_CLEAR( tmp3 );
13280 }
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13286 PyObject *resultobj = 0;
13287 PLFLT *arg1 = (PLFLT *) 0 ;
13288 PLFLT *arg2 = (PLFLT *) 0 ;
13289 PLINT arg3 ;
13290 PLBOOL arg4 ;
13291 PyArrayObject *tmp1 = NULL ;
13292 PyArrayObject *tmp2 = NULL ;
13293 int val4 ;
13294 int ecode4 = 0 ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13298
13299 if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13300 {
13301 if ( obj0 != Py_None )
13302 {
13303 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13304 if ( tmp1 == NULL )
13305 return NULL;
13306 Alen = PyArray_DIMS( tmp1 )[0];
13307 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13308 }
13309 else
13310 {
13311 arg1 = NULL;
13312 Alen = 0;
13313 }
13314 }
13315 {
13316 if ( obj1 != Py_None )
13317 {
13318 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13319 if ( tmp2 == NULL )
13320 return NULL;
13321 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13322 {
13323 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13324 return NULL;
13325 }
13326 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13327 arg3 = PyArray_DIMS( tmp2 )[0];
13328 }
13329 else
13330 {
13331 arg2 = NULL;
13332 arg3 = 0;
13333 }
13334 }
13335 ecode4 = SWIG_AsVal_int(obj2, &val4);
13336 if (!SWIG_IsOK(ecode4)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13338 }
13339 arg4 = (PLBOOL)(val4);
13340 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13341 resultobj = SWIG_Py_Void();
13342 {
13343 Py_CLEAR( tmp1 );
13344 }
13345 {
13346 Py_CLEAR( tmp2 );
13347 }
13348 return resultobj;
13349 fail:
13350 {
13351 Py_CLEAR( tmp1 );
13352 }
13353 {
13354 Py_CLEAR( tmp2 );
13355 }
13356 return NULL;
13357 }
13358
13359
13360 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13361 PyObject *resultobj = 0;
13362 PLFLT arg1 ;
13363 PLFLT arg2 ;
13364 PLFLT arg3 ;
13365 PLFLT arg4 ;
13366 double val1 ;
13367 int ecode1 = 0 ;
13368 double val2 ;
13369 int ecode2 = 0 ;
13370 double val3 ;
13371 int ecode3 = 0 ;
13372 double val4 ;
13373 int ecode4 = 0 ;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 PyObject * obj2 = 0 ;
13377 PyObject * obj3 = 0 ;
13378
13379 if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13380 ecode1 = SWIG_AsVal_double(obj0, &val1);
13381 if (!SWIG_IsOK(ecode1)) {
13382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13383 }
13384 arg1 = (PLFLT)(val1);
13385 ecode2 = SWIG_AsVal_double(obj1, &val2);
13386 if (!SWIG_IsOK(ecode2)) {
13387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13388 }
13389 arg2 = (PLFLT)(val2);
13390 ecode3 = SWIG_AsVal_double(obj2, &val3);
13391 if (!SWIG_IsOK(ecode3)) {
13392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13393 }
13394 arg3 = (PLFLT)(val3);
13395 ecode4 = SWIG_AsVal_double(obj3, &val4);
13396 if (!SWIG_IsOK(ecode4)) {
13397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13398 }
13399 arg4 = (PLFLT)(val4);
13400 plsvpa(arg1,arg2,arg3,arg4);
13401 resultobj = SWIG_Py_Void();
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409 PyObject *resultobj = 0;
13410 PLINT arg1 ;
13411 PLINT arg2 ;
13412 int val1 ;
13413 int ecode1 = 0 ;
13414 int val2 ;
13415 int ecode2 = 0 ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418
13419 if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13420 ecode1 = SWIG_AsVal_int(obj0, &val1);
13421 if (!SWIG_IsOK(ecode1)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13423 }
13424 arg1 = (PLINT)(val1);
13425 ecode2 = SWIG_AsVal_int(obj1, &val2);
13426 if (!SWIG_IsOK(ecode2)) {
13427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13428 }
13429 arg2 = (PLINT)(val2);
13430 plsxax(arg1,arg2);
13431 resultobj = SWIG_Py_Void();
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 PLINT arg1 ;
13441 PLINT arg2 ;
13442 int val1 ;
13443 int ecode1 = 0 ;
13444 int val2 ;
13445 int ecode2 = 0 ;
13446 PyObject * obj0 = 0 ;
13447 PyObject * obj1 = 0 ;
13448
13449 if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13450 ecode1 = SWIG_AsVal_int(obj0, &val1);
13451 if (!SWIG_IsOK(ecode1)) {
13452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13453 }
13454 arg1 = (PLINT)(val1);
13455 ecode2 = SWIG_AsVal_int(obj1, &val2);
13456 if (!SWIG_IsOK(ecode2)) {
13457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13458 }
13459 arg2 = (PLINT)(val2);
13460 plsyax(arg1,arg2);
13461 resultobj = SWIG_Py_Void();
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469 PyObject *resultobj = 0;
13470 PLINT arg1 ;
13471 PLFLT *arg2 = (PLFLT *) 0 ;
13472 PLFLT *arg3 = (PLFLT *) 0 ;
13473 PLINT arg4 ;
13474 PyArrayObject *tmp1 = NULL ;
13475 PyArrayObject *tmp3 = NULL ;
13476 int val4 ;
13477 int ecode4 = 0 ;
13478 PyObject * obj0 = 0 ;
13479 PyObject * obj1 = 0 ;
13480 PyObject * obj2 = 0 ;
13481
13482 if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13483 {
13484 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13485 if ( tmp1 == NULL )
13486 return NULL;
13487 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13488 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13489 }
13490 {
13491 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13492 if ( tmp3 == NULL )
13493 return NULL;
13494 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13495 {
13496 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13497 return NULL;
13498 }
13499 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13500 }
13501 ecode4 = SWIG_AsVal_int(obj2, &val4);
13502 if (!SWIG_IsOK(ecode4)) {
13503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13504 }
13505 arg4 = (PLINT)(val4);
13506 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13507 resultobj = SWIG_Py_Void();
13508 {
13509 Py_CLEAR( tmp1 );
13510 }
13511 {
13512 Py_CLEAR( tmp3 );
13513 }
13514 return resultobj;
13515 fail:
13516 {
13517 Py_CLEAR( tmp1 );
13518 }
13519 {
13520 Py_CLEAR( tmp3 );
13521 }
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13527 PyObject *resultobj = 0;
13528 PLINT arg1 ;
13529 PLINT arg2 ;
13530 int val1 ;
13531 int ecode1 = 0 ;
13532 int val2 ;
13533 int ecode2 = 0 ;
13534 PyObject * obj0 = 0 ;
13535 PyObject * obj1 = 0 ;
13536
13537 if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13538 ecode1 = SWIG_AsVal_int(obj0, &val1);
13539 if (!SWIG_IsOK(ecode1)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13541 }
13542 arg1 = (PLINT)(val1);
13543 ecode2 = SWIG_AsVal_int(obj1, &val2);
13544 if (!SWIG_IsOK(ecode2)) {
13545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13546 }
13547 arg2 = (PLINT)(val2);
13548 plszax(arg1,arg2);
13549 resultobj = SWIG_Py_Void();
13550 return resultobj;
13551 fail:
13552 return NULL;
13553 }
13554
13555
13556 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13557 PyObject *resultobj = 0;
13558
13559 if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13560 pltext();
13561 resultobj = SWIG_Py_Void();
13562 return resultobj;
13563 fail:
13564 return NULL;
13565 }
13566
13567
13568 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13569 PyObject *resultobj = 0;
13570 char *arg1 = (char *) 0 ;
13571 int res1 ;
13572 char *buf1 = 0 ;
13573 int alloc1 = 0 ;
13574 PyObject * obj0 = 0 ;
13575
13576 if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13577 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13578 if (!SWIG_IsOK(res1)) {
13579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13580 }
13581 arg1 = (char *)(buf1);
13582 pltimefmt((char const *)arg1);
13583 resultobj = SWIG_Py_Void();
13584 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13585 return resultobj;
13586 fail:
13587 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13588 return NULL;
13589 }
13590
13591
13592 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593 PyObject *resultobj = 0;
13594 PLFLT arg1 ;
13595 double val1 ;
13596 int ecode1 = 0 ;
13597 PyObject * obj0 = 0 ;
13598
13599 if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13600 ecode1 = SWIG_AsVal_double(obj0, &val1);
13601 if (!SWIG_IsOK(ecode1)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13603 }
13604 arg1 = (PLFLT)(val1);
13605 plvasp(arg1);
13606 resultobj = SWIG_Py_Void();
13607 return resultobj;
13608 fail:
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13614 PyObject *resultobj = 0;
13615 PLFLT **arg1 = (PLFLT **) 0 ;
13616 PLFLT **arg2 = (PLFLT **) 0 ;
13617 PLINT arg3 ;
13618 PLINT arg4 ;
13619 PLFLT arg5 ;
13620 pltr_func arg6 = (pltr_func) 0 ;
13621 PLPointer arg7 = (PLPointer) 0 ;
13622 PyArrayObject *tmp1 = NULL ;
13623 PyArrayObject *tmp2 = NULL ;
13624 double val5 ;
13625 int ecode5 = 0 ;
13626 PyObject * obj0 = 0 ;
13627 PyObject * obj1 = 0 ;
13628 PyObject * obj2 = 0 ;
13629 PyObject * obj3 = 0 ;
13630 PyObject * obj4 = 0 ;
13631
13632 {
13633 python_pltr = 0;
13634 arg6 = NULL;
13635 }
13636 {
13637 arg7 = NULL;
13638 }
13639 if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13640 {
13641 int i, size;
13642 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13643 if ( tmp1 == NULL )
13644 return NULL;
13645 Xlen = PyArray_DIMS( tmp1 )[0];
13646 Ylen = PyArray_DIMS( tmp1 )[1];
13647 size = Ylen;
13648 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13649 for ( i = 0; i < Xlen; i++ )
13650 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13651 }
13652 {
13653 int i, size;
13654 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13655 if ( tmp2 == NULL )
13656 return NULL;
13657 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13658 {
13659 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13660 return NULL;
13661 }
13662 arg3 = PyArray_DIMS( tmp2 )[0];
13663 arg4 = PyArray_DIMS( tmp2 )[1];
13664 size = arg4;
13665 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13666 for ( i = 0; i < arg3; i++ )
13667 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13668 }
13669 ecode5 = SWIG_AsVal_double(obj2, &val5);
13670 if (!SWIG_IsOK(ecode5)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13672 }
13673 arg5 = (PLFLT)(val5);
13674 if (obj3) {
13675 {
13676 // it must be a callable or None
13677 if ( obj3 == Py_None )
13678 {
13679 arg6 = NULL;
13680 }
13681 else
13682 {
13683 if ( !PyCallable_Check( (PyObject *) obj3 ) )
13684 {
13685 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13686 return NULL;
13687 }
13688 arg6 = marshal_pltr( obj3 );
13689 }
13690 }
13691 }
13692 if (obj4) {
13693 {
13694 if ( obj4 == Py_None )
13695 arg7 = NULL;
13696 else
13697 {
13698 arg7 = marshal_PLPointer( obj4, 0 );
13699 }
13700 }
13701 }
13702 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13703 resultobj = SWIG_Py_Void();
13704 {
13705 Py_CLEAR( tmp1 );
13706 free( arg1 );
13707 }
13708 {
13709 Py_CLEAR( tmp2 );
13710 free( arg2 );
13711 }
13712 {
13713 cleanup_pltr();
13714 }
13715 {
13716 cleanup_PLPointer();
13717 }
13718 return resultobj;
13719 fail:
13720 {
13721 Py_CLEAR( tmp1 );
13722 free( arg1 );
13723 }
13724 {
13725 Py_CLEAR( tmp2 );
13726 free( arg2 );
13727 }
13728 {
13729 cleanup_pltr();
13730 }
13731 {
13732 cleanup_PLPointer();
13733 }
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13739 PyObject *resultobj = 0;
13740 PLFLT arg1 ;
13741 PLFLT arg2 ;
13742 PLFLT arg3 ;
13743 PLFLT arg4 ;
13744 PLFLT arg5 ;
13745 double val1 ;
13746 int ecode1 = 0 ;
13747 double val2 ;
13748 int ecode2 = 0 ;
13749 double val3 ;
13750 int ecode3 = 0 ;
13751 double val4 ;
13752 int ecode4 = 0 ;
13753 double val5 ;
13754 int ecode5 = 0 ;
13755 PyObject * obj0 = 0 ;
13756 PyObject * obj1 = 0 ;
13757 PyObject * obj2 = 0 ;
13758 PyObject * obj3 = 0 ;
13759 PyObject * obj4 = 0 ;
13760
13761 if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13762 ecode1 = SWIG_AsVal_double(obj0, &val1);
13763 if (!SWIG_IsOK(ecode1)) {
13764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13765 }
13766 arg1 = (PLFLT)(val1);
13767 ecode2 = SWIG_AsVal_double(obj1, &val2);
13768 if (!SWIG_IsOK(ecode2)) {
13769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13770 }
13771 arg2 = (PLFLT)(val2);
13772 ecode3 = SWIG_AsVal_double(obj2, &val3);
13773 if (!SWIG_IsOK(ecode3)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13775 }
13776 arg3 = (PLFLT)(val3);
13777 ecode4 = SWIG_AsVal_double(obj3, &val4);
13778 if (!SWIG_IsOK(ecode4)) {
13779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13780 }
13781 arg4 = (PLFLT)(val4);
13782 ecode5 = SWIG_AsVal_double(obj4, &val5);
13783 if (!SWIG_IsOK(ecode5)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13785 }
13786 arg5 = (PLFLT)(val5);
13787 plvpas(arg1,arg2,arg3,arg4,arg5);
13788 resultobj = SWIG_Py_Void();
13789 return resultobj;
13790 fail:
13791 return NULL;
13792 }
13793
13794
13795 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13796 PyObject *resultobj = 0;
13797 PLFLT arg1 ;
13798 PLFLT arg2 ;
13799 PLFLT arg3 ;
13800 PLFLT arg4 ;
13801 double val1 ;
13802 int ecode1 = 0 ;
13803 double val2 ;
13804 int ecode2 = 0 ;
13805 double val3 ;
13806 int ecode3 = 0 ;
13807 double val4 ;
13808 int ecode4 = 0 ;
13809 PyObject * obj0 = 0 ;
13810 PyObject * obj1 = 0 ;
13811 PyObject * obj2 = 0 ;
13812 PyObject * obj3 = 0 ;
13813
13814 if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13815 ecode1 = SWIG_AsVal_double(obj0, &val1);
13816 if (!SWIG_IsOK(ecode1)) {
13817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13818 }
13819 arg1 = (PLFLT)(val1);
13820 ecode2 = SWIG_AsVal_double(obj1, &val2);
13821 if (!SWIG_IsOK(ecode2)) {
13822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13823 }
13824 arg2 = (PLFLT)(val2);
13825 ecode3 = SWIG_AsVal_double(obj2, &val3);
13826 if (!SWIG_IsOK(ecode3)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13828 }
13829 arg3 = (PLFLT)(val3);
13830 ecode4 = SWIG_AsVal_double(obj3, &val4);
13831 if (!SWIG_IsOK(ecode4)) {
13832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13833 }
13834 arg4 = (PLFLT)(val4);
13835 plvpor(arg1,arg2,arg3,arg4);
13836 resultobj = SWIG_Py_Void();
13837 return resultobj;
13838 fail:
13839 return NULL;
13840 }
13841
13842
13843 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13844 PyObject *resultobj = 0;
13845
13846 if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13847 plvsta();
13848 resultobj = SWIG_Py_Void();
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13856 PyObject *resultobj = 0;
13857 PLFLT arg1 ;
13858 PLFLT arg2 ;
13859 PLFLT arg3 ;
13860 PLFLT arg4 ;
13861 PLFLT arg5 ;
13862 PLFLT arg6 ;
13863 PLFLT arg7 ;
13864 PLFLT arg8 ;
13865 PLFLT arg9 ;
13866 PLFLT arg10 ;
13867 PLFLT arg11 ;
13868 double val1 ;
13869 int ecode1 = 0 ;
13870 double val2 ;
13871 int ecode2 = 0 ;
13872 double val3 ;
13873 int ecode3 = 0 ;
13874 double val4 ;
13875 int ecode4 = 0 ;
13876 double val5 ;
13877 int ecode5 = 0 ;
13878 double val6 ;
13879 int ecode6 = 0 ;
13880 double val7 ;
13881 int ecode7 = 0 ;
13882 double val8 ;
13883 int ecode8 = 0 ;
13884 double val9 ;
13885 int ecode9 = 0 ;
13886 double val10 ;
13887 int ecode10 = 0 ;
13888 double val11 ;
13889 int ecode11 = 0 ;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 PyObject * obj2 = 0 ;
13893 PyObject * obj3 = 0 ;
13894 PyObject * obj4 = 0 ;
13895 PyObject * obj5 = 0 ;
13896 PyObject * obj6 = 0 ;
13897 PyObject * obj7 = 0 ;
13898 PyObject * obj8 = 0 ;
13899 PyObject * obj9 = 0 ;
13900 PyObject * obj10 = 0 ;
13901
13902 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13903 ecode1 = SWIG_AsVal_double(obj0, &val1);
13904 if (!SWIG_IsOK(ecode1)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13906 }
13907 arg1 = (PLFLT)(val1);
13908 ecode2 = SWIG_AsVal_double(obj1, &val2);
13909 if (!SWIG_IsOK(ecode2)) {
13910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13911 }
13912 arg2 = (PLFLT)(val2);
13913 ecode3 = SWIG_AsVal_double(obj2, &val3);
13914 if (!SWIG_IsOK(ecode3)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13916 }
13917 arg3 = (PLFLT)(val3);
13918 ecode4 = SWIG_AsVal_double(obj3, &val4);
13919 if (!SWIG_IsOK(ecode4)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13921 }
13922 arg4 = (PLFLT)(val4);
13923 ecode5 = SWIG_AsVal_double(obj4, &val5);
13924 if (!SWIG_IsOK(ecode5)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13926 }
13927 arg5 = (PLFLT)(val5);
13928 ecode6 = SWIG_AsVal_double(obj5, &val6);
13929 if (!SWIG_IsOK(ecode6)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13931 }
13932 arg6 = (PLFLT)(val6);
13933 ecode7 = SWIG_AsVal_double(obj6, &val7);
13934 if (!SWIG_IsOK(ecode7)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13936 }
13937 arg7 = (PLFLT)(val7);
13938 ecode8 = SWIG_AsVal_double(obj7, &val8);
13939 if (!SWIG_IsOK(ecode8)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13941 }
13942 arg8 = (PLFLT)(val8);
13943 ecode9 = SWIG_AsVal_double(obj8, &val9);
13944 if (!SWIG_IsOK(ecode9)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13946 }
13947 arg9 = (PLFLT)(val9);
13948 ecode10 = SWIG_AsVal_double(obj9, &val10);
13949 if (!SWIG_IsOK(ecode10)) {
13950 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13951 }
13952 arg10 = (PLFLT)(val10);
13953 ecode11 = SWIG_AsVal_double(obj10, &val11);
13954 if (!SWIG_IsOK(ecode11)) {
13955 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13956 }
13957 arg11 = (PLFLT)(val11);
13958 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13959 resultobj = SWIG_Py_Void();
13960 return resultobj;
13961 fail:
13962 return NULL;
13963 }
13964
13965
13966 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13967 PyObject *resultobj = 0;
13968 PLINT arg1 ;
13969 int val1 ;
13970 int ecode1 = 0 ;
13971 PyObject * obj0 = 0 ;
13972
13973 if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13974 ecode1 = SWIG_AsVal_int(obj0, &val1);
13975 if (!SWIG_IsOK(ecode1)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
13977 }
13978 arg1 = (PLINT)(val1);
13979 plwidth(arg1);
13980 resultobj = SWIG_Py_Void();
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 PyObject *resultobj = 0;
13989 PLFLT arg1 ;
13990 PLFLT arg2 ;
13991 PLFLT arg3 ;
13992 PLFLT arg4 ;
13993 double val1 ;
13994 int ecode1 = 0 ;
13995 double val2 ;
13996 int ecode2 = 0 ;
13997 double val3 ;
13998 int ecode3 = 0 ;
13999 double val4 ;
14000 int ecode4 = 0 ;
14001 PyObject * obj0 = 0 ;
14002 PyObject * obj1 = 0 ;
14003 PyObject * obj2 = 0 ;
14004 PyObject * obj3 = 0 ;
14005
14006 if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14007 ecode1 = SWIG_AsVal_double(obj0, &val1);
14008 if (!SWIG_IsOK(ecode1)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14010 }
14011 arg1 = (PLFLT)(val1);
14012 ecode2 = SWIG_AsVal_double(obj1, &val2);
14013 if (!SWIG_IsOK(ecode2)) {
14014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14015 }
14016 arg2 = (PLFLT)(val2);
14017 ecode3 = SWIG_AsVal_double(obj2, &val3);
14018 if (!SWIG_IsOK(ecode3)) {
14019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14020 }
14021 arg3 = (PLFLT)(val3);
14022 ecode4 = SWIG_AsVal_double(obj3, &val4);
14023 if (!SWIG_IsOK(ecode4)) {
14024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14025 }
14026 arg4 = (PLFLT)(val4);
14027 plwind(arg1,arg2,arg3,arg4);
14028 resultobj = SWIG_Py_Void();
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14036 PyObject *resultobj = 0;
14037 PLBOOL arg1 ;
14038 PLBOOL *arg2 = (PLBOOL *) 0 ;
14039 int val1 ;
14040 int ecode1 = 0 ;
14041 PLBOOL temp2 ;
14042 int res2 = SWIG_TMPOBJ ;
14043 PyObject * obj0 = 0 ;
14044
14045 arg2 = &temp2;
14046 if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14047 ecode1 = SWIG_AsVal_int(obj0, &val1);
14048 if (!SWIG_IsOK(ecode1)) {
14049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14050 }
14051 arg1 = (PLBOOL)(val1);
14052 plxormod(arg1,arg2);
14053 resultobj = SWIG_Py_Void();
14054 if (SWIG_IsTmpObj(res2)) {
14055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14056 } else {
14057 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14059 }
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14067 PyObject *resultobj = 0;
14068 mapform_func arg1 = (mapform_func) 0 ;
14069 char *arg2 = (char *) 0 ;
14070 PLFLT arg3 ;
14071 PLFLT arg4 ;
14072 PLFLT arg5 ;
14073 PLFLT arg6 ;
14074 int res2 ;
14075 char *buf2 = 0 ;
14076 int alloc2 = 0 ;
14077 double val3 ;
14078 int ecode3 = 0 ;
14079 double val4 ;
14080 int ecode4 = 0 ;
14081 double val5 ;
14082 int ecode5 = 0 ;
14083 double val6 ;
14084 int ecode6 = 0 ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 PyObject * obj3 = 0 ;
14089 PyObject * obj4 = 0 ;
14090 PyObject * obj5 = 0 ;
14091
14092 if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14093 {
14094 // it must be a callable or none
14095 if ( obj0 == Py_None )
14096 {
14097 arg1 = NULL;
14098 }
14099 else
14100 {
14101 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14102 {
14103 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14104 return NULL;
14105 }
14106 arg1 = marshal_mapform( obj0 );
14107 }
14108 }
14109 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14110 if (!SWIG_IsOK(res2)) {
14111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14112 }
14113 arg2 = (char *)(buf2);
14114 ecode3 = SWIG_AsVal_double(obj2, &val3);
14115 if (!SWIG_IsOK(ecode3)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14117 }
14118 arg3 = (PLFLT)(val3);
14119 ecode4 = SWIG_AsVal_double(obj3, &val4);
14120 if (!SWIG_IsOK(ecode4)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14122 }
14123 arg4 = (PLFLT)(val4);
14124 ecode5 = SWIG_AsVal_double(obj4, &val5);
14125 if (!SWIG_IsOK(ecode5)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14127 }
14128 arg5 = (PLFLT)(val5);
14129 ecode6 = SWIG_AsVal_double(obj5, &val6);
14130 if (!SWIG_IsOK(ecode6)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14132 }
14133 arg6 = (PLFLT)(val6);
14134 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14135 resultobj = SWIG_Py_Void();
14136 {
14137 cleanup_mapform();
14138 }
14139 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14140 return resultobj;
14141 fail:
14142 {
14143 cleanup_mapform();
14144 }
14145 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14151 PyObject *resultobj = 0;
14152 mapform_func arg1 = (mapform_func) 0 ;
14153 PLFLT arg2 ;
14154 PLFLT arg3 ;
14155 PLFLT arg4 ;
14156 PLFLT arg5 ;
14157 PLFLT arg6 ;
14158 PLFLT arg7 ;
14159 double val2 ;
14160 int ecode2 = 0 ;
14161 double val3 ;
14162 int ecode3 = 0 ;
14163 double val4 ;
14164 int ecode4 = 0 ;
14165 double val5 ;
14166 int ecode5 = 0 ;
14167 double val6 ;
14168 int ecode6 = 0 ;
14169 double val7 ;
14170 int ecode7 = 0 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 PyObject * obj3 = 0 ;
14175 PyObject * obj4 = 0 ;
14176 PyObject * obj5 = 0 ;
14177 PyObject * obj6 = 0 ;
14178
14179 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14180 {
14181 // it must be a callable or none
14182 if ( obj0 == Py_None )
14183 {
14184 arg1 = NULL;
14185 }
14186 else
14187 {
14188 if ( !PyCallable_Check( (PyObject *) obj0 ) )
14189 {
14190 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14191 return NULL;
14192 }
14193 arg1 = marshal_mapform( obj0 );
14194 }
14195 }
14196 ecode2 = SWIG_AsVal_double(obj1, &val2);
14197 if (!SWIG_IsOK(ecode2)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14199 }
14200 arg2 = (PLFLT)(val2);
14201 ecode3 = SWIG_AsVal_double(obj2, &val3);
14202 if (!SWIG_IsOK(ecode3)) {
14203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14204 }
14205 arg3 = (PLFLT)(val3);
14206 ecode4 = SWIG_AsVal_double(obj3, &val4);
14207 if (!SWIG_IsOK(ecode4)) {
14208 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14209 }
14210 arg4 = (PLFLT)(val4);
14211 ecode5 = SWIG_AsVal_double(obj4, &val5);
14212 if (!SWIG_IsOK(ecode5)) {
14213 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14214 }
14215 arg5 = (PLFLT)(val5);
14216 ecode6 = SWIG_AsVal_double(obj5, &val6);
14217 if (!SWIG_IsOK(ecode6)) {
14218 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14219 }
14220 arg6 = (PLFLT)(val6);
14221 ecode7 = SWIG_AsVal_double(obj6, &val7);
14222 if (!SWIG_IsOK(ecode7)) {
14223 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14224 }
14225 arg7 = (PLFLT)(val7);
14226 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14227 resultobj = SWIG_Py_Void();
14228 {
14229 cleanup_mapform();
14230 }
14231 return resultobj;
14232 fail:
14233 {
14234 cleanup_mapform();
14235 }
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *resultobj = 0;
14242 PLFLT **arg1 = (PLFLT **) 0 ;
14243 PLINT arg2 ;
14244 PLINT arg3 ;
14245 PLFLT arg4 ;
14246 PLFLT arg5 ;
14247 PLFLT arg6 ;
14248 PLFLT arg7 ;
14249 PLFLT arg8 ;
14250 PLFLT arg9 ;
14251 PLFLT arg10 ;
14252 PLFLT arg11 ;
14253 PLFLT arg12 ;
14254 PLFLT arg13 ;
14255 PyArrayObject *tmp1 = NULL ;
14256 double val4 ;
14257 int ecode4 = 0 ;
14258 double val5 ;
14259 int ecode5 = 0 ;
14260 double val6 ;
14261 int ecode6 = 0 ;
14262 double val7 ;
14263 int ecode7 = 0 ;
14264 double val8 ;
14265 int ecode8 = 0 ;
14266 double val9 ;
14267 int ecode9 = 0 ;
14268 double val10 ;
14269 int ecode10 = 0 ;
14270 double val11 ;
14271 int ecode11 = 0 ;
14272 double val12 ;
14273 int ecode12 = 0 ;
14274 double val13 ;
14275 int ecode13 = 0 ;
14276 PyObject * obj0 = 0 ;
14277 PyObject * obj1 = 0 ;
14278 PyObject * obj2 = 0 ;
14279 PyObject * obj3 = 0 ;
14280 PyObject * obj4 = 0 ;
14281 PyObject * obj5 = 0 ;
14282 PyObject * obj6 = 0 ;
14283 PyObject * obj7 = 0 ;
14284 PyObject * obj8 = 0 ;
14285 PyObject * obj9 = 0 ;
14286 PyObject * obj10 = 0 ;
14287
14288 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14289 {
14290 int i, size;
14291 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14292 if ( tmp1 == NULL )
14293 return NULL;
14294 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14295 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14296 size = arg3;
14297 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14298 for ( i = 0; i < arg2; i++ )
14299 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14300 }
14301 ecode4 = SWIG_AsVal_double(obj1, &val4);
14302 if (!SWIG_IsOK(ecode4)) {
14303 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14304 }
14305 arg4 = (PLFLT)(val4);
14306 ecode5 = SWIG_AsVal_double(obj2, &val5);
14307 if (!SWIG_IsOK(ecode5)) {
14308 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14309 }
14310 arg5 = (PLFLT)(val5);
14311 ecode6 = SWIG_AsVal_double(obj3, &val6);
14312 if (!SWIG_IsOK(ecode6)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14314 }
14315 arg6 = (PLFLT)(val6);
14316 ecode7 = SWIG_AsVal_double(obj4, &val7);
14317 if (!SWIG_IsOK(ecode7)) {
14318 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14319 }
14320 arg7 = (PLFLT)(val7);
14321 ecode8 = SWIG_AsVal_double(obj5, &val8);
14322 if (!SWIG_IsOK(ecode8)) {
14323 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14324 }
14325 arg8 = (PLFLT)(val8);
14326 ecode9 = SWIG_AsVal_double(obj6, &val9);
14327 if (!SWIG_IsOK(ecode9)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14329 }
14330 arg9 = (PLFLT)(val9);
14331 ecode10 = SWIG_AsVal_double(obj7, &val10);
14332 if (!SWIG_IsOK(ecode10)) {
14333 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14334 }
14335 arg10 = (PLFLT)(val10);
14336 ecode11 = SWIG_AsVal_double(obj8, &val11);
14337 if (!SWIG_IsOK(ecode11)) {
14338 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14339 }
14340 arg11 = (PLFLT)(val11);
14341 ecode12 = SWIG_AsVal_double(obj9, &val12);
14342 if (!SWIG_IsOK(ecode12)) {
14343 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14344 }
14345 arg12 = (PLFLT)(val12);
14346 ecode13 = SWIG_AsVal_double(obj10, &val13);
14347 if (!SWIG_IsOK(ecode13)) {
14348 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14349 }
14350 arg13 = (PLFLT)(val13);
14351 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14352 resultobj = SWIG_Py_Void();
14353 {
14354 Py_CLEAR( tmp1 );
14355 free( arg1 );
14356 }
14357 return resultobj;
14358 fail:
14359 {
14360 Py_CLEAR( tmp1 );
14361 free( arg1 );
14362 }
14363 return NULL;
14364 }
14365
14366
14367 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14368 PyObject *resultobj = 0;
14369 PLFLT **arg1 = (PLFLT **) 0 ;
14370 PLINT arg2 ;
14371 PLINT arg3 ;
14372 PLFLT arg4 ;
14373 PLFLT arg5 ;
14374 PLFLT arg6 ;
14375 PLFLT arg7 ;
14376 PLFLT arg8 ;
14377 PLFLT arg9 ;
14378 PLFLT arg10 ;
14379 PLFLT arg11 ;
14380 pltr_func arg12 = (pltr_func) 0 ;
14381 PLPointer arg13 = (PLPointer) 0 ;
14382 PyArrayObject *tmp1 = NULL ;
14383 double val4 ;
14384 int ecode4 = 0 ;
14385 double val5 ;
14386 int ecode5 = 0 ;
14387 double val6 ;
14388 int ecode6 = 0 ;
14389 double val7 ;
14390 int ecode7 = 0 ;
14391 double val8 ;
14392 int ecode8 = 0 ;
14393 double val9 ;
14394 int ecode9 = 0 ;
14395 double val10 ;
14396 int ecode10 = 0 ;
14397 double val11 ;
14398 int ecode11 = 0 ;
14399 PyObject * obj0 = 0 ;
14400 PyObject * obj1 = 0 ;
14401 PyObject * obj2 = 0 ;
14402 PyObject * obj3 = 0 ;
14403 PyObject * obj4 = 0 ;
14404 PyObject * obj5 = 0 ;
14405 PyObject * obj6 = 0 ;
14406 PyObject * obj7 = 0 ;
14407 PyObject * obj8 = 0 ;
14408 PyObject * obj9 = 0 ;
14409 PyObject * obj10 = 0 ;
14410
14411 {
14412 python_pltr = 0;
14413 arg12 = NULL;
14414 }
14415 {
14416 arg13 = NULL;
14417 }
14418 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14419 {
14420 int i, size;
14421 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14422 if ( tmp1 == NULL )
14423 return NULL;
14424 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14425 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14426 size = arg3;
14427 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14428 for ( i = 0; i < arg2; i++ )
14429 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14430 }
14431 ecode4 = SWIG_AsVal_double(obj1, &val4);
14432 if (!SWIG_IsOK(ecode4)) {
14433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14434 }
14435 arg4 = (PLFLT)(val4);
14436 ecode5 = SWIG_AsVal_double(obj2, &val5);
14437 if (!SWIG_IsOK(ecode5)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14439 }
14440 arg5 = (PLFLT)(val5);
14441 ecode6 = SWIG_AsVal_double(obj3, &val6);
14442 if (!SWIG_IsOK(ecode6)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14444 }
14445 arg6 = (PLFLT)(val6);
14446 ecode7 = SWIG_AsVal_double(obj4, &val7);
14447 if (!SWIG_IsOK(ecode7)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14449 }
14450 arg7 = (PLFLT)(val7);
14451 ecode8 = SWIG_AsVal_double(obj5, &val8);
14452 if (!SWIG_IsOK(ecode8)) {
14453 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14454 }
14455 arg8 = (PLFLT)(val8);
14456 ecode9 = SWIG_AsVal_double(obj6, &val9);
14457 if (!SWIG_IsOK(ecode9)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14459 }
14460 arg9 = (PLFLT)(val9);
14461 ecode10 = SWIG_AsVal_double(obj7, &val10);
14462 if (!SWIG_IsOK(ecode10)) {
14463 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14464 }
14465 arg10 = (PLFLT)(val10);
14466 ecode11 = SWIG_AsVal_double(obj8, &val11);
14467 if (!SWIG_IsOK(ecode11)) {
14468 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14469 }
14470 arg11 = (PLFLT)(val11);
14471 if (obj9) {
14472 {
14473 // it must be a callable or None
14474 if ( obj9 == Py_None )
14475 {
14476 arg12 = NULL;
14477 }
14478 else
14479 {
14480 if ( !PyCallable_Check( (PyObject *) obj9 ) )
14481 {
14482 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14483 return NULL;
14484 }
14485 arg12 = marshal_pltr( obj9 );
14486 }
14487 }
14488 }
14489 if (obj10) {
14490 {
14491 if ( obj10 == Py_None )
14492 arg13 = NULL;
14493 else
14494 {
14495 arg13 = marshal_PLPointer( obj10, 1 );
14496 }
14497 }
14498 }
14499 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14500 resultobj = SWIG_Py_Void();
14501 {
14502 Py_CLEAR( tmp1 );
14503 free( arg1 );
14504 }
14505 {
14506 cleanup_pltr();
14507 }
14508 {
14509 cleanup_PLPointer();
14510 }
14511 return resultobj;
14512 fail:
14513 {
14514 Py_CLEAR( tmp1 );
14515 free( arg1 );
14516 }
14517 {
14518 cleanup_pltr();
14519 }
14520 {
14521 cleanup_PLPointer();
14522 }
14523 return NULL;
14524 }
14525
14526
14527 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14528 PyObject *resultobj = 0;
14529
14530 if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
14531 plClearOpts();
14532 resultobj = SWIG_Py_Void();
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14540 PyObject *resultobj = 0;
14541
14542 if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
14543 plResetOpts();
14544 resultobj = SWIG_Py_Void();
14545 return resultobj;
14546 fail:
14547 return NULL;
14548 }
14549
14550
14551 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14552 PyObject *resultobj = 0;
14553 char *arg1 = (char *) 0 ;
14554 char *arg2 = (char *) 0 ;
14555 int res1 ;
14556 char *buf1 = 0 ;
14557 int alloc1 = 0 ;
14558 int res2 ;
14559 char *buf2 = 0 ;
14560 int alloc2 = 0 ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563
14564 if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
14565 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14566 if (!SWIG_IsOK(res1)) {
14567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14568 }
14569 arg1 = (char *)(buf1);
14570 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14571 if (!SWIG_IsOK(res2)) {
14572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14573 }
14574 arg2 = (char *)(buf2);
14575 plSetUsage((char const *)arg1,(char const *)arg2);
14576 resultobj = SWIG_Py_Void();
14577 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14578 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14579 return resultobj;
14580 fail:
14581 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14582 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14583 return NULL;
14584 }
14585
14586
14587 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14588 PyObject *resultobj = 0;
14589
14590 if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
14591 plOptUsage();
14592 resultobj = SWIG_Py_Void();
14593 return resultobj;
14594 fail:
14595 return NULL;
14596 }
14597
14598
14599 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14600 PyObject *resultobj = 0;
14601 PLFLT **arg1 = (PLFLT **) 0 ;
14602 PLINT arg2 ;
14603 PLINT arg3 ;
14604 PLFLT *arg4 = (PLFLT *) 0 ;
14605 PLFLT *arg5 = (PLFLT *) 0 ;
14606 PyArrayObject *tmp1 = NULL ;
14607 PLFLT temp4 ;
14608 int res4 = SWIG_TMPOBJ ;
14609 PLFLT temp5 ;
14610 int res5 = SWIG_TMPOBJ ;
14611 PyObject * obj0 = 0 ;
14612
14613 arg4 = &temp4;
14614 arg5 = &temp5;
14615 if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
14616 {
14617 int i, size;
14618 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14619 if ( tmp1 == NULL )
14620 return NULL;
14621 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14622 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14623 size = arg3;
14624 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14625 for ( i = 0; i < arg2; i++ )
14626 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14627 }
14628 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14629 resultobj = SWIG_Py_Void();
14630 if (SWIG_IsTmpObj(res4)) {
14631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14632 } else {
14633 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14635 }
14636 if (SWIG_IsTmpObj(res5)) {
14637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14638 } else {
14639 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14641 }
14642 {
14643 Py_CLEAR( tmp1 );
14644 free( arg1 );
14645 }
14646 return resultobj;
14647 fail:
14648 {
14649 Py_CLEAR( tmp1 );
14650 free( arg1 );
14651 }
14652 return NULL;
14653 }
14654
14655
14656 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14659 void *argp1 = 0 ;
14660 int res1 = 0 ;
14661 PyObject * obj0 = 0 ;
14662 PLINT result;
14663
14664 if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
14665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14668 }
14669 arg1 = (PLGraphicsIn *)(argp1);
14670 result = (PLINT)plGetCursor(arg1);
14671 resultobj = SWIG_From_int((int)(result));
14672 return resultobj;
14673 fail:
14674 return NULL;
14675 }
14676
14677
14678 static PyMethodDef SwigMethods[] = {
14679 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
14680 { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14681 { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14682 { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14683 { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14684 { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
14685 { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14686 { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
14687 { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14688 { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
14689 { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14690 { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
14691 { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14692 { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
14693 { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14694 { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
14695 { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14696 { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
14697 { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14698 { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
14699 { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14700 { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14701 { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14702 { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14703 { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14704 { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14705 { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14706 { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14707 { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14708 { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14709 { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14710 { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14711 { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14712 "Set format of numerical label for contours\n"
14713 "\n"
14714 "DESCRIPTION:\n"
14715 "\n"
14716 " Set format of numerical label for contours. \n"
14717 "\n"
14718 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14719 "\n"
14720 " This function is used example 9. \n"
14721 "\n"
14722 "\n"
14723 "\n"
14724 "SYNOPSIS:\n"
14725 "\n"
14726 "pl_setcontlabelformat(lexp, sigdig)\n"
14727 "\n"
14728 "ARGUMENTS:\n"
14729 "\n"
14730 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14731 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14732 " format is used. Default value of lexp is 4. \n"
14733 "\n"
14734 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14735 " value is 2. \n"
14736 "\n"
14737 ""},
14738 { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14739 "Set parameters of contour labelling other than format of numerical label\n"
14740 "\n"
14741 "DESCRIPTION:\n"
14742 "\n"
14743 " Set parameters of contour labelling other than those handled by\n"
14744 " pl_setcontlabelformat. \n"
14745 "\n"
14746 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14747 "\n"
14748 " This function is used in example 9. \n"
14749 "\n"
14750 "\n"
14751 "\n"
14752 "SYNOPSIS:\n"
14753 "\n"
14754 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14755 "\n"
14756 "ARGUMENTS:\n"
14757 "\n"
14758 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14759 " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
14760 "\n"
14761 " size (PLFLT, input) : Font height for contour labels (normalized). \n"
14762 " Default value is 0.3. \n"
14763 "\n"
14764 " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
14765 " Default value is 0.1. \n"
14766 "\n"
14767 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14768 " contour labels on. Default is off (0). \n"
14769 "\n"
14770 ""},
14771 { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14772 "Advance the (sub-)page\n"
14773 "\n"
14774 "DESCRIPTION:\n"
14775 "\n"
14776 " Advances to the next subpage if sub=0, performing a page advance if\n"
14777 " there are no remaining subpages on the current page. If subpages\n"
14778 " aren't being used, pladv(0) will always advance the page. If sub>0,\n"
14779 " PLplot switches to the specified subpage. Note that this allows you\n"
14780 " to overwrite a plot on the specified subpage; if this is not what you\n"
14781 " intended, use pleop followed by plbop to first advance the page. This\n"
14782 " routine is called automatically (with sub=0) by plenv, but if plenv is\n"
14783 " not used, pladv must be called after initializing PLplot but before\n"
14784 " defining the viewport. \n"
14785 "\n"
14786 " Redacted form: pladv(sub)\n"
14787 "\n"
14788 " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14789 "\n"
14790 "\n"
14791 "\n"
14792 "SYNOPSIS:\n"
14793 "\n"
14794 "pladv(sub)\n"
14795 "\n"
14796 "ARGUMENTS:\n"
14797 "\n"
14798 " sub (PLINT, input) : Specifies the subpage number (starting from 1\n"
14799 " in the top left corner and increasing along the rows) to which to\n"
14800 " advance. Set to zero to advance to the next subpage. \n"
14801 "\n"
14802 ""},
14803 { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14804 "Draw a circular or elliptical arc \n"
14805 "\n"
14806 "DESCRIPTION:\n"
14807 "\n"
14808 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14809 " semiminor axis b, starting at angle1 and ending at angle2. \n"
14810 "\n"
14811 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14812 " fill)\n"
14813 "\n"
14814 "\n"
14815 " This function is used in examples 3 and 27. \n"
14816 "\n"
14817 "\n"
14818 "\n"
14819 "SYNOPSIS:\n"
14820 "\n"
14821 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14822 "\n"
14823 "ARGUMENTS:\n"
14824 "\n"
14825 " x (PLFLT, input) : X coordinate of arc center. \n"
14826 "\n"
14827 " y (PLFLT, input) : Y coordinate of arc center. \n"
14828 "\n"
14829 " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
14830 "\n"
14831 " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
14832 "\n"
14833 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14834 " semimajor axis. \n"
14835 "\n"
14836 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14837 " semimajor axis. \n"
14838 "\n"
14839 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14840 " X-axis. \n"
14841 "\n"
14842 " fill (PLBOOL, input) : Draw a filled arc. \n"
14843 "\n"
14844 ""},
14845 { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14846 "Draw a box with axes, etc. with arbitrary origin \n"
14847 "\n"
14848 "DESCRIPTION:\n"
14849 "\n"
14850 " Draws a box around the currently defined viewport with arbitrary\n"
14851 " world-coordinate origin specified by x0 and y0 and labels it with\n"
14852 " world coordinate values appropriate to the window. Thus plaxes should\n"
14853 " only be called after defining both viewport and window. The character\n"
14854 " strings xopt and yopt specify how the box should be drawn as described\n"
14855 " below. If ticks and/or subticks are to be drawn for a particular\n"
14856 " axis, the tick intervals and number of subintervals may be specified\n"
14857 " explicitly, or they may be defaulted by setting the appropriate\n"
14858 " arguments to zero. \n"
14859 "\n"
14860 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14861 " ytick, nysub)\n"
14862 " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14863 " yopt)\n"
14864 "\n"
14865 "\n"
14866 " This function is not used in any examples. \n"
14867 "\n"
14868 "\n"
14869 "\n"
14870 "SYNOPSIS:\n"
14871 "\n"
14872 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14873 "\n"
14874 "ARGUMENTS:\n"
14875 "\n"
14876 " x0 (PLFLT, input) : World X coordinate of origin. \n"
14877 "\n"
14878 " y0 (PLFLT, input) : World Y coordinate of origin. \n"
14879 "\n"
14880 " xopt (const char *, input) : Pointer to character string specifying\n"
14881 " options for horizontal axis. The string can include any\n"
14882 " combination of the following letters (upper or lower case) in any\n"
14883 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14884 " is vertical line (x=0). \n"
14885 " b: Draws bottom (X) or left (Y) edge of frame. \n"
14886 " c: Draws top (X) or right (Y) edge of frame. \n"
14887 " d: Plot labels as date / time. Values are assumed to be\n"
14888 " seconds since the epoch (as used by gmtime). \n"
14889 " f: Always use fixed point numeric labels. \n"
14890 " g: Draws a grid at the major tick interval. \n"
14891 " h: Draws a grid at the minor tick interval. \n"
14892 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14893 " inwards. \n"
14894 " l: Labels axis logarithmically. This only affects the labels,\n"
14895 " not the data, and so it is necessary to compute the logarithms\n"
14896 " of data points before passing them to any of the drawing\n"
14897 " routines. \n"
14898 " m: Writes numeric labels at major tick intervals in the\n"
14899 " unconventional location (above box for X, right of box for Y). \n"
14900 " n: Writes numeric labels at major tick intervals in the\n"
14901 " conventional location (below box for X, left of box for Y). \n"
14902 " o: Use custom labelling function to generate axis label text. \n"
14903 " The custom labelling function can be defined with the\n"
14904 " plslabelfunc command. \n"
14905 " s: Enables subticks between major ticks, only valid if t is\n"
14906 " also specified. \n"
14907 " t: Draws major ticks. \n"
14908 " u: Exactly like \"b\" except don't draw edge line. \n"
14909 " w: Exactly like \"c\" except don't draw edge line. \n"
14910 " x: Exactly like \"t\" (including the side effect of the\n"
14911 " numerical labels for the major ticks) except exclude drawing\n"
14912 " the major and minor tick marks. \n"
14913 "\n"
14914 "\n"
14915 " xtick (PLFLT, input) : World coordinate interval between major\n"
14916 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14917 " generates a suitable tick interval. \n"
14918 "\n"
14919 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14920 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14921 " generates a suitable minor tick interval. \n"
14922 "\n"
14923 " yopt (const char *, input) : Pointer to character string specifying\n"
14924 " options for vertical axis. The string can include any combination\n"
14925 " of the letters defined above for xopt, and in addition may\n"
14926 " contain: v: Write numeric labels for vertical axis parallel to the\n"
14927 " base of the graph, rather than parallel to the axis. \n"
14928 "\n"
14929 "\n"
14930 " ytick (PLFLT, input) : World coordinate interval between major\n"
14931 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14932 " generates a suitable tick interval. \n"
14933 "\n"
14934 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14935 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14936 " generates a suitable minor tick interval. \n"
14937 "\n"
14938 ""},
14939 { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14940 "Plot a histogram from binned data \n"
14941 "\n"
14942 "DESCRIPTION:\n"
14943 "\n"
14944 " Plots a histogram consisting of nbin bins. The value associated with\n"
14945 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14946 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14947 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14948 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14949 " placed midway between the values in the x array. Also see plhist for\n"
14950 " drawing histograms from unbinned data. \n"
14951 "\n"
14952 " Redacted form: General: plbin(x, y, opt)\n"
14953 " Perl/PDL: plbin(nbin, x, y, opt)\n"
14954 " Python: plbin(nbin, x, y, opt)\n"
14955 "\n"
14956 "\n"
14957 " This function is not used in any examples. \n"
14958 "\n"
14959 "\n"
14960 "\n"
14961 "SYNOPSIS:\n"
14962 "\n"
14963 "plbin(nbin, x, y, opt)\n"
14964 "\n"
14965 "ARGUMENTS:\n"
14966 "\n"
14967 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14968 " and y arrays.) \n"
14969 "\n"
14970 " x (PLFLT *, input) : Pointer to array containing values associated\n"
14971 " with bins. These must form a strictly increasing sequence. \n"
14972 "\n"
14973 " y (PLFLT *, input) : Pointer to array containing number of points\n"
14974 " in bin. This is a PLFLT (instead of PLINT) array so as to allow\n"
14975 " histograms of probabilities, etc. \n"
14976 "\n"
14977 " opt (PLINT, input) : Is a combination of several flags:\n"
14978 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14979 " outer bins are expanded to fill up the entire x-axis and bins of\n"
14980 " zero height are simply drawn. \n"
14981 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14982 " between the x values. If the values in x are equally spaced,\n"
14983 " the values are the center values of the bins. \n"
14984 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14985 " size as the ones inside. \n"
14986 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14987 " (there is a gap for such bins). \n"
14988 "\n"
14989 ""},
14990 { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, NULL},
14991 { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
14992 "Begin a new page\n"
14993 "\n"
14994 "DESCRIPTION:\n"
14995 "\n"
14996 " Begins a new page. For a file driver, the output file is opened if\n"
14997 " necessary. Advancing the page via pleop and plbop is useful when a\n"
14998 " page break is desired at a particular point when plotting to subpages.\n"
14999 " Another use for pleop and plbop is when plotting pages to different\n"
15000 " files, since you can manually set the file name by calling plsfnam\n"
15001 " after the call to pleop. (In fact some drivers may only support a\n"
15002 " single page per file, making this a necessity.) One way to handle\n"
15003 " this case automatically is to page advance via pladv, but enable\n"
15004 " familying (see plsfam) with a small limit on the file size so that a\n"
15005 " new family member file will be created on each page break. \n"
15006 "\n"
15007 " Redacted form: plbop()\n"
15008 "\n"
15009 " This function is used in examples 2,20. \n"
15010 "\n"
15011 "\n"
15012 "\n"
15013 "SYNOPSIS:\n"
15014 "\n"
15015 "plbop()\n"
15016 "\n"
15017 ""},
15018 { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15019 "Draw a box with axes, etc\n"
15020 "\n"
15021 "DESCRIPTION:\n"
15022 "\n"
15023 " Draws a box around the currently defined viewport, and labels it with\n"
15024 " world coordinate values appropriate to the window. Thus plbox should\n"
15025 " only be called after defining both viewport and window. The character\n"
15026 " strings xopt and yopt specify how the box should be drawn as described\n"
15027 " below. If ticks and/or subticks are to be drawn for a particular\n"
15028 " axis, the tick intervals and number of subintervals may be specified\n"
15029 " explicitly, or they may be defaulted by setting the appropriate\n"
15030 " arguments to zero. \n"
15031 "\n"
15032 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15033 " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15034 "\n"
15035 "\n"
15036 " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
15037 "\n"
15038 "\n"
15039 "\n"
15040 "SYNOPSIS:\n"
15041 "\n"
15042 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15043 "\n"
15044 "ARGUMENTS:\n"
15045 "\n"
15046 " xopt (const char *, input) : Pointer to character string specifying\n"
15047 " options for horizontal axis. The string can include any\n"
15048 " combination of the following letters (upper or lower case) in any\n"
15049 " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15050 " is vertical line (x=0). \n"
15051 " b: Draws bottom (X) or left (Y) edge of frame. \n"
15052 " c: Draws top (X) or right (Y) edge of frame. \n"
15053 " d: Plot labels as date / time. Values are assumed to be\n"
15054 " seconds since the epoch (as used by gmtime). \n"
15055 " f: Always use fixed point numeric labels. \n"
15056 " g: Draws a grid at the major tick interval. \n"
15057 " h: Draws a grid at the minor tick interval. \n"
15058 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15059 " inwards. \n"
15060 " l: Labels axis logarithmically. This only affects the labels,\n"
15061 " not the data, and so it is necessary to compute the logarithms\n"
15062 " of data points before passing them to any of the drawing\n"
15063 " routines. \n"
15064 " m: Writes numeric labels at major tick intervals in the\n"
15065 " unconventional location (above box for X, right of box for Y). \n"
15066 " n: Writes numeric labels at major tick intervals in the\n"
15067 " conventional location (below box for X, left of box for Y). \n"
15068 " o: Use custom labelling function to generate axis label text. \n"
15069 " The custom labelling function can be defined with the\n"
15070 " plslabelfunc command. \n"
15071 " s: Enables subticks between major ticks, only valid if t is\n"
15072 " also specified. \n"
15073 " t: Draws major ticks. \n"
15074 " u: Exactly like \"b\" except don't draw edge line. \n"
15075 " w: Exactly like \"c\" except don't draw edge line. \n"
15076 " x: Exactly like \"t\" (including the side effect of the\n"
15077 " numerical labels for the major ticks) except exclude drawing\n"
15078 " the major and minor tick marks. \n"
15079 "\n"
15080 "\n"
15081 " xtick (PLFLT, input) : World coordinate interval between major\n"
15082 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15083 " generates a suitable tick interval. \n"
15084 "\n"
15085 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15086 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15087 " generates a suitable minor tick interval. \n"
15088 "\n"
15089 " yopt (const char *, input) : Pointer to character string specifying\n"
15090 " options for vertical axis. The string can include any combination\n"
15091 " of the letters defined above for xopt, and in addition may\n"
15092 " contain: v: Write numeric labels for vertical axis parallel to the\n"
15093 " base of the graph, rather than parallel to the axis. \n"
15094 "\n"
15095 "\n"
15096 " ytick (PLFLT, input) : World coordinate interval between major\n"
15097 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15098 " generates a suitable tick interval. \n"
15099 "\n"
15100 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15101 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15102 " generates a suitable minor tick interval. \n"
15103 "\n"
15104 ""},
15105 { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15106 "Draw a box with axes, etc, in 3-d \n"
15107 "\n"
15108 "DESCRIPTION:\n"
15109 "\n"
15110 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15111 " plot. For a more complete description of three-dimensional plotting\n"
15112 " see the PLplot documentation. \n"
15113 "\n"
15114 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15115 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15116 " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15117 " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15118 "\n"
15119 "\n"
15120 " This function is used in examples 8,11,18,21. \n"
15121 "\n"
15122 "\n"
15123 "\n"
15124 "SYNOPSIS:\n"
15125 "\n"
15126 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15127 "\n"
15128 "ARGUMENTS:\n"
15129 "\n"
15130 " xopt (const char *, input) : Pointer to character string specifying\n"
15131 " options for the x axis. The string can include any combination of\n"
15132 " the following letters (upper or lower case) in any order: b: Draws\n"
15133 " axis at base, at height z=\n"
15134 " zmin where zmin is defined by call to plw3d. This character must be\n"
15135 " specified in order to use any of the other options. \n"
15136 " f: Always use fixed point numeric labels. \n"
15137 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15138 " than upwards. \n"
15139 " l: Labels axis logarithmically. This only affects the labels,\n"
15140 " not the data, and so it is necessary to compute the logarithms\n"
15141 " of data points before passing them to any of the drawing\n"
15142 " routines. \n"
15143 " n: Writes numeric labels at major tick intervals. \n"
15144 " o: Use custom labelling function to generate axis label text. \n"
15145 " The custom labelling function can be defined with the\n"
15146 " plslabelfunc command. \n"
15147 " s: Enables subticks between major ticks, only valid if t is\n"
15148 " also specified. \n"
15149 " t: Draws major ticks. \n"
15150 " u: If this is specified, the text label for the axis is\n"
15151 " written under the axis. \n"
15152 "\n"
15153 "\n"
15154 " xlabel (const char *, input) : Pointer to character string\n"
15155 " specifying text label for the x axis. It is only drawn if u is in\n"
15156 " the xopt string. \n"
15157 "\n"
15158 " xtick (PLFLT, input) : World coordinate interval between major\n"
15159 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15160 " generates a suitable tick interval. \n"
15161 "\n"
15162 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15163 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15164 " generates a suitable minor tick interval. \n"
15165 "\n"
15166 " yopt (const char *, input) : Pointer to character string specifying\n"
15167 " options for the y axis. The string is interpreted in the same way\n"
15168 " as xopt. \n"
15169 "\n"
15170 " ylabel (const char *, input) : Pointer to character string\n"
15171 " specifying text label for the y axis. It is only drawn if u is in\n"
15172 " the yopt string. \n"
15173 "\n"
15174 " ytick (PLFLT, input) : World coordinate interval between major\n"
15175 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15176 " generates a suitable tick interval. \n"
15177 "\n"
15178 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15179 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15180 " generates a suitable minor tick interval. \n"
15181 "\n"
15182 " zopt (const char *, input) : Pointer to character string specifying\n"
15183 " options for the z axis. The string can include any combination of\n"
15184 " the following letters (upper or lower case) in any order: b: Draws\n"
15185 " z axis to the left of the surface plot. \n"
15186 " c: Draws z axis to the right of the surface plot. \n"
15187 " d: Draws grid lines parallel to the x-y plane behind the\n"
15188 " figure. These lines are not drawn until after plot3d or\n"
15189 " plmesh are called because of the need for hidden line removal. \n"
15190 " f: Always use fixed point numeric labels. \n"
15191 " i: Inverts tick marks, so they are drawn away from the center. \n"
15192 " l: Labels axis logarithmically. This only affects the labels,\n"
15193 " not the data, and so it is necessary to compute the logarithms\n"
15194 " of data points before passing them to any of the drawing\n"
15195 " routines. \n"
15196 " m: Writes numeric labels at major tick intervals on the\n"
15197 " right-hand vertical axis. \n"
15198 " n: Writes numeric labels at major tick intervals on the\n"
15199 " left-hand vertical axis. \n"
15200 " o: Use custom labelling function to generate axis label text. \n"
15201 " The custom labelling function can be defined with the\n"
15202 " plslabelfunc command. \n"
15203 " s: Enables subticks between major ticks, only valid if t is\n"
15204 " also specified. \n"
15205 " t: Draws major ticks. \n"
15206 " u: If this is specified, the text label is written beside the\n"
15207 " left-hand axis. \n"
15208 " v: If this is specified, the text label is written beside the\n"
15209 " right-hand axis. \n"
15210 "\n"
15211 "\n"
15212 " zlabel (const char *, input) : Pointer to character string\n"
15213 " specifying text label for the z axis. It is only drawn if u or v\n"
15214 " are in the zopt string. \n"
15215 "\n"
15216 " ztick (PLFLT, input) : World coordinate interval between major\n"
15217 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15218 " generates a suitable tick interval. \n"
15219 "\n"
15220 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15221 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15222 " generates a suitable minor tick interval. \n"
15223 "\n"
15224 ""},
15225 { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15226 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15227 "\n"
15228 "DESCRIPTION:\n"
15229 "\n"
15230 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15231 " from relative device coordinates, rx and ry. \n"
15232 "\n"
15233 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15234 " Perl/PDL: Not available? \n"
15235 "\n"
15236 "\n"
15237 " This function is used in example 31. \n"
15238 "\n"
15239 "\n"
15240 "\n"
15241 "SYNOPSIS:\n"
15242 "\n"
15243 "plcalc_world(rx, ry, wx, wy, window)\n"
15244 "\n"
15245 "ARGUMENTS:\n"
15246 "\n"
15247 " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15248 " 0. to 1.) for the x coordinate. \n"
15249 "\n"
15250 " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15251 " 0. to 1.) for the y coordinate. \n"
15252 "\n"
15253 " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15254 " x corresponding to the relative device coordinates rx and ry. \n"
15255 "\n"
15256 " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15257 " y corresponding to the relative device coordinates rx and ry. \n"
15258 "\n"
15259 " window (PLINT *, output) : Pointer to the returned last defined\n"
15260 " window index that corresponds to the input relative device\n"
15261 " coordinates (and the returned world coordinates). To give some\n"
15262 " background on the window index, for each page the initial window\n"
15263 " index is set to zero, and each time plwind is called within the\n"
15264 " page, world and device coordinates are stored for the window and\n"
15265 " the window index is incremented. Thus, for a simple page layout\n"
15266 " with non-overlapping viewports and one window per viewport, window\n"
15267 " corresponds to the viewport index (in the order which the\n"
15268 " viewport/windows were created) of the only viewport/window\n"
15269 " corresponding to rx and ry. However, for more complicated layouts\n"
15270 " with potentially overlapping viewports and possibly more than one\n"
15271 " window (set of world coordinates) per viewport, window and the\n"
15272 " corresponding output world coordinates corresponds to the last\n"
15273 " window created that fulfills the criterion that the relative\n"
15274 " device coordinates are inside it. Finally, in all cases where the\n"
15275 " input relative device coordinates are not inside any\n"
15276 " viewport/window, then window is set to -1. \n"
15277 "\n"
15278 ""},
15279 { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15280 "Clear current (sub)page \n"
15281 "\n"
15282 "DESCRIPTION:\n"
15283 "\n"
15284 " Clears the current page, effectively erasing everything that have been\n"
15285 " drawn. This command only works with interactive drivers; if the\n"
15286 " driver does not support this, the page is filled with the background\n"
15287 " color in use. If the current page is divided into subpages, only the\n"
15288 " current subpage is erased. The nth subpage can be selected with\n"
15289 " pladv(n). \n"
15290 "\n"
15291 " Redacted form: General: plclear()\n"
15292 " Perl/PDL: Not available? \n"
15293 "\n"
15294 "\n"
15295 " This function is not used in any examples. \n"
15296 "\n"
15297 "\n"
15298 "\n"
15299 "SYNOPSIS:\n"
15300 "\n"
15301 "plclear()\n"
15302 "\n"
15303 ""},
15304 { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15305 "Set color, map0 \n"
15306 "\n"
15307 "DESCRIPTION:\n"
15308 "\n"
15309 " Sets the color for color map0 (see the PLplot documentation). \n"
15310 "\n"
15311 " Redacted form: plcol0(color)\n"
15312 "\n"
15313 " This function is used in examples 1-9,11-16,18-27,29. \n"
15314 "\n"
15315 "\n"
15316 "\n"
15317 "SYNOPSIS:\n"
15318 "\n"
15319 "plcol0(color)\n"
15320 "\n"
15321 "ARGUMENTS:\n"
15322 "\n"
15323 " color (PLINT, input) : Integer representing the color. The\n"
15324 " defaults at present are (these may change): \n"
15325 " 0 black (default background) \n"
15326 " 1 red (default foreground) \n"
15327 " 2 yellow \n"
15328 " 3 green \n"
15329 " 4 aquamarine \n"
15330 " 5 pink \n"
15331 " 6 wheat \n"
15332 " 7 grey \n"
15333 " 8 brown \n"
15334 " 9 blue \n"
15335 " 10 BlueViolet \n"
15336 " 11 cyan \n"
15337 " 12 turquoise \n"
15338 " 13 magenta \n"
15339 " 14 salmon \n"
15340 " 15 white \n"
15341 "\n"
15342 " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15343 " change an individual color in the map0 color palette. \n"
15344 "\n"
15345 ""},
15346 { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15347 "Set color, map1 \n"
15348 "\n"
15349 "DESCRIPTION:\n"
15350 "\n"
15351 " Sets the color for color map1 (see the PLplot documentation). \n"
15352 "\n"
15353 " Redacted form: plcol1(col1)\n"
15354 "\n"
15355 " This function is used in examples 12 and 21. \n"
15356 "\n"
15357 "\n"
15358 "\n"
15359 "SYNOPSIS:\n"
15360 "\n"
15361 "plcol1(col1)\n"
15362 "\n"
15363 "ARGUMENTS:\n"
15364 "\n"
15365 " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15366 " and is mapped to color using the continuous map1 color palette\n"
15367 " which by default ranges from blue to the background color to red. \n"
15368 " The map1 palette can also be straightforwardly changed by the user\n"
15369 " with plscmap1 or plscmap1l. \n"
15370 "\n"
15371 ""},
15372 { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, NULL},
15373 { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
15374 "Contour plot \n"
15375 "\n"
15376 "DESCRIPTION:\n"
15377 "\n"
15378 " Draws a contour plot of the data in z[\n"
15379 " nx][\n"
15380 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15381 " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15382 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15383 " additional data required by the transformation routine is used to map\n"
15384 " indices within the array to the world coordinates. See the following\n"
15385 " discussion of the arguments and the PLplot documentation for more\n"
15386 " information. \n"
15387 "\n"
15388 " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15389 " plcont(z, kx, lx, ky, ly, clevel, tr?) or plcont(z, kx, lx, ky, ly,\n"
15390 " clevel, xgrid, ygrid)\n"
15391 " Java: pls.cont(z, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15392 " Perl/PDL: plcont(z, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15393 " Python: plcont2(z, kx, lx, ky, ly, clevel)\n"
15394 "\n"
15395 "\n"
15396 " This function is used in examples 9,14,16,22. \n"
15397 "\n"
15398 "\n"
15399 "\n"
15400 "SYNOPSIS:\n"
15401 "\n"
15402 "plcont(z, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15403 "\n"
15404 "ARGUMENTS:\n"
15405 "\n"
15406 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
15407 " containing data to be contoured. \n"
15408 "\n"
15409 " nx, ny (PLINT, input) : Physical dimensions of array z. \n"
15410 "\n"
15411 " kx, lx (PLINT, input) : Range of x indices to consider. \n"
15412 "\n"
15413 " ky, ly (PLINT, input) : Range of y indices to consider. \n"
15414 "\n"
15415 " clevel (PLFLT *, input) : Pointer to array specifying levels at\n"
15416 " which to draw contours. \n"
15417 "\n"
15418 " nlevel (PLINT, input) : Number of contour levels to draw. \n"
15419 "\n"
15420 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15421 " Pointer to function that defines transformation between indices\n"
15422 " in array z and the world coordinates (C only). Transformation\n"
15423 " functions are provided in the PLplot library: pltr0 for identity\n"
15424 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15425 " defined by one- and two-dimensional arrays. In addition,\n"
15426 " user-supplied routines for the transformation can be used as well.\n"
15427 " Examples of all of these approaches are given in the PLplot\n"
15428 " documentation. The transformation function should have the form\n"
15429 " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15430 " and similar PLplot functions which have a pltr argument, plcont\n"
15431 " requires that a transformation function be provided in the C\n"
15432 " interface. Leaving pltr NULL will result in an error. \n"
15433 "\n"
15434 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15435 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15436 " externally supplied. \n"
15437 "\n"
15438 ""},
15439 { (char *)"plctime", _wrap_plctime, METH_VARARGS, NULL},
15440 { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
15441 "Copy state parameters from the reference stream to the current stream \n"
15442 "\n"
15443 "DESCRIPTION:\n"
15444 "\n"
15445 " Copies state parameters from the reference stream to the current\n"
15446 " stream. Tell driver interface to map device coordinates unless flags\n"
15447 " == 1. \n"
15448 "\n"
15449 " This function is used for making save files of selected plots (e.g.\n"
15450 " from the TK driver). After initializing, you can get a copy of the\n"
15451 " current plot to the specified device by switching to this stream and\n"
15452 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15453 " appropriate. The plot buffer must have previously been enabled (done\n"
15454 " automatically by some display drivers, such as X). \n"
15455 "\n"
15456 " Redacted form: plcpstrm(iplsr, flags)\n"
15457 "\n"
15458 " This function is used in example 1,20. \n"
15459 "\n"
15460 "\n"
15461 "\n"
15462 "SYNOPSIS:\n"
15463 "\n"
15464 "plcpstrm(iplsr, flags)\n"
15465 "\n"
15466 "ARGUMENTS:\n"
15467 "\n"
15468 " iplsr (PLINT, input) : Number of reference stream. \n"
15469 "\n"
15470 " flags (PLBOOL, input) : If flags is set to true the device\n"
15471 " coordinates are not copied from the reference to current stream. \n"
15472 "\n"
15473 ""},
15474 { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
15475 "End plotting session \n"
15476 "\n"
15477 "DESCRIPTION:\n"
15478 "\n"
15479 " Ends a plotting session, tidies up all the output files, switches\n"
15480 " interactive devices back into text mode and frees up any memory that\n"
15481 " was allocated. Must be called before end of program. \n"
15482 "\n"
15483 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15484 " wait state after a call to plend or other functions which trigger the\n"
15485 " end of a plot page. To avoid this, use the plspause function. \n"
15486 "\n"
15487 " Redacted form: plend()\n"
15488 "\n"
15489 " This function is used in all of the examples. \n"
15490 "\n"
15491 "\n"
15492 "\n"
15493 "SYNOPSIS:\n"
15494 "\n"
15495 "plend()\n"
15496 "\n"
15497 ""},
15498 { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
15499 "End plotting session for current stream \n"
15500 "\n"
15501 "DESCRIPTION:\n"
15502 "\n"
15503 " Ends a plotting session for the current output stream only. See\n"
15504 " plsstrm for more info. \n"
15505 "\n"
15506 " Redacted form: plend1()\n"
15507 "\n"
15508 " This function is used in examples 1,20. \n"
15509 "\n"
15510 "\n"
15511 "\n"
15512 "SYNOPSIS:\n"
15513 "\n"
15514 "plend1()\n"
15515 "\n"
15516 ""},
15517 { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
15518 "Set up standard window and draw box \n"
15519 "\n"
15520 "DESCRIPTION:\n"
15521 "\n"
15522 " Sets up plotter environment for simple graphs by calling pladv and\n"
15523 " setting up viewport and window to sensible default values. plenv\n"
15524 " leaves enough room around most graphs for axis labels and a title.\n"
15525 " When these defaults are not suitable, use the individual routines\n"
15526 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15527 " defining the window, and plbox for drawing the box. \n"
15528 "\n"
15529 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15530 "\n"
15531 " This function is used in example 1,3,9,13,14,19-22,29. \n"
15532 "\n"
15533 "\n"
15534 "\n"
15535 "SYNOPSIS:\n"
15536 "\n"
15537 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15538 "\n"
15539 "ARGUMENTS:\n"
15540 "\n"
15541 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15542 " world coordinates). \n"
15543 "\n"
15544 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15545 " world coordinates). \n"
15546 "\n"
15547 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15548 " coordinates). \n"
15549 "\n"
15550 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15551 " coordinates). \n"
15552 "\n"
15553 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15554 " scales will not be set, the user must set up the scale before\n"
15555 " calling plenv using plsvpa, plvasp or other. \n"
15556 " 0: the x and y axes are scaled independently to use as much of\n"
15557 " the screen as possible. \n"
15558 " 1: the scales of the x and y axes are made equal. \n"
15559 " 2: the axis of the x and y axes are made equal, and the plot\n"
15560 " box will be square. \n"
15561 "\n"
15562 "\n"
15563 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15564 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15565 " -1: draw box only. \n"
15566 " 0: draw box, ticks, and numeric tick labels. \n"
15567 " 1: also draw coordinate axes at x=0 and y=0. \n"
15568 " 2: also draw a grid at major tick positions in both\n"
15569 " coordinates. \n"
15570 " 3: also draw a grid at minor tick positions in both\n"
15571 " coordinates. \n"
15572 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15573 " have to be converted to logarithms separately.) \n"
15574 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15575 " have to be converted to logarithms separately.) \n"
15576 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15577 " have to be converted to logarithms separately.) \n"
15578 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15579 " have to be converted to logarithms separately.) \n"
15580 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15581 " have to be converted to logarithms separately.) \n"
15582 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15583 " have to be converted to logarithms separately.) \n"
15584 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15585 " have to be converted to logarithms separately.) \n"
15586 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15587 " have to be converted to logarithms separately.) \n"
15588 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15589 " and y data have to be converted to logarithms separately.) \n"
15590 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15591 " and y data have to be converted to logarithms separately.) \n"
15592 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15593 " and y data have to be converted to logarithms separately.) \n"
15594 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15595 " and y data have to be converted to logarithms separately.) \n"
15596 " 40: same as 0 except date / time x labels. \n"
15597 " 41: same as 1 except date / time x labels. \n"
15598 " 42: same as 2 except date / time x labels. \n"
15599 " 43: same as 3 except date / time x labels. \n"
15600 " 50: same as 0 except date / time y labels. \n"
15601 " 51: same as 1 except date / time y labels. \n"
15602 " 52: same as 2 except date / time y labels. \n"
15603 " 53: same as 3 except date / time y labels. \n"
15604 " 60: same as 0 except date / time x and y labels. \n"
15605 " 61: same as 1 except date / time x and y labels. \n"
15606 " 62: same as 2 except date / time x and y labels. \n"
15607 " 63: same as 3 except date / time x and y labels. \n"
15608 " 70: same as 0 except custom x and y labels. \n"
15609 " 71: same as 1 except custom x and y labels. \n"
15610 " 72: same as 2 except custom x and y labels. \n"
15611 " 73: same as 3 except custom x and y labels. \n"
15612 "\n"
15613 ""},
15614 { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
15615 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n"
15616 "\n"
15617 "DESCRIPTION:\n"
15618 "\n"
15619 " Sets up plotter environment for simple graphs by calling pladv and\n"
15620 " setting up viewport and window to sensible default values. plenv0\n"
15621 " leaves enough room around most graphs for axis labels and a title.\n"
15622 " When these defaults are not suitable, use the individual routines\n"
15623 " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15624 " defining the window, and plbox for drawing the box. \n"
15625 "\n"
15626 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15627 "\n"
15628 " This function is used in example 21. \n"
15629 "\n"
15630 "\n"
15631 "\n"
15632 "SYNOPSIS:\n"
15633 "\n"
15634 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15635 "\n"
15636 "ARGUMENTS:\n"
15637 "\n"
15638 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15639 " world coordinates). \n"
15640 "\n"
15641 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15642 " world coordinates). \n"
15643 "\n"
15644 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15645 " coordinates). \n"
15646 "\n"
15647 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15648 " coordinates). \n"
15649 "\n"
15650 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15651 " scales will not be set, the user must set up the scale before\n"
15652 " calling plenv0 using plsvpa, plvasp or other. \n"
15653 " 0: the x and y axes are scaled independently to use as much of\n"
15654 " the screen as possible. \n"
15655 " 1: the scales of the x and y axes are made equal. \n"
15656 " 2: the axis of the x and y axes are made equal, and the plot\n"
15657 " box will be square. \n"
15658 "\n"
15659 "\n"
15660 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15661 " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15662 " -1: draw box only. \n"
15663 " 0: draw box, ticks, and numeric tick labels. \n"
15664 " 1: also draw coordinate axes at x=0 and y=0. \n"
15665 " 2: also draw a grid at major tick positions in both\n"
15666 " coordinates. \n"
15667 " 3: also draw a grid at minor tick positions in both\n"
15668 " coordinates. \n"
15669 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15670 " have to be converted to logarithms separately.) \n"
15671 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15672 " have to be converted to logarithms separately.) \n"
15673 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15674 " have to be converted to logarithms separately.) \n"
15675 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15676 " have to be converted to logarithms separately.) \n"
15677 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15678 " have to be converted to logarithms separately.) \n"
15679 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15680 " have to be converted to logarithms separately.) \n"
15681 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15682 " have to be converted to logarithms separately.) \n"
15683 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15684 " have to be converted to logarithms separately.) \n"
15685 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15686 " and y data have to be converted to logarithms separately.) \n"
15687 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15688 " and y data have to be converted to logarithms separately.) \n"
15689 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15690 " and y data have to be converted to logarithms separately.) \n"
15691 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15692 " and y data have to be converted to logarithms separately.) \n"
15693 " 40: same as 0 except date / time x labels. \n"
15694 " 41: same as 1 except date / time x labels. \n"
15695 " 42: same as 2 except date / time x labels. \n"
15696 " 43: same as 3 except date / time x labels. \n"
15697 " 50: same as 0 except date / time y labels. \n"
15698 " 51: same as 1 except date / time y labels. \n"
15699 " 52: same as 2 except date / time y labels. \n"
15700 " 53: same as 3 except date / time y labels. \n"
15701 " 60: same as 0 except date / time x and y labels. \n"
15702 " 61: same as 1 except date / time x and y labels. \n"
15703 " 62: same as 2 except date / time x and y labels. \n"
15704 " 63: same as 3 except date / time x and y labels. \n"
15705 " 70: same as 0 except custom x and y labels. \n"
15706 " 71: same as 1 except custom x and y labels. \n"
15707 " 72: same as 2 except custom x and y labels. \n"
15708 " 73: same as 3 except custom x and y labels. \n"
15709 "\n"
15710 ""},
15711 { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
15712 "Eject current page \n"
15713 "\n"
15714 "DESCRIPTION:\n"
15715 "\n"
15716 " Clears the graphics screen of an interactive device, or ejects a page\n"
15717 " on a plotter. See plbop for more information. \n"
15718 "\n"
15719 " Redacted form: pleop()\n"
15720 "\n"
15721 " This function is used in example 2,14. \n"
15722 "\n"
15723 "\n"
15724 "\n"
15725 "SYNOPSIS:\n"
15726 "\n"
15727 "pleop()\n"
15728 "\n"
15729 ""},
15730 { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15731 "Draw x error bar \n"
15732 "\n"
15733 "DESCRIPTION:\n"
15734 "\n"
15735 " Draws a set of n horizontal error bars, the i'th error bar extending\n"
15736 " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
15737 " error bar are of length equal to the minor tick length (settable using\n"
15738 " plsmin). \n"
15739 "\n"
15740 " Redacted form: General: plerrx(xmin, ymax, y)\n"
15741 " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15742 "\n"
15743 "\n"
15744 " This function is used in example 29. \n"
15745 "\n"
15746 "\n"
15747 "\n"
15748 "SYNOPSIS:\n"
15749 "\n"
15750 "plerrx(n, xmin, xmax, y)\n"
15751 "\n"
15752 "ARGUMENTS:\n"
15753 "\n"
15754 " n (PLINT, input) : Number of error bars to draw. \n"
15755 "\n"
15756 " xmin (PLFLT *, input) : Pointer to array with x coordinates of\n"
15757 " left-hand endpoint of error bars. \n"
15758 "\n"
15759 " xmax (PLFLT *, input) : Pointer to array with x coordinates of\n"
15760 " right-hand endpoint of error bars. \n"
15761 "\n"
15762 " y (PLFLT *, input) : Pointer to array with y coordinates of error\n"
15763 " bar. \n"
15764 "\n"
15765 ""},
15766 { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15767 "Draw y error bar \n"
15768 "\n"
15769 "DESCRIPTION:\n"
15770 "\n"
15771 " Draws a set of n vertical error bars, the i'th error bar extending\n"
15772 " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
15773 " error bar are of length equal to the minor tick length (settable using\n"
15774 " plsmin). \n"
15775 "\n"
15776 " Redacted form: General: plerry(x, ymin, ymax)\n"
15777 " Perl/PDL: plerry(n, x, ymin, ymax)\n"
15778 "\n"
15779 "\n"
15780 " This function is used in example 29. \n"
15781 "\n"
15782 "\n"
15783 "\n"
15784 "SYNOPSIS:\n"
15785 "\n"
15786 "plerry(n, x, ymin, ymax)\n"
15787 "\n"
15788 "ARGUMENTS:\n"
15789 "\n"
15790 " n (PLINT, input) : Number of error bars to draw. \n"
15791 "\n"
15792 " x (PLFLT *, input) : Pointer to array with x coordinates of error\n"
15793 " bars. \n"
15794 "\n"
15795 " ymin (PLFLT *, input) : Pointer to array with y coordinates of\n"
15796 " lower endpoint of error bars. \n"
15797 "\n"
15798 " ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n"
15799 " endpoint of error bar. \n"
15800 "\n"
15801 ""},
15802 { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
15803 "Advance to the next family file on the next new page \n"
15804 "\n"
15805 "DESCRIPTION:\n"
15806 "\n"
15807 " Advance to the next family file on the next new page. \n"
15808 "\n"
15809 " Redacted form: plfamadv()\n"
15810 "\n"
15811 " This function is not used in any examples. \n"
15812 "\n"
15813 "\n"
15814 "\n"
15815 "SYNOPSIS:\n"
15816 "\n"
15817 "plfamadv()\n"
15818 "\n"
15819 ""},
15820 { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
15821 "Draw filled polygon \n"
15822 "\n"
15823 "DESCRIPTION:\n"
15824 "\n"
15825 " Fills the polygon defined by the n points (\n"
15826 " x[i], \n"
15827 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15828 " style is a solid fill. The routine will automatically close the\n"
15829 " polygon between the last and first vertices. If multiple closed\n"
15830 " polygons are passed in x and y then plfill will fill in between them. \n"
15831 "\n"
15832 " Redacted form: plfill(x,y)\n"
15833 "\n"
15834 " This function is used in examples 12,13,15,16,21,24,25. \n"
15835 "\n"
15836 "\n"
15837 "\n"
15838 "SYNOPSIS:\n"
15839 "\n"
15840 "plfill(n, x, y)\n"
15841 "\n"
15842 "ARGUMENTS:\n"
15843 "\n"
15844 " n (PLINT, input) : Number of vertices in polygon. \n"
15845 "\n"
15846 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15847 " vertices. \n"
15848 "\n"
15849 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15850 " vertices. \n"
15851 "\n"
15852 ""},
15853 { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
15854 "Draw filled polygon in 3D \n"
15855 "\n"
15856 "DESCRIPTION:\n"
15857 "\n"
15858 " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
15859 " using the pattern defined by plpsty or plpat. The routine will\n"
15860 " automatically close the polygon between the last and first vertices. \n"
15861 " If multiple closed polygons are passed in x, y, and z then plfill3\n"
15862 " will fill in between them. \n"
15863 "\n"
15864 " Redacted form: General: plfill3(x, y, z)\n"
15865 " Perl/PDL: plfill3(n, x, y, z)\n"
15866 "\n"
15867 "\n"
15868 " This function is used in example 15. \n"
15869 "\n"
15870 "\n"
15871 "\n"
15872 "SYNOPSIS:\n"
15873 "\n"
15874 "plfill3(n, x, y, z)\n"
15875 "\n"
15876 "ARGUMENTS:\n"
15877 "\n"
15878 " n (PLINT, input) : Number of vertices in polygon. \n"
15879 "\n"
15880 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15881 " vertices. \n"
15882 "\n"
15883 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15884 " vertices. \n"
15885 "\n"
15886 " z (PLFLT *, input) : Pointer to array with z coordinates of\n"
15887 " vertices. \n"
15888 "\n"
15889 ""},
15890 { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
15891 "Draw linear gradient inside polygon \n"
15892 "\n"
15893 "DESCRIPTION:\n"
15894 "\n"
15895 " Draw a linear gradient using colour map 1 inside the polygon defined\n"
15896 " by the n points (\n"
15897 " x[i], \n"
15898 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15899 " polygon coordinates and the gradient angle are all expressed in world\n"
15900 " coordinates. The angle from the x axis for both the rotated\n"
15901 " coordinate system and the gradient vector is specified by angle. The\n"
15902 " magnitude of the gradient vector is the difference between the maximum\n"
15903 " and minimum values of x for the vertices in the rotated coordinate\n"
15904 " system. The origin of the gradient vector can be interpreted as being\n"
15905 " anywhere on the line corresponding to the minimum x value for the\n"
15906 " vertices in the rotated coordinate system. The distance along the\n"
15907 " gradient vector is linearly transformed to the independent variable of\n"
15908 " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
15909 " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15910 " colour corresponding to the independent variable of colour map 1. For\n"
15911 " more information about colour map 1 (see the PLplot documentation). \n"
15912 "\n"
15913 " Redacted form: plgradient(x,y,angle)\n"
15914 "\n"
15915 " This function is used in examples 25,30. \n"
15916 "\n"
15917 "\n"
15918 "\n"
15919 "SYNOPSIS:\n"
15920 "\n"
15921 "plgradient(n, x, y, angle)\n"
15922 "\n"
15923 "ARGUMENTS:\n"
15924 "\n"
15925 " n (PLINT, input) : Number of vertices in polygon. \n"
15926 "\n"
15927 " x (PLFLT *, input) : Pointer to array with x coordinates of\n"
15928 " vertices. \n"
15929 "\n"
15930 " y (PLFLT *, input) : Pointer to array with y coordinates of\n"
15931 " vertices. \n"
15932 "\n"
15933 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
15934 " axis. \n"
15935 "\n"
15936 ""},
15937 { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
15938 "Flushes the output stream \n"
15939 "\n"
15940 "DESCRIPTION:\n"
15941 "\n"
15942 " Flushes the output stream. Use sparingly, if at all. \n"
15943 "\n"
15944 " Redacted form: plflush()\n"
15945 "\n"
15946 " This function is used in examples 1,14. \n"
15947 "\n"
15948 "\n"
15949 "\n"
15950 "SYNOPSIS:\n"
15951 "\n"
15952 "plflush()\n"
15953 "\n"
15954 ""},
15955 { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
15956 "Set character font \n"
15957 "\n"
15958 "DESCRIPTION:\n"
15959 "\n"
15960 " Sets the default character font for subsequent character drawing. Also\n"
15961 " affects symbols produced by plpoin. This routine has no effect unless\n"
15962 " the extended character set is loaded (see plfontld). \n"
15963 "\n"
15964 " Redacted form: plfont(font)\n"
15965 "\n"
15966 " This function is used in examples 1,2,4,7,13,24,26. \n"
15967 "\n"
15968 "\n"
15969 "\n"
15970 "SYNOPSIS:\n"
15971 "\n"
15972 "plfont(font)\n"
15973 "\n"
15974 "ARGUMENTS:\n"
15975 "\n"
15976 " font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
15977 " and fastest) \n"
15978 " 2: Roman font \n"
15979 " 3: Italic font \n"
15980 " 4: Script font \n"
15981 "\n"
15982 ""},
15983 { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
15984 "Load character font \n"
15985 "\n"
15986 "DESCRIPTION:\n"
15987 "\n"
15988 " Sets the character set to use for subsequent character drawing. May\n"
15989 " be called before initializing PLplot. \n"
15990 "\n"
15991 " Redacted form: plfontld(set)\n"
15992 "\n"
15993 " This function is used in examples 1,7. \n"
15994 "\n"
15995 "\n"
15996 "\n"
15997 "SYNOPSIS:\n"
15998 "\n"
15999 "plfontld(set)\n"
16000 "\n"
16001 "ARGUMENTS:\n"
16002 "\n"
16003 " set (PLINT, input) : Specifies the character set to load: 0:\n"
16004 " Standard character set \n"
16005 " 1: Extended character set \n"
16006 "\n"
16007 ""},
16008 { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16009 "Get character default height and current (scaled) height \n"
16010 "\n"
16011 "DESCRIPTION:\n"
16012 "\n"
16013 " Get character default height and current (scaled) height. \n"
16014 "\n"
16015 " Redacted form: plgchr(p_def, p_ht)\n"
16016 "\n"
16017 " This function is used in example 23. \n"
16018 "\n"
16019 "\n"
16020 "\n"
16021 "SYNOPSIS:\n"
16022 "\n"
16023 "plgchr(p_def, p_ht)\n"
16024 "\n"
16025 "ARGUMENTS:\n"
16026 "\n"
16027 " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
16028 "\n"
16029 " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
16030 " height (mm). \n"
16031 "\n"
16032 ""},
16033 { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16034 "Returns 8-bit RGB values for given color from color map0 \n"
16035 "\n"
16036 "DESCRIPTION:\n"
16037 "\n"
16038 " Returns 8-bit RGB values (0-255) for given color from color map0 (see\n"
16039 " the PLplot documentation). Values are negative if an invalid color id\n"
16040 " is given. \n"
16041 "\n"
16042 " Redacted form: plgcol0(icol0, r, g, b)\n"
16043 "\n"
16044 " This function is used in example 2. \n"
16045 "\n"
16046 "\n"
16047 "\n"
16048 "SYNOPSIS:\n"
16049 "\n"
16050 "plgcol0(icol0, r, g, b)\n"
16051 "\n"
16052 "ARGUMENTS:\n"
16053 "\n"
16054 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16055 "\n"
16056 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16057 "\n"
16058 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16059 "\n"
16060 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16061 "\n"
16062 ""},
16063 { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16064 "Returns 8-bit RGB values and double alpha value for given color from color map0. \n"
16065 "\n"
16066 "DESCRIPTION:\n"
16067 "\n"
16068 " Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n"
16069 " for given color from color map0 (see the PLplot documentation). \n"
16070 " Values are negative if an invalid color id is given. \n"
16071 "\n"
16072 " This function is used in example 30. \n"
16073 "\n"
16074 "\n"
16075 "\n"
16076 "SYNOPSIS:\n"
16077 "\n"
16078 "plgcol0a(icol0, r, g, b, a)\n"
16079 "\n"
16080 "ARGUMENTS:\n"
16081 "\n"
16082 " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16083 "\n"
16084 " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16085 "\n"
16086 " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16087 "\n"
16088 " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16089 "\n"
16090 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16091 "\n"
16092 ""},
16093 { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16094 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16095 "\n"
16096 "ESCRIPTION:\n"
16097 "\n"
16098 " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16099 "\n"
16100 " Redacted form: plgcolbg(r, g, b)\n"
16101 "\n"
16102 " This function is used in example 31. \n"
16103 "\n"
16104 "\n"
16105 "\n"
16106 "YNOPSIS:\n"
16107 "\n"
16108 "lgcolbg(r, g, b)\n"
16109 "\n"
16110 "RGUMENTS:\n"
16111 "\n"
16112 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16113 " representing the degree of red in the color. \n"
16114 "\n"
16115 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16116 " representing the degree of green in the color. \n"
16117 "\n"
16118 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16119 " representing the degree of blue in the color. \n"
16120 "\n"
16121 ""},
16122 { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16123 "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n"
16124 "\n"
16125 "ESCRIPTION:\n"
16126 "\n"
16127 " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16128 " alpha value. \n"
16129 "\n"
16130 " This function is used in example 31. \n"
16131 "\n"
16132 "\n"
16133 "\n"
16134 "YNOPSIS:\n"
16135 "\n"
16136 "lgcolbga(r, g, b, a)\n"
16137 "\n"
16138 "RGUMENTS:\n"
16139 "\n"
16140 " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16141 " representing the degree of red in the color. \n"
16142 "\n"
16143 " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16144 " representing the degree of green in the color. \n"
16145 "\n"
16146 " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16147 " representing the degree of blue in the color. \n"
16148 "\n"
16149 " a (PLFLT *, output) : Pointer to PLFLT alpha value. \n"
16150 "\n"
16151 ""},
16152 { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16153 "Get the current device-compression setting \n"
16154 "\n"
16155 "DESCRIPTION:\n"
16156 "\n"
16157 " Get the current device-compression setting. This parameter is only\n"
16158 " used for drivers that provide compression. \n"
16159 "\n"
16160 " Redacted form: plgcompression(compression)\n"
16161 "\n"
16162 " This function is used in example 31. \n"
16163 "\n"
16164 "\n"
16165 "\n"
16166 "SYNOPSIS:\n"
16167 "\n"
16168 "plgcompression(compression)\n"
16169 "\n"
16170 "ARGUMENTS:\n"
16171 "\n"
16172 " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16173 " with the current device-compression setting. \n"
16174 "\n"
16175 ""},
16176 { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16177 "Get the current device (keyword) name \n"
16178 "\n"
16179 "DESCRIPTION:\n"
16180 "\n"
16181 " Get the current device (keyword) name. Note: you must have allocated\n"
16182 " space for this (80 characters is safe). \n"
16183 "\n"
16184 " Redacted form: plgdev(p_dev)\n"
16185 "\n"
16186 " This function is used in example 14. \n"
16187 "\n"
16188 "\n"
16189 "\n"
16190 "SYNOPSIS:\n"
16191 "\n"
16192 "plgdev(p_dev)\n"
16193 "\n"
16194 "ARGUMENTS:\n"
16195 "\n"
16196 " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16197 "\n"
16198 ""},
16199 { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16200 "Get parameters that define current device-space window \n"
16201 "\n"
16202 "DESCRIPTION:\n"
16203 "\n"
16204 " Get relative margin width, aspect ratio, and relative justification\n"
16205 " that define current device-space window. If plsdidev has not been\n"
16206 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16207 " p_jy will all be 0. \n"
16208 "\n"
16209 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16210 "\n"
16211 " This function is used in example 31. \n"
16212 "\n"
16213 "\n"
16214 "\n"
16215 "SYNOPSIS:\n"
16216 "\n"
16217 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16218 "\n"
16219 "ARGUMENTS:\n"
16220 "\n"
16221 " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16222 "\n"
16223 " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16224 "\n"
16225 " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16226 "\n"
16227 " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16228 "\n"
16229 ""},
16230 { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16231 "Get plot orientation \n"
16232 "\n"
16233 "DESCRIPTION:\n"
16234 "\n"
16235 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16236 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16237 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16238 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16239 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16240 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16241 " not been called the default value pointed to by p_rot will be 0. \n"
16242 "\n"
16243 " Redacted form: plgdiori(p_rot)\n"
16244 "\n"
16245 " This function is not used in any examples. \n"
16246 "\n"
16247 "\n"
16248 "\n"
16249 "SYNOPSIS:\n"
16250 "\n"
16251 "plgdiori(p_rot)\n"
16252 "\n"
16253 "ARGUMENTS:\n"
16254 "\n"
16255 " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16256 "\n"
16257 ""},
16258 { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16259 "Get parameters that define current plot-space window \n"
16260 "\n"
16261 "DESCRIPTION:\n"
16262 "\n"
16263 " Get relative minima and maxima that define current plot-space window.\n"
16264 " If plsdiplt has not been called the default values pointed to by\n"
16265 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16266 "\n"
16267 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16268 "\n"
16269 " This function is used in example 31. \n"
16270 "\n"
16271 "\n"
16272 "\n"
16273 "SYNOPSIS:\n"
16274 "\n"
16275 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16276 "\n"
16277 "ARGUMENTS:\n"
16278 "\n"
16279 " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16280 "\n"
16281 " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16282 "\n"
16283 " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16284 "\n"
16285 " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16286 "\n"
16287 ""},
16288 { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
16289 "Get family file parameters \n"
16290 "\n"
16291 "DESCRIPTION:\n"
16292 "\n"
16293 " Gets information about current family file, if familying is enabled. \n"
16294 " See the PLplot documentation for more information. \n"
16295 "\n"
16296 " Redacted form: plgfam(fam, num, bmax)\n"
16297 "\n"
16298 " This function is used in examples 14,31. \n"
16299 "\n"
16300 "\n"
16301 "\n"
16302 "SYNOPSIS:\n"
16303 "\n"
16304 "plgfam(fam, num, bmax)\n"
16305 "\n"
16306 "ARGUMENTS:\n"
16307 "\n"
16308 " fam (PLINT *, output) : Pointer to variable with the Boolean family\n"
16309 " flag value. If nonzero, familying is enabled. \n"
16310 "\n"
16311 " num (PLINT *, output) : Pointer to variable with the current family\n"
16312 " file number. \n"
16313 "\n"
16314 " bmax (PLINT *, output) : Pointer to variable with the maximum file\n"
16315 " size (in bytes) for a family file. \n"
16316 "\n"
16317 ""},
16318 { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
16319 "Get FCI (font characterization integer) \n"
16320 "\n"
16321 "DESCRIPTION:\n"
16322 "\n"
16323 " Gets information about the current font using the FCI approach. See\n"
16324 " the PLplot documentation for more information. \n"
16325 "\n"
16326 " Redacted form: plgfci(fci)\n"
16327 "\n"
16328 " This function is used in example 23. \n"
16329 "\n"
16330 "\n"
16331 "\n"
16332 "SYNOPSIS:\n"
16333 "\n"
16334 "plgfci(fci)\n"
16335 "\n"
16336 "ARGUMENTS:\n"
16337 "\n"
16338 " fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
16339 " integer) variable which is updated with current FCI value. \n"
16340 "\n"
16341 ""},
16342 { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
16343 "Get output file name \n"
16344 "\n"
16345 "DESCRIPTION:\n"
16346 "\n"
16347 " Gets the current output file name, if applicable. \n"
16348 "\n"
16349 " Redacted form: plgfnam(fnam)\n"
16350 "\n"
16351 " This function is used in example 31. \n"
16352 "\n"
16353 "\n"
16354 "\n"
16355 "SYNOPSIS:\n"
16356 "\n"
16357 "plgfnam(fnam)\n"
16358 "\n"
16359 "ARGUMENTS:\n"
16360 "\n"
16361 " fnam (char *, output) : Pointer to file name string (a preallocated\n"
16362 " string of 80 characters or more). \n"
16363 "\n"
16364 ""},
16365 { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
16366 "Get family, style and weight of the current font \n"
16367 "\n"
16368 "DESCRIPTION:\n"
16369 "\n"
16370 " Gets information about current font. See the PLplot documentation for\n"
16371 " more information on font selection. \n"
16372 "\n"
16373 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16374 "\n"
16375 " This function is used in example 23. \n"
16376 "\n"
16377 "\n"
16378 "\n"
16379 "SYNOPSIS:\n"
16380 "\n"
16381 "plgfont(p_family, p_style, p_weight)\n"
16382 "\n"
16383 "ARGUMENTS:\n"
16384 "\n"
16385 " p_family (PLINT *, output) : Pointer to variable with the current\n"
16386 " font family. The available values are given by the PL_FCI_*\n"
16387 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16388 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16389 " p_family is NULL then the font family is not returned. \n"
16390 "\n"
16391 " p_style (PLINT *, output) : Pointer to variable with the current\n"
16392 " font style. The available values are given by the PL_FCI_*\n"
16393 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16394 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16395 " font style is not returned. \n"
16396 "\n"
16397 " p_weight (PLINT *, output) : Pointer to variable with the current\n"
16398 " font weight. The available values are given by the PL_FCI_*\n"
16399 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16400 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16401 " returned. \n"
16402 "\n"
16403 ""},
16404 { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
16405 "Get the (current) run level \n"
16406 "\n"
16407 "DESCRIPTION:\n"
16408 "\n"
16409 " Get the (current) run level. Valid settings are: 0, uninitialized \n"
16410 " 1, initialized \n"
16411 " 2, viewport defined \n"
16412 " 3, world coordinates defined \n"
16413 "\n"
16414 "\n"
16415 " Redacted form: plglevel(p_level)\n"
16416 "\n"
16417 " This function is used in example 31. \n"
16418 "\n"
16419 "\n"
16420 "\n"
16421 "SYNOPSIS:\n"
16422 "\n"
16423 "plglevel(p_level)\n"
16424 "\n"
16425 "ARGUMENTS:\n"
16426 "\n"
16427 " p_level (PLINT *, output) : Pointer to the run level. \n"
16428 "\n"
16429 ""},
16430 { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
16431 "Get page parameters \n"
16432 "\n"
16433 "DESCRIPTION:\n"
16434 "\n"
16435 " Gets the current page configuration. The length and offset values are\n"
16436 " expressed in units that are specific to the current driver. For\n"
16437 " instance: screen drivers will usually interpret them as number of\n"
16438 " pixels, whereas printer drivers will usually use mm. \n"
16439 "\n"
16440 " Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16441 "\n"
16442 " This function is used in examples 14 and 31. \n"
16443 "\n"
16444 "\n"
16445 "\n"
16446 "SYNOPSIS:\n"
16447 "\n"
16448 "plgpage(xp, yp, xleng, yleng, xoff, yoff)\n"
16449 "\n"
16450 "ARGUMENTS:\n"
16451 "\n"
16452 " xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
16453 "\n"
16454 " yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n"
16455 "\n"
16456 " xleng (PLINT *, output) : Pointer to x page length value. \n"
16457 "\n"
16458 " yleng (PLINT *, output) : Pointer to y page length value. \n"
16459 "\n"
16460 " xoff (PLINT *, output) : Pointer to x page offset. \n"
16461 "\n"
16462 " yoff (PLINT *, output) : Pointer to y page offset. \n"
16463 "\n"
16464 ""},
16465 { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
16466 "Switch to graphics screen \n"
16467 "\n"
16468 "DESCRIPTION:\n"
16469 "\n"
16470 " Sets an interactive device to graphics mode, used in conjunction with\n"
16471 " pltext to allow graphics and text to be interspersed. On a device\n"
16472 " which supports separate text and graphics windows, this command causes\n"
16473 " control to be switched to the graphics window. If already in graphics\n"
16474 " mode, this command is ignored. It is also ignored on devices which\n"
16475 " only support a single window or use a different method for shifting\n"
16476 " focus. See also pltext. \n"
16477 "\n"
16478 " Redacted form: plgra()\n"
16479 "\n"
16480 " This function is used in example 1. \n"
16481 "\n"
16482 "\n"
16483 "\n"
16484 "SYNOPSIS:\n"
16485 "\n"
16486 "plgra()\n"
16487 "\n"
16488 ""},
16489 { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
16490 "Grid data from irregularly sampled data \n"
16491 "\n"
16492 "DESCRIPTION:\n"
16493 "\n"
16494 " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16495 " plots require data placed in a uniform grid. This function takes\n"
16496 " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16497 " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16498 " and yg[nptsy], and returns the gridded data into output array\n"
16499 " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
16500 " with the argument type which can have one parameter specified in\n"
16501 " argument data. \n"
16502 "\n"
16503 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16504 " Perl/PDL: Not available? \n"
16505 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16506 "\n"
16507 "\n"
16508 " This function is used in example 21. \n"
16509 "\n"
16510 "\n"
16511 "\n"
16512 "SYNOPSIS:\n"
16513 "\n"
16514 "plggriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16515 "\n"
16516 "ARGUMENTS:\n"
16517 "\n"
16518 " x (PLFLT *, input) : The input x array. \n"
16519 "\n"
16520 " y (PLFLT *, input) : The input y array. \n"
16521 "\n"
16522 " z (PLFLT *, input) : The input z array. Each triple x[i], y[i],\n"
16523 " z[i] represents one data sample coordinate. \n"
16524 "\n"
16525 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16526 " arrays. \n"
16527 "\n"
16528 " xg (PLFLT *, input) : The input array that specifies the grid\n"
16529 " spacing in the x direction. Usually xg has nptsx equally spaced\n"
16530 " values from the minimum to the maximum values of the x input\n"
16531 " array. \n"
16532 "\n"
16533 " nptsx (PLINT, input) : The number of points in the xg array. \n"
16534 "\n"
16535 " yg (PLFLT *, input) : The input array that specifies the grid\n"
16536 " spacing in the y direction. Similar to the xg parameter. \n"
16537 "\n"
16538 " nptsy (PLINT, input) : The number of points in the yg array. \n"
16539 "\n"
16540 " zg (PLFLT **, output) : The output array, where data lies in the\n"
16541 " regular grid specified by xg and yg. the zg array must exist or be\n"
16542 " allocated by the user prior to the call, and must have dimension\n"
16543 " zg[nptsx][nptsy]. \n"
16544 "\n"
16545 " type (PLINT, input) : The type of gridding algorithm to use, which\n"
16546 " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16547 " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16548 " GRID_NNI: Natural Neighbors Interpolation \n"
16549 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16550 " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16551 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16552 " Weighted \n"
16553 " For details of the algorithms read the source file plgridd.c. \n"
16554 "\n"
16555 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16556 " which can be specified through this argument. Currently, for\n"
16557 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16558 " use, the lower the value, the noisier (more local) the\n"
16559 " approximation is. \n"
16560 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16561 " range [1. .. 2.]. High values enable the usage of very thin\n"
16562 " triangles for interpolation, possibly resulting in error in\n"
16563 " the approximation. \n"
16564 " GRID_NNI, only weights greater than data will be accepted. If\n"
16565 " 0, all weights will be accepted. \n"
16566 "\n"
16567 ""},
16568 { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
16569 "Get current subpage parameters \n"
16570 "\n"
16571 "DESCRIPTION:\n"
16572 "\n"
16573 " Gets the size of the current subpage in millimeters measured from the\n"
16574 " bottom left hand corner of the output device page or screen. Can be\n"
16575 " used in conjunction with plsvpa for setting the size of a viewport in\n"
16576 " absolute coordinates (millimeters). \n"
16577 "\n"
16578 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16579 "\n"
16580 " This function is used in example 23. \n"
16581 "\n"
16582 "\n"
16583 "\n"
16584 "SYNOPSIS:\n"
16585 "\n"
16586 "plgspa(xmin, xmax, ymin, ymax)\n"
16587 "\n"
16588 "ARGUMENTS:\n"
16589 "\n"
16590 " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
16591 " hand edge of subpage in millimeters. \n"
16592 "\n"
16593 " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
16594 " hand edge of subpage in millimeters. \n"
16595 "\n"
16596 " ymin (PLFLT *, output) : Pointer to variable with position of\n"
16597 " bottom edge of subpage in millimeters. \n"
16598 "\n"
16599 " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
16600 " edge of subpage in millimeters. \n"
16601 "\n"
16602 ""},
16603 { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
16604 "Get current stream number \n"
16605 "\n"
16606 "DESCRIPTION:\n"
16607 "\n"
16608 " Gets the number of the current output stream. See also plsstrm. \n"
16609 "\n"
16610 " Redacted form: plgstrm(strm)\n"
16611 "\n"
16612 " This function is used in example 1,20. \n"
16613 "\n"
16614 "\n"
16615 "\n"
16616 "SYNOPSIS:\n"
16617 "\n"
16618 "plgstrm(strm)\n"
16619 "\n"
16620 "ARGUMENTS:\n"
16621 "\n"
16622 " strm (PLINT *, output) : Pointer to current stream value. \n"
16623 "\n"
16624 ""},
16625 { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
16626 "Get the current library version number \n"
16627 "\n"
16628 "DESCRIPTION:\n"
16629 "\n"
16630 " Get the current library version number. Note: you must have allocated\n"
16631 " space for this (80 characters is safe). \n"
16632 "\n"
16633 " Redacted form: plgver(p_ver)\n"
16634 "\n"
16635 " This function is used in example 1. \n"
16636 "\n"
16637 "\n"
16638 "\n"
16639 "SYNOPSIS:\n"
16640 "\n"
16641 "plgver(p_ver)\n"
16642 "\n"
16643 "ARGUMENTS:\n"
16644 "\n"
16645 " p_ver (char *, output) : Pointer to the current library version\n"
16646 " number. \n"
16647 "\n"
16648 ""},
16649 { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
16650 "Get viewport limits in normalized device coordinates \n"
16651 "\n"
16652 "DESCRIPTION:\n"
16653 "\n"
16654 " Get viewport limits in normalized device coordinates. \n"
16655 "\n"
16656 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16657 " Perl/PDL: Not available? \n"
16658 "\n"
16659 "\n"
16660 " This function is used in example 31. \n"
16661 "\n"
16662 "\n"
16663 "\n"
16664 "SYNOPSIS:\n"
16665 "\n"
16666 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16667 "\n"
16668 "ARGUMENTS:\n"
16669 "\n"
16670 " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16671 " device coordinate in x. \n"
16672 "\n"
16673 " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16674 " device coordinate in x. \n"
16675 "\n"
16676 " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
16677 " device coordinate in y. \n"
16678 "\n"
16679 " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
16680 " device coordinate in y. \n"
16681 "\n"
16682 ""},
16683 { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
16684 "Get viewport limits in world coordinates \n"
16685 "\n"
16686 "DESCRIPTION:\n"
16687 "\n"
16688 " Get viewport limits in world coordinates. \n"
16689 "\n"
16690 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16691 " Perl/PDL: Not available? \n"
16692 "\n"
16693 "\n"
16694 " This function is used in example 31. \n"
16695 "\n"
16696 "\n"
16697 "\n"
16698 "SYNOPSIS:\n"
16699 "\n"
16700 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16701 "\n"
16702 "ARGUMENTS:\n"
16703 "\n"
16704 " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
16705 " coordinate in x. \n"
16706 "\n"
16707 " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
16708 " coordinate in x. \n"
16709 "\n"
16710 " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
16711 " coordinate in y. \n"
16712 "\n"
16713 " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
16714 " coordinate in y. \n"
16715 "\n"
16716 ""},
16717 { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16718 "Get x axis parameters \n"
16719 "\n"
16720 "DESCRIPTION:\n"
16721 "\n"
16722 " Returns current values of the digmax and digits flags for the x axis. \n"
16723 " digits is updated after the plot is drawn, so this routine should only\n"
16724 " be called after the call to plbox (or plbox3) is complete. See the\n"
16725 " PLplot documentation for more information. \n"
16726 "\n"
16727 " Redacted form: plgxax(digmax, digits)\n"
16728 "\n"
16729 " This function is used in example 31. \n"
16730 "\n"
16731 "\n"
16732 "\n"
16733 "SYNOPSIS:\n"
16734 "\n"
16735 "plgxax(digmax, digits)\n"
16736 "\n"
16737 "ARGUMENTS:\n"
16738 "\n"
16739 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16740 " number of digits for the x axis. If nonzero, the printed label\n"
16741 " has been switched to a floating point representation when the\n"
16742 " number of digits exceeds digmax. \n"
16743 "\n"
16744 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16745 " number of digits for the numeric labels (x axis) from the last\n"
16746 " plot. \n"
16747 "\n"
16748 ""},
16749 { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16750 "Get y axis parameters \n"
16751 "\n"
16752 "DESCRIPTION:\n"
16753 "\n"
16754 " Identical to plgxax, except that arguments are flags for y axis. See\n"
16755 " the description of plgxax for more detail. \n"
16756 "\n"
16757 " Redacted form: plgyax(digmax, digits)\n"
16758 "\n"
16759 " This function is used in example 31. \n"
16760 "\n"
16761 "\n"
16762 "\n"
16763 "SYNOPSIS:\n"
16764 "\n"
16765 "plgyax(digmax, digits)\n"
16766 "\n"
16767 "ARGUMENTS:\n"
16768 "\n"
16769 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16770 " number of digits for the y axis. If nonzero, the printed label\n"
16771 " has been switched to a floating point representation when the\n"
16772 " number of digits exceeds digmax. \n"
16773 "\n"
16774 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16775 " number of digits for the numeric labels (y axis) from the last\n"
16776 " plot. \n"
16777 "\n"
16778 ""},
16779 { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16780 "Get z axis parameters \n"
16781 "\n"
16782 "DESCRIPTION:\n"
16783 "\n"
16784 " Identical to plgxax, except that arguments are flags for z axis. See\n"
16785 " the description of plgxax for more detail. \n"
16786 "\n"
16787 " Redacted form: plgzax(digmax, digits)\n"
16788 "\n"
16789 " This function is used in example 31. \n"
16790 "\n"
16791 "\n"
16792 "\n"
16793 "SYNOPSIS:\n"
16794 "\n"
16795 "plgzax(digmax, digits)\n"
16796 "\n"
16797 "ARGUMENTS:\n"
16798 "\n"
16799 " digmax (PLINT *, output) : Pointer to variable with the maximum\n"
16800 " number of digits for the z axis. If nonzero, the printed label\n"
16801 " has been switched to a floating point representation when the\n"
16802 " number of digits exceeds digmax. \n"
16803 "\n"
16804 " digits (PLINT *, output) : Pointer to variable with the actual\n"
16805 " number of digits for the numeric labels (z axis) from the last\n"
16806 " plot. \n"
16807 "\n"
16808 ""},
16809 { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
16810 "Plot a histogram from unbinned data \n"
16811 "\n"
16812 "DESCRIPTION:\n"
16813 "\n"
16814 " Plots a histogram from n data points stored in the array data. This\n"
16815 " routine bins the data into nbin bins equally spaced between datmin and\n"
16816 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16817 " opt allows, among other things, the histogram either to be plotted in\n"
16818 " an existing window or causes plhist to call plenv with suitable limits\n"
16819 " before plotting the histogram. \n"
16820 "\n"
16821 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16822 "\n"
16823 " This function is used in example 5. \n"
16824 "\n"
16825 "\n"
16826 "\n"
16827 "SYNOPSIS:\n"
16828 "\n"
16829 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16830 "\n"
16831 "ARGUMENTS:\n"
16832 "\n"
16833 " n (PLINT, input) : Number of data points. \n"
16834 "\n"
16835 " data (PLFLT *, input) : Pointer to array with values of the n data\n"
16836 " points. \n"
16837 "\n"
16838 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
16839 "\n"
16840 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
16841 "\n"
16842 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16843 " divide the interval xmin to xmax. \n"
16844 "\n"
16845 " opt (PLINT, input) : Is a combination of several flags:\n"
16846 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16847 " the histogram data, the outer bins are expanded to fill up the\n"
16848 " entire x-axis, data outside the given extremes are assigned to the\n"
16849 " outer bins and bins of zero height are simply drawn. \n"
16850 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16851 " to fit the histogram data, without this flag, plenv is called\n"
16852 " to set the world coordinates. \n"
16853 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16854 " extremes are not taken into account. This option should\n"
16855 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16856 " properly present the data. \n"
16857 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16858 " size as the ones inside. \n"
16859 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16860 " (there is a gap for such bins). \n"
16861 "\n"
16862 ""},
16863 { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
16864 "Convert HLS color to RGB \n"
16865 "\n"
16866 "DESCRIPTION:\n"
16867 "\n"
16868 " Convert HLS color coordinates to RGB. \n"
16869 "\n"
16870 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16871 " Perl/PDL: Not available? Implemented as plhls? \n"
16872 "\n"
16873 "\n"
16874 " This function is used in example 2. \n"
16875 "\n"
16876 "\n"
16877 "\n"
16878 "SYNOPSIS:\n"
16879 "\n"
16880 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16881 "\n"
16882 "ARGUMENTS:\n"
16883 "\n"
16884 " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
16885 "\n"
16886 " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
16887 " of the colour cone (0.0-1.0) \n"
16888 "\n"
16889 " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
16890 " radius of the colour cone (0.0-1.0) \n"
16891 "\n"
16892 " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
16893 " colour \n"
16894 "\n"
16895 " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
16896 " colour \n"
16897 "\n"
16898 " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
16899 " colour \n"
16900 "\n"
16901 ""},
16902 { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
16903 "Initialize PLplot \n"
16904 "\n"
16905 "DESCRIPTION:\n"
16906 "\n"
16907 " Initializing the plotting package. The program prompts for the device\n"
16908 " keyword or number of the desired output device. Hitting a RETURN in\n"
16909 " response to the prompt is the same as selecting the first device. \n"
16910 " plinit will issue no prompt if either the device was specified\n"
16911 " previously (via command line flag, the plsetopt function, or the\n"
16912 " plsdev function), or if only one device is enabled when PLplot is\n"
16913 " installed. If subpages have been specified, the output device is\n"
16914 " divided into nx by ny subpages, each of which may be used\n"
16915 " independently. If plinit is called again during a program, the\n"
16916 " previously opened file will be closed. The subroutine pladv is used\n"
16917 " to advance from one subpage to the next. \n"
16918 "\n"
16919 " Redacted form: plinit()\n"
16920 "\n"
16921 " This function is used in all of the examples. \n"
16922 "\n"
16923 "\n"
16924 "\n"
16925 "SYNOPSIS:\n"
16926 "\n"
16927 "plinit()\n"
16928 "\n"
16929 ""},
16930 { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
16931 "Draw a line between two points \n"
16932 "\n"
16933 "DESCRIPTION:\n"
16934 "\n"
16935 " Joins the point (\n"
16936 " x1, \n"
16937 " y1) to (\n"
16938 " x2, \n"
16939 " y2). \n"
16940 "\n"
16941 " Redacted form: pljoin(x1,y1,x2,y2)\n"
16942 "\n"
16943 " This function is used in examples 3,14. \n"
16944 "\n"
16945 "\n"
16946 "\n"
16947 "SYNOPSIS:\n"
16948 "\n"
16949 "pljoin(x1, y1, x2, y2)\n"
16950 "\n"
16951 "ARGUMENTS:\n"
16952 "\n"
16953 " x1 (PLFLT, input) : x coordinate of first point. \n"
16954 "\n"
16955 " y1 (PLFLT, input) : y coordinate of first point. \n"
16956 "\n"
16957 " x2 (PLFLT, input) : x coordinate of second point. \n"
16958 "\n"
16959 " y2 (PLFLT, input) : y coordinate of second point. \n"
16960 "\n"
16961 ""},
16962 { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
16963 "Simple routine to write labels \n"
16964 "\n"
16965 "DESCRIPTION:\n"
16966 "\n"
16967 " Routine for writing simple labels. Use plmtex for more complex labels. \n"
16968 "\n"
16969 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
16970 "\n"
16971 " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
16972 "\n"
16973 "\n"
16974 "\n"
16975 "SYNOPSIS:\n"
16976 "\n"
16977 "pllab(xlabel, ylabel, tlabel)\n"
16978 "\n"
16979 "ARGUMENTS:\n"
16980 "\n"
16981 " xlabel (const char *, input) : Label for horizontal axis. \n"
16982 "\n"
16983 " ylabel (const char *, input) : Label for vertical axis. \n"
16984 "\n"
16985 " tlabel (const char *, input) : Title of graph. \n"
16986 "\n"
16987 ""},
16988 { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
16989 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
16990 "\n"
16991 "DESCRIPTION:\n"
16992 "\n"
16993 " Routine for creating a discrete plot legend with a plotted filled box,\n"
16994 " line, and/or line of symbols for each annotated legend entry. (See\n"
16995 " plcolorbar for similar functionality for creating continuous color\n"
16996 " bars.) The arguments of pllegend provide control over the location\n"
16997 " and size of the legend as well as the location and characteristics of\n"
16998 " the elements (most of which are optional) within that legend. The\n"
16999 " resulting legend is clipped at the boundaries of the current subpage. \n"
17000 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17001 " defined in the documentation of the position parameter.) \n"
17002 "\n"
17003 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17004 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17005 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17006 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17007 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17008 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17009 "\n"
17010 " This function is used in examples 4, 26, and 33. \n"
17011 "\n"
17012 "\n"
17013 "\n"
17014 "SYNOPSIS:\n"
17015 "\n"
17016 "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"
17017 "\n"
17018 "ARGUMENTS:\n"
17019 "\n"
17020 " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
17021 " contains (after the call) the legend width in adopted coordinates.\n"
17022 " This quantity is calculated from plot_width, text_offset, ncolumn\n"
17023 " (possibly modified inside the routine depending on nlegend and\n"
17024 " nrow), and the length (calculated internally) of the longest text\n"
17025 " string. \n"
17026 "\n"
17027 " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
17028 " contains (after the call) the legend height in adopted\n"
17029 " coordinates. This quantity is calculated from text_scale,\n"
17030 " text_spacing, and nrow (possibly modified inside the routine\n"
17031 " depending on nlegend and nrow). \n"
17032 "\n"
17033 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17034 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17035 " on the left of the legend and the plotted area on the right.\n"
17036 " Otherwise, put the text area on the right of the legend and the\n"
17037 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17038 " plot a (semi-transparent) background for the legend. If the\n"
17039 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17040 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17041 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17042 " plot the resulting array of legend entries in row-major order.\n"
17043 " Otherwise, plot the legend entries in column-major order. \n"
17044 "\n"
17045 " position (PLINT, input) : position contains bits which control the\n"
17046 " overall position of the legend and the definition of the adopted\n"
17047 " coordinates used for positions just like what is done for the\n"
17048 " position argument for plcolorbar. However, note that the defaults\n"
17049 " for the position bits (see below) are different than the\n"
17050 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17051 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17052 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17053 " the 16 possible standard positions (the 4 corners and centers of\n"
17054 " the 4 sides for both the inside and outside cases) of the legend\n"
17055 " relative to the adopted coordinate system. The corner positions\n"
17056 " are specified by the appropriate combination of two of the\n"
17057 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17058 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17059 " value of one of those bits. The adopted coordinates are\n"
17060 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17061 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17062 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17063 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17064 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17065 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17066 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17067 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
17068 "\n"
17069 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17070 " coordinates from the specified standard position of the legend.\n"
17071 " For positive x, the direction of motion away from the standard\n"
17072 " position is inward/outward from the standard corner positions or\n"
17073 " standard left or right positions if the\n"
17074 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17075 " For the standard top or bottom positions, the direction of motion\n"
17076 " is toward positive X. \n"
17077 "\n"
17078 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17079 " coordinates from the specified standard position of the legend.\n"
17080 " For positive y, the direction of motion away from the standard\n"
17081 " position is inward/outward from the standard corner positions or\n"
17082 " standard top or bottom positions if the\n"
17083 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17084 " For the standard left or right positions, the direction of motion\n"
17085 " is toward positive Y. \n"
17086 "\n"
17087 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17088 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17089 " symbols are drawn) of the legend. \n"
17090 "\n"
17091 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17092 " legend (PL_LEGEND_BACKGROUND). \n"
17093 "\n"
17094 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17095 " for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17096 "\n"
17097 " bb_style (PLINT, input) : The pllsty style number for the\n"
17098 " bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n"
17099 "\n"
17100 " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17101 " the legend (PL_LEGEND_BACKGROUND). \n"
17102 "\n"
17103 " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17104 " for the legend (PL_LEGEND_BACKGROUND). \n"
17105 "\n"
17106 " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17107 " vertical height of the legend in adopted coordinates is calculated\n"
17108 " internally from nlegend, text_scale (see below), and text_spacing\n"
17109 " (see below). \n"
17110 "\n"
17111 " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17112 " options to control each individual plotted area corresponding to a\n"
17113 " legend entry. If the \n"
17114 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17115 " area. If the \n"
17116 " PL_LEGEND_COLOR_BOX, \n"
17117 " PL_LEGEND_LINE, and/or \n"
17118 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17119 " entry is plotted with a colored box; a line; and/or a line of\n"
17120 " symbols. \n"
17121 "\n"
17122 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17123 " area in units of character width. N.B. The total horizontal\n"
17124 " width of the legend in adopted coordinates is calculated\n"
17125 " internally from \n"
17126 " plot_width (see above), \n"
17127 " text_offset, and length (calculated internally) of the longest text\n"
17128 " string. \n"
17129 "\n"
17130 " text_scale (PLFLT, input) : Character height scale for text\n"
17131 " annotations. N.B. The total vertical height of the legend in\n"
17132 " adopted coordinates is calculated internally from \n"
17133 " nlegend (see above), \n"
17134 " text_scale, and \n"
17135 " text_spacing (see below). \n"
17136 "\n"
17137 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17138 " character height from one legend entry to the next. N.B. The\n"
17139 " total vertical height of the legend in adopted coordinates is\n"
17140 " calculated internally from \n"
17141 " nlegend (see above), \n"
17142 " text_scale (see above), and \n"
17143 " text_spacing. \n"
17144 "\n"
17145 " text_justification (PLFLT, input) : Justification parameter used\n"
17146 " for text justification. The most common values of\n"
17147 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17148 " is left justified, centred, or right justified within the text\n"
17149 " area, but other values are allowed as well. \n"
17150 "\n"
17151 " text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n"
17152 " colors. \n"
17153 "\n"
17154 " text (const char *const *, input) : Array of nlegend text string\n"
17155 " annotations. \n"
17156 "\n"
17157 " box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n"
17158 " for the discrete colored boxes (\n"
17159 " PL_LEGEND_COLOR_BOX). \n"
17160 "\n"
17161 " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17162 " (plpsty indices) for the discrete colored boxes (\n"
17163 " PL_LEGEND_COLOR_BOX). \n"
17164 "\n"
17165 " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17166 " of fraction of character height) for the height of the discrete\n"
17167 " colored boxes (\n"
17168 " PL_LEGEND_COLOR_BOX). \n"
17169 "\n"
17170 " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17171 " widths for the patterns specified by box_patterns (\n"
17172 " PL_LEGEND_COLOR_BOX). \n"
17173 "\n"
17174 " line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n"
17175 " colors (\n"
17176 " PL_LEGEND_LINE). \n"
17177 "\n"
17178 " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17179 " (plsty indices) (\n"
17180 " PL_LEGEND_LINE). \n"
17181 "\n"
17182 " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17183 " PL_LEGEND_LINE). \n"
17184 "\n"
17185 " symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n"
17186 " symbol colors (\n"
17187 " PL_LEGEND_SYMBOL). \n"
17188 "\n"
17189 " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17190 " values for the symbol height (\n"
17191 " PL_LEGEND_SYMBOL). \n"
17192 "\n"
17193 " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17194 " symbols to be drawn across the width of the plotted area (\n"
17195 " PL_LEGEND_SYMBOL). \n"
17196 "\n"
17197 " symbols (const char *const *, input) : Array of nlegend symbols\n"
17198 " (plpoin indices) (\n"
17199 " PL_LEGEND_SYMBOL). \n"
17200 "\n"
17201 ""},
17202 { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
17203 "Plot color bar for image, shade or gradient plots \n"
17204 "\n"
17205 "DESCRIPTION:\n"
17206 "\n"
17207 " Routine for creating a continuous color bar for image, shade, or\n"
17208 " gradient plots. (See pllegend for similar functionality for creating\n"
17209 " legends with discrete elements). The arguments of plcolorbar provide\n"
17210 " control over the location and size of the color bar as well as the\n"
17211 " location and characteristics of the elements (most of which are\n"
17212 " optional) within that color bar. The resulting color bar is clipped\n"
17213 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17214 " system used for some of the parameters is defined in the documentation\n"
17215 " of the position parameter.) \n"
17216 "\n"
17217 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17218 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17219 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17220 " labels, axis_opts, ticks, sub_ticks, values)\n"
17221 "\n"
17222 " This function is used in examples 16 and 33. \n"
17223 "\n"
17224 "\n"
17225 "\n"
17226 "SYNOPSIS:\n"
17227 "\n"
17228 "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"
17229 "\n"
17230 "ARGUMENTS:\n"
17231 "\n"
17232 " p_colorbar_width (PLFLT *, output) : Pointer to a location which\n"
17233 " contains (after the call) the labelled and decorated color bar\n"
17234 " width in adopted coordinates. \n"
17235 "\n"
17236 " p_colorbar_height (PLFLT *, output) : Pointer to a location which\n"
17237 " contains (after the call) the labelled and decorated color bar\n"
17238 " height in adopted coordinates. \n"
17239 "\n"
17240 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17241 " color bar. The orientation (direction of the maximum value) of\n"
17242 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17243 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17244 " specified, the default orientation is toward the top if the\n"
17245 " colorbar is placed on the left or right of the viewport or toward\n"
17246 " the right if the colorbar is placed on the top or bottom of the\n"
17247 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17248 " (semi-transparent) background for the color bar. If the\n"
17249 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17250 " color bar. The type of color bar must be specified with one of\n"
17251 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17252 " more than one of those bits is set only the first one in the above\n"
17253 " list is honored. The position of the (optional) label/title can be\n"
17254 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17255 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17256 " will be drawn. If more than one of this list of bits is specified,\n"
17257 " only the first one on the list is honored. End-caps for the color\n"
17258 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17259 " If a particular color bar cap option is not specified then no cap\n"
17260 " will be drawn for that end. As a special case for\n"
17261 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17262 " specified. If this option is provided then any tick marks and tick\n"
17263 " labels will be placed at the breaks between shaded segments. TODO:\n"
17264 " This should be expanded to support custom placement of tick marks\n"
17265 " and tick labels at custom value locations for any color bar type. \n"
17266 "\n"
17267 " position (PLINT, input) : position contains bits which control the\n"
17268 " overall position of the color bar and the definition of the\n"
17269 " adopted coordinates used for positions just like what is done for\n"
17270 " the position argument for pllegend. However, note that the\n"
17271 " defaults for the position bits (see below) are different than the\n"
17272 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17273 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17274 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17275 " the 16 possible standard positions (the 4 corners and centers of\n"
17276 " the 4 sides for both the inside and outside cases) of the color\n"
17277 " bar relative to the adopted coordinate system. The corner\n"
17278 " positions are specified by the appropriate combination of two of\n"
17279 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17280 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17281 " value of one of those bits. The adopted coordinates are\n"
17282 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17283 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17284 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17285 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17286 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17287 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17288 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17289 " PL_POSITION_VIEWPORT. \n"
17290 "\n"
17291 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17292 " coordinates from the specified standard position of the color bar.\n"
17293 " For positive x, the direction of motion away from the standard\n"
17294 " position is inward/outward from the standard corner positions or\n"
17295 " standard left or right positions if the\n"
17296 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17297 " For the standard top or bottom positions, the direction of motion\n"
17298 " is toward positive X. \n"
17299 "\n"
17300 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17301 " coordinates from the specified standard position of the color bar.\n"
17302 " For positive y, the direction of motion away from the standard\n"
17303 " position is inward/outward from the standard corner positions or\n"
17304 " standard top or bottom positions if the\n"
17305 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17306 " For the standard left or right positions, the direction of motion\n"
17307 " is toward positive Y. \n"
17308 "\n"
17309 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17310 " the X direction in adopted coordinates. \n"
17311 "\n"
17312 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17313 " the Y direction in adopted coordinates. \n"
17314 "\n"
17315 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17316 " color bar (PL_COLORBAR_BACKGROUND). \n"
17317 "\n"
17318 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17319 " for the color bar (PL_COLORBAR_BOUNDING_BOX). \n"
17320 "\n"
17321 " bb_style (PLINT, input) : The pllsty style number for the\n"
17322 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n"
17323 "\n"
17324 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17325 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n"
17326 "\n"
17327 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17328 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n"
17329 "\n"
17330 " cont_color (PLINT, input) : The cmap0 contour color for\n"
17331 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17332 " it will be interpreted according to the design of plshades. \n"
17333 "\n"
17334 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17335 " plots. This is passed directly to plshades, so it will be\n"
17336 " interpreted according to the design of plshades. \n"
17337 "\n"
17338 " n_labels (PLINT, input) : Number of labels to place around the\n"
17339 " color bar. \n"
17340 "\n"
17341 " label_opts (const PLINT *, input) : Options for each of \n"
17342 " n_labels labels. \n"
17343 "\n"
17344 " labels (const char *const *, input) : n_labels text labels for the\n"
17345 " color bar. No label is drawn if no label position is specified\n"
17346 " with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17347 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17348 " corresponding label_opts field. \n"
17349 "\n"
17350 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17351 " value must be greater than 0. It is typically 1 (numerical axis\n"
17352 " labels are provided for one of the long edges of the color bar),\n"
17353 " but it can be larger if multiple numerical axis labels for the\n"
17354 " long edges of the color bar are desired. \n"
17355 "\n"
17356 " axis_opts (const char *const *, input) : An array of n_axes axis\n"
17357 " options (interpreted as for plbox) for the color bar's axis\n"
17358 " definitions. \n"
17359 "\n"
17360 " ticks (PLFLT *, input) : An array of n_axes values of the spacing\n"
17361 " of the major tick marks (interpreted as for plbox) for the color\n"
17362 " bar's axis definitions. \n"
17363 "\n"
17364 " sub_ticks (PLINT *, input) : An array of n_axes values of the\n"
17365 " number of subticks (interpreted as for plbox) for the color bar's\n"
17366 " axis definitions. \n"
17367 "\n"
17368 " n_values (PLINT, input) : An array containing the number of\n"
17369 " elements in each of the n_axes rows of the two-dimensional values\n"
17370 " array. \n"
17371 "\n"
17372 " values (PLFLT *const *, input) : A two-dimensional array containing\n"
17373 " the numeric values for the data range represented by the color\n"
17374 " bar. For a row index of i_axis (where 0 < i_axis < n_axes), the\n"
17375 " number of elements in the row is specified by n_values[i_axis].\n"
17376 " For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of\n"
17377 " elements is 2, and the corresponding row elements of the values\n"
17378 " array are the minimum and maximum value represented by the\n"
17379 " colorbar. For PL_COLORBAR_SHADE, the number and values of the\n"
17380 " elements of a row of the values array is interpreted the same as\n"
17381 " the nlevel and clevel arguments of plshades. \n"
17382 "\n"
17383 ""},
17384 { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
17385 "Sets the 3D position of the light source \n"
17386 "\n"
17387 "DESCRIPTION:\n"
17388 "\n"
17389 " Sets the 3D position of the light source for use with plsurf3d. \n"
17390 "\n"
17391 " Redacted form: pllightsource(x, y, z)\n"
17392 "\n"
17393 " This function is used in example 8. \n"
17394 "\n"
17395 "\n"
17396 "\n"
17397 "SYNOPSIS:\n"
17398 "\n"
17399 "pllightsource(x, y, z)\n"
17400 "\n"
17401 "ARGUMENTS:\n"
17402 "\n"
17403 " x (PLFLT, input) : X-coordinate of the light source. \n"
17404 "\n"
17405 " y (PLFLT, input) : Y-coordinate of the light source. \n"
17406 "\n"
17407 " z (PLFLT, input) : Z-coordinate of the light source. \n"
17408 "\n"
17409 ""},
17410 { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
17411 "Draw a line \n"
17412 "\n"
17413 "DESCRIPTION:\n"
17414 "\n"
17415 " Draws line defined by n points in x and y. \n"
17416 "\n"
17417 " Redacted form: plline(x, y)\n"
17418 "\n"
17419 " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17420 "\n"
17421 "\n"
17422 "\n"
17423 "SYNOPSIS:\n"
17424 "\n"
17425 "plline(n, x, y)\n"
17426 "\n"
17427 "ARGUMENTS:\n"
17428 "\n"
17429 " n (PLINT, input) : Number of points defining line. \n"
17430 "\n"
17431 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17432 "\n"
17433 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17434 "\n"
17435 ""},
17436 { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
17437 "Draw a line in 3 space \n"
17438 "\n"
17439 "DESCRIPTION:\n"
17440 "\n"
17441 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17442 " first set up the viewport, the 2d viewing window (in world\n"
17443 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17444 " more info. \n"
17445 "\n"
17446 " Redacted form: plline3(x, y, z)\n"
17447 "\n"
17448 " This function is used in example 18. \n"
17449 "\n"
17450 "\n"
17451 "\n"
17452 "SYNOPSIS:\n"
17453 "\n"
17454 "plline3(n, x, y, z)\n"
17455 "\n"
17456 "ARGUMENTS:\n"
17457 "\n"
17458 " n (PLINT, input) : Number of points defining line. \n"
17459 "\n"
17460 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
17461 "\n"
17462 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
17463 "\n"
17464 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
17465 "\n"
17466 ""},
17467 { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
17468 "Select line style \n"
17469 "\n"
17470 "DESCRIPTION:\n"
17471 "\n"
17472 " This sets the line style according to one of eight predefined patterns\n"
17473 " (also see plstyl). \n"
17474 "\n"
17475 " Redacted form: pllsty(n)\n"
17476 "\n"
17477 " This function is used in examples 9,12,22,25. \n"
17478 "\n"
17479 "\n"
17480 "\n"
17481 "SYNOPSIS:\n"
17482 "\n"
17483 "pllsty(n)\n"
17484 "\n"
17485 "ARGUMENTS:\n"
17486 "\n"
17487 " n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n"
17488 " continuous line, line style 2 is a line with short dashes and\n"
17489 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17490 " 4 has long dashes and short gaps and so on. \n"
17491 "\n"
17492 ""},
17493 { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
17494 "Plot surface mesh \n"
17495 "\n"
17496 "DESCRIPTION:\n"
17497 "\n"
17498 " Plots a surface mesh within the environment set up by plw3d. The\n"
17499 " surface is defined by the two-dimensional array z[\n"
17500 " nx][\n"
17501 " ny], the point z[i][j] being the value of the function at (\n"
17502 " x[i], \n"
17503 " y[j]). Note that the points in arrays x and y do not need to be\n"
17504 " equally spaced, but must be stored in ascending order. The parameter\n"
17505 " opt controls the way in which the surface is displayed. For further\n"
17506 " details see the PLplot documentation. \n"
17507 "\n"
17508 " Redacted form: plmesh(x, y, z, opt)\n"
17509 "\n"
17510 " This function is used in example 11. \n"
17511 "\n"
17512 "\n"
17513 "\n"
17514 "SYNOPSIS:\n"
17515 "\n"
17516 "plmesh(x, y, z, nx, ny, opt)\n"
17517 "\n"
17518 "ARGUMENTS:\n"
17519 "\n"
17520 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17521 " the function is evaluated. \n"
17522 "\n"
17523 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17524 " the function is evaluated. \n"
17525 "\n"
17526 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17527 " with set of function values. \n"
17528 "\n"
17529 " nx (PLINT, input) : Number of x values at which function is\n"
17530 " evaluated. \n"
17531 "\n"
17532 " ny (PLINT, input) : Number of y values at which function is\n"
17533 " evaluated. \n"
17534 "\n"
17535 " opt (PLINT, input) : Determines the way in which the surface is\n"
17536 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17537 " function of x for each value of y[j]. \n"
17538 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17539 " for each value of x[i]. \n"
17540 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17541 " at which function is defined. \n"
17542 "\n"
17543 ""},
17544 { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
17545 "Magnitude colored plot surface mesh with contour. \n"
17546 "\n"
17547 "DESCRIPTION:\n"
17548 "\n"
17549 " Identical to plmesh but with extra functionalities: the surface mesh\n"
17550 " can be colored accordingly to the current z value being plotted, a\n"
17551 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17552 " drawn between the plotted function border and the base XY plane. \n"
17553 "\n"
17554 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17555 "\n"
17556 " This function is used in example 11. \n"
17557 "\n"
17558 "\n"
17559 "\n"
17560 "SYNOPSIS:\n"
17561 "\n"
17562 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17563 "\n"
17564 "ARGUMENTS:\n"
17565 "\n"
17566 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17567 " the function is evaluated. \n"
17568 "\n"
17569 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17570 " the function is evaluated. \n"
17571 "\n"
17572 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17573 " with set of function values. \n"
17574 "\n"
17575 " nx (PLINT, input) : Number of x values at which function is\n"
17576 " evaluated. \n"
17577 "\n"
17578 " ny (PLINT, input) : Number of y values at which function is\n"
17579 " evaluated. \n"
17580 "\n"
17581 " opt (PLINT, input) : Determines the way in which the surface is\n"
17582 " represented. To specify more than one option just add the options,\n"
17583 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17584 " showing z as a function of x for each value of y[j]. \n"
17585 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17586 " for each value of x[i]. \n"
17587 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17588 " at which function is defined. \n"
17589 " opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17590 " the z value being plotted. The color is used from the current\n"
17591 " color map 1. \n"
17592 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17593 " using parameters \n"
17594 " nlevel and \n"
17595 " clevel. \n"
17596 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17597 " the borders of the plotted function. \n"
17598 "\n"
17599 "\n"
17600 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17601 " contour level spacing. \n"
17602 "\n"
17603 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17604 "\n"
17605 ""},
17606 { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
17607 "Creates a new stream and makes it the default \n"
17608 "\n"
17609 "DESCRIPTION:\n"
17610 "\n"
17611 " Creates a new stream and makes it the default. Differs from using\n"
17612 " plsstrm, in that a free stream number is found, and returned.\n"
17613 " Unfortunately, I have to start at stream 1 and work upward, since\n"
17614 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17615 " that no initial, library-opening call is required. So stream 0 must\n"
17616 " be preallocated, and there is no simple way of determining whether it\n"
17617 " is already in use or not. \n"
17618 "\n"
17619 " Redacted form: plmkstrm(p_strm)\n"
17620 "\n"
17621 " This function is used in examples 1,20. \n"
17622 "\n"
17623 "\n"
17624 "\n"
17625 "SYNOPSIS:\n"
17626 "\n"
17627 "plmkstrm(p_strm)\n"
17628 "\n"
17629 "ARGUMENTS:\n"
17630 "\n"
17631 " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
17632 " stream. \n"
17633 "\n"
17634 ""},
17635 { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
17636 "Write text relative to viewport boundaries \n"
17637 "\n"
17638 "DESCRIPTION:\n"
17639 "\n"
17640 " Writes text at a specified position relative to the viewport\n"
17641 " boundaries. Text may be written inside or outside the viewport, but\n"
17642 " is clipped at the subpage boundaries. The reference point of a string\n"
17643 " lies along a line passing through the string at half the height of a\n"
17644 " capital letter. The position of the reference point along this line\n"
17645 " is determined by just, and the position of the reference point\n"
17646 " relative to the viewport is set by disp and pos. \n"
17647 "\n"
17648 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17649 " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17650 "\n"
17651 "\n"
17652 " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17653 "\n"
17654 "\n"
17655 "\n"
17656 "SYNOPSIS:\n"
17657 "\n"
17658 "plmtex(side, disp, pos, just, text)\n"
17659 "\n"
17660 "ARGUMENTS:\n"
17661 "\n"
17662 " side (const char *, input) : Specifies the side of the viewport\n"
17663 " along which the text is to be written. The string must be one of:\n"
17664 " b: Bottom of viewport, text written parallel to edge. \n"
17665 " bv: Bottom of viewport, text written at right angles to edge. \n"
17666 " l: Left of viewport, text written parallel to edge. \n"
17667 " lv: Left of viewport, text written at right angles to edge. \n"
17668 " r: Right of viewport, text written parallel to edge. \n"
17669 " rv: Right of viewport, text written at right angles to edge. \n"
17670 " t: Top of viewport, text written parallel to edge. \n"
17671 " tv: Top of viewport, text written at right angles to edge. \n"
17672 "\n"
17673 "\n"
17674 " disp (PLFLT, input) : Position of the reference point of string,\n"
17675 " measured outwards from the specified viewport edge in units of the\n"
17676 " current character height. Use negative disp to write within the\n"
17677 " viewport. \n"
17678 "\n"
17679 " pos (PLFLT, input) : Position of the reference point of string\n"
17680 " along the specified edge, expressed as a fraction of the length of\n"
17681 " the edge. \n"
17682 "\n"
17683 " just (PLFLT, input) : Specifies the position of the string relative\n"
17684 " to its reference point. If just=0., the reference point is at the\n"
17685 " left and if just=1., it is at the right of the string. Other\n"
17686 " values of just give intermediate justifications. \n"
17687 "\n"
17688 " text (const char *, input) : The string to be written out. \n"
17689 "\n"
17690 ""},
17691 { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
17692 "Write text relative to viewport boundaries in 3D plots. \n"
17693 "\n"
17694 "DESCRIPTION:\n"
17695 "\n"
17696 " Writes text at a specified position relative to the viewport\n"
17697 " boundaries. Text may be written inside or outside the viewport, but\n"
17698 " is clipped at the subpage boundaries. The reference point of a string\n"
17699 " lies along a line passing through the string at half the height of a\n"
17700 " capital letter. The position of the reference point along this line\n"
17701 " is determined by just, and the position of the reference point\n"
17702 " relative to the viewport is set by disp and pos. \n"
17703 "\n"
17704 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17705 "\n"
17706 " This function is used in example 28. \n"
17707 "\n"
17708 "\n"
17709 "\n"
17710 "SYNOPSIS:\n"
17711 "\n"
17712 "plmtex3(side, disp, pos, just, text)\n"
17713 "\n"
17714 "ARGUMENTS:\n"
17715 "\n"
17716 " side (const char *, input) : Specifies the side of the viewport\n"
17717 " along which the text is to be written. The string should contain\n"
17718 " one or more of the following characters: [xyz][ps][v]. Only one\n"
17719 " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17720 " both the X and Y axes. x: Label the X axis. \n"
17721 " y: Label the Y axis. \n"
17722 " z: Label the Z axis. \n"
17723 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17724 " For X it is the axis that starts at y-min. For Y it is the\n"
17725 " axis that starts at x-min. \n"
17726 " s: Label the secondary axis. \n"
17727 " v: Draw the text perpendicular to the axis. \n"
17728 "\n"
17729 "\n"
17730 " disp (PLFLT, input) : Position of the reference point of string,\n"
17731 " measured outwards from the specified viewport edge in units of the\n"
17732 " current character height. Use negative disp to write within the\n"
17733 " viewport. \n"
17734 "\n"
17735 " pos (PLFLT, input) : Position of the reference point of string\n"
17736 " along the specified edge, expressed as a fraction of the length of\n"
17737 " the edge. \n"
17738 "\n"
17739 " just (PLFLT, input) : Specifies the position of the string relative\n"
17740 " to its reference point. If just=0., the reference point is at the\n"
17741 " left and if just=1., it is at the right of the string. Other\n"
17742 " values of just give intermediate justifications. \n"
17743 "\n"
17744 " text (const char *, input) : The string to be written out. \n"
17745 "\n"
17746 ""},
17747 { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
17748 "Plot 3-d surface plot \n"
17749 "\n"
17750 "DESCRIPTION:\n"
17751 "\n"
17752 " Plots a three dimensional surface plot within the environment set up\n"
17753 " by plw3d. The surface is defined by the two-dimensional array z[\n"
17754 " nx][\n"
17755 " ny], the point z[i][j] being the value of the function at (\n"
17756 " x[i], \n"
17757 " y[j]). Note that the points in arrays x and y do not need to be\n"
17758 " equally spaced, but must be stored in ascending order. The parameter\n"
17759 " opt controls the way in which the surface is displayed. For further\n"
17760 " details see the PLplot documentation. The only difference between\n"
17761 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17762 " while plot3d only draws the surface as viewed from the top. \n"
17763 "\n"
17764 " Redacted form: plot3d(x, y, z, opt, side)\n"
17765 "\n"
17766 " This function is used in examples 11,21. \n"
17767 "\n"
17768 "\n"
17769 "\n"
17770 "SYNOPSIS:\n"
17771 "\n"
17772 "plot3d(x, y, z, nx, ny, opt, side)\n"
17773 "\n"
17774 "ARGUMENTS:\n"
17775 "\n"
17776 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17777 " the function is evaluated. \n"
17778 "\n"
17779 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17780 " the function is evaluated. \n"
17781 "\n"
17782 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17783 " with set of function values. \n"
17784 "\n"
17785 " nx (PLINT, input) : Number of x values at which function is\n"
17786 " evaluated. \n"
17787 "\n"
17788 " ny (PLINT, input) : Number of y values at which function is\n"
17789 " evaluated. \n"
17790 "\n"
17791 " opt (PLINT, input) : Determines the way in which the surface is\n"
17792 " represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17793 " function of x for each value of y[j]. \n"
17794 " opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17795 " for each value of x[i]. \n"
17796 " opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17797 " at which function is defined. \n"
17798 "\n"
17799 "\n"
17800 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17801 " should be draw on the figure. If side is true sides are drawn,\n"
17802 " otherwise no sides are drawn. \n"
17803 "\n"
17804 ""},
17805 { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
17806 "Magnitude colored plot surface with contour. \n"
17807 "\n"
17808 "DESCRIPTION:\n"
17809 "\n"
17810 " Identical to plot3d but with extra functionalities: the surface mesh\n"
17811 " can be colored accordingly to the current z value being plotted, a\n"
17812 " contour plot can be drawn at the base XY plane, and a curtain can be\n"
17813 " drawn between the plotted function border and the base XY plane. The\n"
17814 " arguments are identical to plmeshc. The only difference between\n"
17815 " plmeshc and plot3dc is that plmeshc draws the bottom side of the\n"
17816 " surface, while plot3dc only draws the surface as viewed from the top. \n"
17817 "\n"
17818 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17819 " Perl/PDL: Not available? \n"
17820 "\n"
17821 "\n"
17822 " This function is used in example 21. \n"
17823 "\n"
17824 "\n"
17825 "\n"
17826 "SYNOPSIS:\n"
17827 "\n"
17828 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17829 "\n"
17830 ""},
17831 { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, NULL},
17832 { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
17833 "Plot shaded 3-d surface plot \n"
17834 "\n"
17835 "DESCRIPTION:\n"
17836 "\n"
17837 " Plots a three dimensional shaded surface plot within the environment\n"
17838 " set up by plw3d. The surface is defined by the two-dimensional array\n"
17839 " z[\n"
17840 " nx][\n"
17841 " ny], the point z[i][j] being the value of the function at (\n"
17842 " x[i], \n"
17843 " y[j]). Note that the points in arrays x and y do not need to be\n"
17844 " equally spaced, but must be stored in ascending order. For further\n"
17845 " details see the PLplot documentation. \n"
17846 "\n"
17847 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
17848 "\n"
17849 " This function is not used in any examples. \n"
17850 "\n"
17851 "\n"
17852 "\n"
17853 "SYNOPSIS:\n"
17854 "\n"
17855 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17856 "\n"
17857 "ARGUMENTS:\n"
17858 "\n"
17859 " x (PLFLT *, input) : Pointer to set of x coordinate values at which\n"
17860 " the function is evaluated. \n"
17861 "\n"
17862 " y (PLFLT *, input) : Pointer to set of y coordinate values at which\n"
17863 " the function is evaluated. \n"
17864 "\n"
17865 " z (PLFLT **, input) : Pointer to a vectored two-dimensional array\n"
17866 " with set of function values. \n"
17867 "\n"
17868 " nx (PLINT, input) : Number of x values at which function is\n"
17869 " evaluated. \n"
17870 "\n"
17871 " ny (PLINT, input) : Number of y values at which function is\n"
17872 " evaluated. \n"
17873 "\n"
17874 " opt (PLINT, input) : Determines the way in which the surface is\n"
17875 " represented. To specify more than one option just add the options,\n"
17876 " e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
17877 " connecting points at which function is defined. \n"
17878 " opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17879 " using parameters \n"
17880 " nlevel and \n"
17881 " clevel. \n"
17882 " opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
17883 " using parameters \n"
17884 " nlevel and \n"
17885 " clevel. \n"
17886 " opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17887 " the borders of the plotted function. \n"
17888 " opt=MAG_COLOR: the surface is colored according to the value\n"
17889 " of Z; if MAG_COLOR is not used, then the default the surface\n"
17890 " is colored according to the intensity of the reflected light\n"
17891 " in the surface from a light source whose position is set using\n"
17892 " pllightsource. \n"
17893 "\n"
17894 "\n"
17895 " clevel (PLFLT *, input) : Pointer to the array that defines the\n"
17896 " contour level spacing. \n"
17897 "\n"
17898 " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
17899 "\n"
17900 ""},
17901 { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, NULL},
17902 { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
17903 "Parse command-line arguments \n"
17904 "\n"
17905 "DESCRIPTION:\n"
17906 "\n"
17907 " Parse command-line arguments. \n"
17908 "\n"
17909 " plparseopts removes all recognized flags (decreasing argc\n"
17910 " accordingly), so that invalid input may be readily detected. It can\n"
17911 " also be used to process user command line flags. The user can merge\n"
17912 " an option table of type PLOptionTable into the internal option table\n"
17913 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
17914 " the external table(s) be parsed by calling plClearOpts before\n"
17915 " plMergeOpts. \n"
17916 "\n"
17917 " The default action taken by plparseopts is as follows: \n"
17918 " Returns with an error if an unrecognized option or badly formed\n"
17919 " option-value pair are encountered. \n"
17920 " Returns immediately (return code 0) when the first non-option command\n"
17921 " line argument is found. \n"
17922 " Returns with the return code of the option handler, if one was called.\n"
17923 " \n"
17924 " Deletes command line arguments from argv list as they are found, and\n"
17925 " decrements argc accordingly. \n"
17926 " Does not show \"invisible\" options in usage or help messages. \n"
17927 " Assumes the program name is contained in argv[0]. \n"
17928 "\n"
17929 " These behaviors may be controlled through the \n"
17930 " mode argument. \n"
17931 "\n"
17932 " Redacted form: General: plparseopts(argv, mode)\n"
17933 " Perl/PDL: Not available? \n"
17934 "\n"
17935 "\n"
17936 " This function is used in all of the examples. \n"
17937 "\n"
17938 "\n"
17939 "\n"
17940 "SYNOPSIS:\n"
17941 "\n"
17942 "int plparseopts(p_argc, argv, mode)\n"
17943 "\n"
17944 "ARGUMENTS:\n"
17945 "\n"
17946 " p_argc (int *, input) : pointer to number of arguments. \n"
17947 "\n"
17948 " argv (char **, input) : Pointer to character array containing\n"
17949 " *p_argc command-line arguments. \n"
17950 "\n"
17951 " mode (PLINT, input) : Parsing mode with the following\n"
17952 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
17953 " and all error messages enabled, including program exit when an\n"
17954 " error occurs. Anything on the command line that isn't recognized\n"
17955 " as a valid option or option argument is flagged as an error. \n"
17956 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
17957 " of errors. \n"
17958 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
17959 " arguments. \n"
17960 " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
17961 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
17962 " pointer to the program name. \n"
17963 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
17964 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
17965 " unrecognized arguments. \n"
17966 "\n"
17967 ""},
17968 { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
17969 "Set area fill pattern \n"
17970 "\n"
17971 "DESCRIPTION:\n"
17972 "\n"
17973 " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
17974 " parallel lines with specified inclinations and spacings. The\n"
17975 " arguments to this routine are the number of sets to use (1 or 2)\n"
17976 " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
17977 " specifying the inclinations in tenths of a degree and the spacing in\n"
17978 " micrometers. (also see plpsty) \n"
17979 "\n"
17980 " Redacted form: General: plpat(inc, del)\n"
17981 " Perl/PDL: plpat(nlin, inc, del)\n"
17982 "\n"
17983 "\n"
17984 " This function is used in example 15. \n"
17985 "\n"
17986 "\n"
17987 "\n"
17988 "SYNOPSIS:\n"
17989 "\n"
17990 "plpat(nlin, inc, del)\n"
17991 "\n"
17992 "ARGUMENTS:\n"
17993 "\n"
17994 " nlin (PLINT, input) : Number of sets of lines making up the\n"
17995 " pattern, either 1 or 2. \n"
17996 "\n"
17997 " inc (PLINT *, input) : Pointer to array with nlin elements.\n"
17998 " Specifies the line inclination in tenths of a degree. (Should be\n"
17999 " between -900 and 900). \n"
18000 "\n"
18001 " del (PLINT *, input) : Pointer to array with nlin elements.\n"
18002 " Specifies the spacing in micrometers between the lines making up\n"
18003 " the pattern. \n"
18004 "\n"
18005 ""},
18006 { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
18007 "Draw a line between two points, accounting for coordinate transforms. \n"
18008 "\n"
18009 "DESCRIPTION:\n"
18010 "\n"
18011 " Joins the point (\n"
18012 " x1, \n"
18013 " y1) to (\n"
18014 " x2, \n"
18015 " y2). If a global coordinate transform is defined then the line is\n"
18016 " broken in to n segments to approximate the path. If no transform is\n"
18017 " defined then this simply acts like a call to pljoin. \n"
18018 "\n"
18019 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18020 "\n"
18021 " This function is used in example 22. \n"
18022 "\n"
18023 "\n"
18024 "\n"
18025 "SYNOPSIS:\n"
18026 "\n"
18027 "plpath(n, x1, y1, x2, y2)\n"
18028 "\n"
18029 "ARGUMENTS:\n"
18030 "\n"
18031 " n (PLINT, input) : number of points to use to approximate the path. \n"
18032 "\n"
18033 " x1 (PLFLT, input) : x coordinate of first point. \n"
18034 "\n"
18035 " y1 (PLFLT, input) : y coordinate of first point. \n"
18036 "\n"
18037 " x2 (PLFLT, input) : x coordinate of second point. \n"
18038 "\n"
18039 " y2 (PLFLT, input) : y coordinate of second point. \n"
18040 "\n"
18041 ""},
18042 { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
18043 "Plot a glyph at the specified points \n"
18044 "\n"
18045 "DESCRIPTION:\n"
18046 "\n"
18047 " Plot a glyph at the specified points. (This function is largely\n"
18048 " superseded by plstring which gives access to many[!] more glyphs.)\n"
18049 " code=-1 means try to just draw a point. Right now it's just a move\n"
18050 " and a draw at the same place. Not ideal, since a sufficiently\n"
18051 " intelligent output device may optimize it away, or there may be faster\n"
18052 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18053 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18054 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18055 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18056 " code <= 127 the corresponding printable ASCII character is plotted. \n"
18057 "\n"
18058 " Redacted form: plpoin(x, y, code)\n"
18059 "\n"
18060 " This function is used in examples 1,6,14,29. \n"
18061 "\n"
18062 "\n"
18063 "\n"
18064 "SYNOPSIS:\n"
18065 "\n"
18066 "plpoin(n, x, y, code)\n"
18067 "\n"
18068 "ARGUMENTS:\n"
18069 "\n"
18070 " n (PLINT, input) : Number of points in the x and y arrays. \n"
18071 "\n"
18072 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
18073 " points. \n"
18074 "\n"
18075 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
18076 " points. \n"
18077 "\n"
18078 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18079 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18080 " each of the n points. \n"
18081 "\n"
18082 ""},
18083 { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
18084 "Plot a glyph at the specified 3D points \n"
18085 "\n"
18086 "DESCRIPTION:\n"
18087 "\n"
18088 " Plot a glyph at the specified 3D points. (This function is largely\n"
18089 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18090 " Set up the call to this function similar to what is done for plline3.\n"
18091 " code=-1 means try to just draw a point. Right now it's just a move\n"
18092 " and a draw at the same place. Not ideal, since a sufficiently\n"
18093 " intelligent output device may optimize it away, or there may be faster\n"
18094 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18095 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18096 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18097 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18098 " code <= 127 the corresponding printable ASCII character is plotted. \n"
18099 "\n"
18100 " Redacted form: plpoin3(x, y, z, code)\n"
18101 "\n"
18102 " This function is not used in any example. \n"
18103 "\n"
18104 "\n"
18105 "\n"
18106 "SYNOPSIS:\n"
18107 "\n"
18108 "plpoin3(n, x, y, z, code)\n"
18109 "\n"
18110 "ARGUMENTS:\n"
18111 "\n"
18112 " n (PLINT, input) : Number of points in the x and y arrays. \n"
18113 "\n"
18114 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
18115 " points. \n"
18116 "\n"
18117 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
18118 " points. \n"
18119 "\n"
18120 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
18121 " points. \n"
18122 "\n"
18123 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18124 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18125 " each of the n points. \n"
18126 "\n"
18127 ""},
18128 { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
18129 "Draw a polygon in 3 space \n"
18130 "\n"
18131 "DESCRIPTION:\n"
18132 "\n"
18133 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18134 " like plline3, but differs from that function in that plpoly3 attempts\n"
18135 " to determine if the polygon is viewable depending on the order of the\n"
18136 " points within the arrays and the value of ifcc. If the back of\n"
18137 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18138 " you want, then use plline3 instead. \n"
18139 "\n"
18140 " The points are assumed to be in a plane, and the directionality of the\n"
18141 " plane is determined from the first three points. Additional points do\n"
18142 " not have to lie on the plane defined by the first three, but if they\n"
18143 " do not, then the determination of visibility obviously can't be 100%\n"
18144 " accurate... So if you're 3 space polygons are too far from planar,\n"
18145 " consider breaking them into smaller polygons. 3 points define a plane\n"
18146 " :-). \n"
18147 "\n"
18148 " Bugs: If one of the first two segments is of zero length, or if they\n"
18149 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18150 " being correct. Avoid such situations :-). See x18c.c for an example\n"
18151 " of this problem. (Search for 20.1). \n"
18152 "\n"
18153 " Redacted form: plpoly3(x, y, z, code)\n"
18154 "\n"
18155 " This function is used in example 18. \n"
18156 "\n"
18157 "\n"
18158 "\n"
18159 "SYNOPSIS:\n"
18160 "\n"
18161 "plpoly3(n, x, y, z, draw, ifcc)\n"
18162 "\n"
18163 "ARGUMENTS:\n"
18164 "\n"
18165 " n (PLINT, input) : Number of points defining line. \n"
18166 "\n"
18167 " x (PLFLT *, input) : Pointer to array with x coordinates of points. \n"
18168 "\n"
18169 " y (PLFLT *, input) : Pointer to array with y coordinates of points. \n"
18170 "\n"
18171 " z (PLFLT *, input) : Pointer to array with z coordinates of points. \n"
18172 "\n"
18173 " draw (PLBOOL *, input) : Pointer to array which controls drawing\n"
18174 " the segments of the polygon. If draw[i] is true, then the polygon\n"
18175 " segment from index [i] to [i+1] is drawn, otherwise, not. \n"
18176 "\n"
18177 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18178 " polygon is determined by assuming the points are laid out in a\n"
18179 " counter-clockwise order. Otherwise, the directionality of the\n"
18180 " polygon is determined by assuming the points are laid out in a\n"
18181 " clockwise order. \n"
18182 "\n"
18183 ""},
18184 { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
18185 "Set precision in numeric labels \n"
18186 "\n"
18187 "DESCRIPTION:\n"
18188 "\n"
18189 " Sets the number of places after the decimal point in numeric labels. \n"
18190 "\n"
18191 " Redacted form: plprec(set, prec)\n"
18192 "\n"
18193 " This function is used in example 29. \n"
18194 "\n"
18195 "\n"
18196 "\n"
18197 "SYNOPSIS:\n"
18198 "\n"
18199 "plprec(set, prec)\n"
18200 "\n"
18201 "ARGUMENTS:\n"
18202 "\n"
18203 " set (PLINT, input) : If set is equal to 0 then PLplot automatically\n"
18204 " determines the number of places to use after the decimal point in\n"
18205 " numeric labels (like those used to label axes). If set is 1 then\n"
18206 " prec sets the number of places. \n"
18207 "\n"
18208 " prec (PLINT, input) : The number of characters to draw after the\n"
18209 " decimal point in numeric labels. \n"
18210 "\n"
18211 ""},
18212 { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
18213 "Select area fill pattern \n"
18214 "\n"
18215 "DESCRIPTION:\n"
18216 "\n"
18217 " Select one of eight predefined area fill patterns to use (also see\n"
18218 " plpat). Setting the fill style to 0 gives a solid fill. \n"
18219 "\n"
18220 " Redacted form: plpsty(n)\n"
18221 "\n"
18222 " This function is used in examples 12,13,15,16,25. \n"
18223 "\n"
18224 "\n"
18225 "\n"
18226 "SYNOPSIS:\n"
18227 "\n"
18228 "plpsty(n)\n"
18229 "\n"
18230 "ARGUMENTS:\n"
18231 "\n"
18232 " n (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
18233 " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
18234 " consists of lines at 45 degrees angle (upward), and so on. \n"
18235 "\n"
18236 ""},
18237 { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
18238 "Write text inside the viewport \n"
18239 "\n"
18240 "DESCRIPTION:\n"
18241 "\n"
18242 " Writes text at a specified position and inclination within the\n"
18243 " viewport. Text is clipped at the viewport boundaries. The reference\n"
18244 " point of a string lies along a line passing through the string at half\n"
18245 " the height of a capital letter. The position of the reference point\n"
18246 " along this line is determined by just, the reference point is placed\n"
18247 " at world coordinates (\n"
18248 " x, \n"
18249 " y) within the viewport. The inclination of the string is specified in\n"
18250 " terms of differences of world coordinates making it easy to write text\n"
18251 " parallel to a line in a graph. \n"
18252 "\n"
18253 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18254 "\n"
18255 " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
18256 "\n"
18257 "\n"
18258 "\n"
18259 "SYNOPSIS:\n"
18260 "\n"
18261 "plptex(x, y, dx, dy, just, text)\n"
18262 "\n"
18263 "ARGUMENTS:\n"
18264 "\n"
18265 " x (PLFLT, input) : x coordinate of reference point of string. \n"
18266 "\n"
18267 " y (PLFLT, input) : y coordinate of reference point of string. \n"
18268 "\n"
18269 " dx (PLFLT, input) : Together with dy, this specifies the\n"
18270 " inclination of the string. The baseline of the string is parallel\n"
18271 " to a line joining (\n"
18272 " x, \n"
18273 " y) to (\n"
18274 " x+\n"
18275 " dx, \n"
18276 " y+\n"
18277 " dy). \n"
18278 "\n"
18279 " dy (PLFLT, input) : Together with dx, this specifies the\n"
18280 " inclination of the string. \n"
18281 "\n"
18282 " just (PLFLT, input) : Specifies the position of the string relative\n"
18283 " to its reference point. If just=0., the reference point is at the\n"
18284 " left and if just=1., it is at the right of the string. Other\n"
18285 " values of just give intermediate justifications. \n"
18286 "\n"
18287 " text (const char *, input) : The string to be written out. \n"
18288 "\n"
18289 ""},
18290 { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
18291 "Write text inside the viewport of a 3D plot. \n"
18292 "\n"
18293 "DESCRIPTION:\n"
18294 "\n"
18295 " Writes text at a specified position and inclination and with a\n"
18296 " specified shear within the viewport. Text is clipped at the viewport\n"
18297 " boundaries. The reference point of a string lies along a line passing\n"
18298 " through the string at half the height of a capital letter. The\n"
18299 " position of the reference point along this line is determined by just,\n"
18300 " and the reference point is placed at world coordinates (\n"
18301 " x, \n"
18302 " y, \n"
18303 " z) within the viewport. The inclination and shear of the string is\n"
18304 " specified in terms of differences of world coordinates making it easy\n"
18305 " to write text parallel to a line in a graph. \n"
18306 "\n"
18307 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18308 "\n"
18309 " This function is used in example 28. \n"
18310 "\n"
18311 "\n"
18312 "\n"
18313 "SYNOPSIS:\n"
18314 "\n"
18315 "plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18316 "\n"
18317 "ARGUMENTS:\n"
18318 "\n"
18319 " x (PLFLT, input) : x coordinate of reference point of string. \n"
18320 "\n"
18321 " y (PLFLT, input) : y coordinate of reference point of string. \n"
18322 "\n"
18323 " z (PLFLT, input) : z coordinate of reference point of string. \n"
18324 "\n"
18325 " dx (PLFLT, input) : Together with dy and \n"
18326 " dz, this specifies the inclination of the string. The baseline of\n"
18327 " the string is parallel to a line joining (\n"
18328 " x, \n"
18329 " y, \n"
18330 " z) to (\n"
18331 " x+\n"
18332 " dx, \n"
18333 " y+\n"
18334 " dy, \n"
18335 " z+\n"
18336 " dz). \n"
18337 "\n"
18338 " dy (PLFLT, input) : Together with dx and \n"
18339 " dz, this specifies the inclination of the string. \n"
18340 "\n"
18341 " dz (PLFLT, input) : Together with dx and \n"
18342 " dy, this specifies the inclination of the string. \n"
18343 "\n"
18344 " sx (PLFLT, input) : Together with sy and \n"
18345 " sz, this specifies the shear of the string. The string is sheared so\n"
18346 " that the characters are vertically parallel to a line joining (\n"
18347 " x, \n"
18348 " y, \n"
18349 " z) to (\n"
18350 " x+\n"
18351 " sx, \n"
18352 " y+\n"
18353 " sy, \n"
18354 " z+\n"
18355 " sz). If sx = \n"
18356 " sy = \n"
18357 " sz = 0.) then the text is not sheared. \n"
18358 "\n"
18359 " sy (PLFLT, input) : Together with sx and \n"
18360 " sz, this specifies shear of the string. \n"
18361 "\n"
18362 " sz (PLFLT, input) : Together with sx and \n"
18363 " sy, this specifies shear of the string. \n"
18364 "\n"
18365 " just (PLFLT, input) : Specifies the position of the string relative\n"
18366 " to its reference point. If just=0., the reference point is at the\n"
18367 " left and if just=1., it is at the right of the string. Other\n"
18368 " values of just give intermediate justifications. \n"
18369 "\n"
18370 " text (const char *, input) : The string to be written out. \n"
18371 "\n"
18372 ""},
18373 { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
18374 "Random number generator returning a real random number in the range [0,1]. \n"
18375 "\n"
18376 "DESCRIPTION:\n"
18377 "\n"
18378 " Random number generator returning a real random number in the range\n"
18379 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18380 " / compilers provide their own random number generator, and so this is\n"
18381 " provided purely for convenience and to give a consistent random number\n"
18382 " generator across all languages supported by PLplot. This is\n"
18383 " particularly useful for comparing results from the test suite of\n"
18384 " examples. \n"
18385 "\n"
18386 " Redacted form: plrandd()\n"
18387 "\n"
18388 " This function is used in examples 17,21. \n"
18389 "\n"
18390 "\n"
18391 "\n"
18392 "SYNOPSIS:\n"
18393 "\n"
18394 "plrandd()\n"
18395 "\n"
18396 ""},
18397 { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
18398 "Replays contents of plot buffer to current device/file \n"
18399 "\n"
18400 "DESCRIPTION:\n"
18401 "\n"
18402 " Replays contents of plot buffer to current device/file. \n"
18403 "\n"
18404 " Redacted form: plreplot()\n"
18405 "\n"
18406 " This function is used in example 1,20. \n"
18407 "\n"
18408 "\n"
18409 "\n"
18410 "SYNOPSIS:\n"
18411 "\n"
18412 "plreplot()\n"
18413 "\n"
18414 ""},
18415 { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
18416 "Convert RGB color to HLS \n"
18417 "\n"
18418 "DESCRIPTION:\n"
18419 "\n"
18420 " Convert RGB color coordinates to HLS \n"
18421 "\n"
18422 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18423 " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18424 "\n"
18425 "\n"
18426 " This function is used in example 2. \n"
18427 "\n"
18428 "\n"
18429 "\n"
18430 "SYNOPSIS:\n"
18431 "\n"
18432 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18433 "\n"
18434 "ARGUMENTS:\n"
18435 "\n"
18436 " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
18437 "\n"
18438 " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
18439 "\n"
18440 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
18441 "\n"
18442 " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
18443 " cone (0.0-360.0) \n"
18444 "\n"
18445 " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
18446 " fraction of the axis of the colour cone (0.0-1.0) \n"
18447 "\n"
18448 " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
18449 " fraction of the radius of the colour cone (0.0-1.0) \n"
18450 "\n"
18451 ""},
18452 { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
18453 "Set character size \n"
18454 "\n"
18455 "DESCRIPTION:\n"
18456 "\n"
18457 " This sets up the size of all subsequent characters drawn. The actual\n"
18458 " height of a character is the product of the default character size and\n"
18459 " a scaling factor. \n"
18460 "\n"
18461 " Redacted form: plschr(def, scale)\n"
18462 "\n"
18463 " This function is used in example 2,13,23,24. \n"
18464 "\n"
18465 "\n"
18466 "\n"
18467 "SYNOPSIS:\n"
18468 "\n"
18469 "plschr(def, scale)\n"
18470 "\n"
18471 "ARGUMENTS:\n"
18472 "\n"
18473 " def (PLFLT, input) : The default height of a character in\n"
18474 " millimeters, should be set to zero if the default height is to\n"
18475 " remain unchanged. \n"
18476 "\n"
18477 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18478 " actual character height. \n"
18479 "\n"
18480 ""},
18481 { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
18482 "Set color map0 colors by 8-bit RGB values \n"
18483 "\n"
18484 "DESCRIPTION:\n"
18485 "\n"
18486 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18487 " documentation). This sets the entire color map -- only as many colors\n"
18488 " as specified will be allocated. \n"
18489 "\n"
18490 " Redacted form: plscmap0(r, g, b, ncol0)\n"
18491 "\n"
18492 " This function is used in examples 2,24. \n"
18493 "\n"
18494 "\n"
18495 "\n"
18496 "SYNOPSIS:\n"
18497 "\n"
18498 "plscmap0(r, g, b, ncol0)\n"
18499 "\n"
18500 "ARGUMENTS:\n"
18501 "\n"
18502 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18503 " integers (0-255) representing the degree of red in the color. \n"
18504 "\n"
18505 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18506 " integers (0-255) representing the degree of green in the color. \n"
18507 "\n"
18508 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18509 " integers (0-255) representing the degree of blue in the color. \n"
18510 "\n"
18511 " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18512 "\n"
18513 ""},
18514 { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
18515 "Set color map0 colors by 8-bit RGB values and double alpha value. \n"
18516 "\n"
18517 "DESCRIPTION:\n"
18518 "\n"
18519 " Set color map0 colors using 8-bit RGB values (see the PLplot\n"
18520 " documentation) and floating point alpha value. This sets the entire\n"
18521 " color map -- only as many colors as specified will be allocated. \n"
18522 "\n"
18523 " This function is used in examples 30. \n"
18524 "\n"
18525 "\n"
18526 "\n"
18527 "SYNOPSIS:\n"
18528 "\n"
18529 "plscmap0a(r, g, b, a, ncol0)\n"
18530 "\n"
18531 "ARGUMENTS:\n"
18532 "\n"
18533 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18534 " integers (0-255) representing the degree of red in the color. \n"
18535 "\n"
18536 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18537 " integers (0-255) representing the degree of green in the color. \n"
18538 "\n"
18539 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18540 " integers (0-255) representing the degree of blue in the color. \n"
18541 "\n"
18542 " a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n"
18543 " - 1.0) representing the transparency of the color. \n"
18544 "\n"
18545 " ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n"
18546 " arrays. \n"
18547 "\n"
18548 ""},
18549 { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
18550 "Set number of colors in color map0 \n"
18551 "\n"
18552 "DESCRIPTION:\n"
18553 "\n"
18554 " Set number of colors in color map0 (see the PLplot documentation).\n"
18555 " Allocate (or reallocate) color map0, and fill with default values for\n"
18556 " those colors not previously allocated. The first 16 default colors are\n"
18557 " given in the plcol0 documentation. For larger indices the default\n"
18558 " color is red. \n"
18559 "\n"
18560 " The drivers are not guaranteed to support more than 16 colors. \n"
18561 "\n"
18562 " Redacted form: plscmap0n(ncol0)\n"
18563 "\n"
18564 " This function is used in examples 15,16,24. \n"
18565 "\n"
18566 "\n"
18567 "\n"
18568 "SYNOPSIS:\n"
18569 "\n"
18570 "plscmap0n(ncol0)\n"
18571 "\n"
18572 "ARGUMENTS:\n"
18573 "\n"
18574 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18575 " the map0 palette. If this number is zero or less, then the value\n"
18576 " from the previous call to plscmap0n is used and if there is no\n"
18577 " previous call, then a default value is used. \n"
18578 "\n"
18579 ""},
18580 { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
18581 "Set color map1 colors using 8-bit RGB values \n"
18582 "\n"
18583 "DESCRIPTION:\n"
18584 "\n"
18585 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18586 " documentation). This also sets the number of colors. \n"
18587 "\n"
18588 " Redacted form: plscmap1(r, g, b, ncol1)\n"
18589 "\n"
18590 " This function is used in example 31. \n"
18591 "\n"
18592 "\n"
18593 "\n"
18594 "SYNOPSIS:\n"
18595 "\n"
18596 "plscmap1(r, g, b, ncol1)\n"
18597 "\n"
18598 "ARGUMENTS:\n"
18599 "\n"
18600 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18601 " integers (0-255) representing the degree of red in the color. \n"
18602 "\n"
18603 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18604 " integers (0-255) representing the degree of green in the color. \n"
18605 "\n"
18606 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18607 " integers (0-255) representing the degree of blue in the color. \n"
18608 "\n"
18609 " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
18610 "\n"
18611 ""},
18612 { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
18613 "Set color map1 colors using 8-bit RGB values and double alpha values. \n"
18614 "\n"
18615 "DESCRIPTION:\n"
18616 "\n"
18617 " Set color map1 colors using 8-bit RGB values (see the PLplot\n"
18618 " documentation) and double alpha values. This also sets the number of\n"
18619 " colors.\n"
18620 "\n"
18621 " This function is used in example 31. \n"
18622 "\n"
18623 "\n"
18624 "\n"
18625 "SYNOPSIS:\n"
18626 "\n"
18627 "plscmap1a(r, g, b, a, ncol1)\n"
18628 "\n"
18629 "ARGUMENTS:\n"
18630 "\n"
18631 " r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18632 " integers (0-255) representing the degree of red in the color. \n"
18633 "\n"
18634 " g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18635 " integers (0-255) representing the degree of green in the color. \n"
18636 "\n"
18637 " b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n"
18638 " integers (0-255) representing the degree of blue in the color. \n"
18639 "\n"
18640 " a (PLFLT *, input) : Pointer to array with set of double values\n"
18641 " (0.0-1.0) representing the alpha value of the color. \n"
18642 "\n"
18643 " ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n"
18644 " arrays. \n"
18645 "\n"
18646 ""},
18647 { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
18648 "Set color map1 colors using a piece-wise linear relationship \n"
18649 "\n"
18650 "DESCRIPTION:\n"
18651 "\n"
18652 " Set color map1 colors using a piece-wise linear relationship between\n"
18653 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18654 " color space (see the PLplot documentation). May be called at any\n"
18655 " time. \n"
18656 "\n"
18657 " The idea here is to specify a number of control points that define the\n"
18658 " mapping between palette 1 input positions (intensities) and HLS (or\n"
18659 " RGB). Between these points, linear interpolation is used which gives\n"
18660 " a smooth variation of color with input position. Any number of\n"
18661 " control points may be specified, located at arbitrary positions,\n"
18662 " although typically 2 - 4 are enough. Another way of stating this is\n"
18663 " that we are traversing a given number of lines through HLS (or RGB)\n"
18664 " space as we move through color map1 entries. The control points at\n"
18665 " the minimum and maximum position (0 and 1) must always be specified. \n"
18666 " By adding more control points you can get more variation. One good\n"
18667 " technique for plotting functions that vary about some expected average\n"
18668 " is to use an additional 2 control points in the center (position ~=\n"
18669 " 0.5) that are the same lightness as the background (typically white\n"
18670 " for paper output, black for crt), and same hue as the boundary control\n"
18671 " points. This allows the highs and lows to be very easily\n"
18672 " distinguished. \n"
18673 "\n"
18674 " Each control point must specify the position in color map1 as well as\n"
18675 " three coordinates in HLS or RGB space. The first point must\n"
18676 " correspond to position = 0, and the last to position = 1. \n"
18677 "\n"
18678 " The default behaviour is for the hue to be linearly interpolated \n"
18679 " between the control points. Since the hue lies in the range [0, 360]\n"
18680 " this corresponds to interpolation around the \"front\" of the color\n"
18681 " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
18682 " alternative interpolation is used between control points i and i+1. If\n"
18683 " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
18684 " hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n"
18685 " consider this as interpolation around the \"back\" or \"reverse\" of the\n"
18686 " color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
18687 " alt_hue_path[] = false for every control point. \n"
18688 "\n"
18689 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
18690 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
18691 " 240]truegreen-yellow-red-magenta-blue[240\n"
18692 " 120]trueblue-magenta-red-yellow-green\n"
18693 "\n"
18694 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
18695 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
18696 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
18697 "\n"
18698 " Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n"
18699 " alt_hue_path)\n"
18700 "\n"
18701 " This function is used in examples 8,11,12,15,20,21. \n"
18702 "\n"
18703 "\n"
18704 "\n"
18705 "SYNOPSIS:\n"
18706 "\n"
18707 "plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n"
18708 "\n"
18709 "ARGUMENTS:\n"
18710 "\n"
18711 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18712 "\n"
18713 " npts (PLINT, input) : number of control points \n"
18714 "\n"
18715 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18716 " and 1.0, in ascending order) \n"
18717 "\n"
18718 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18719 " control point \n"
18720 "\n"
18721 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18722 " control point \n"
18723 "\n"
18724 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18725 " control point \n"
18726 "\n"
18727 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18728 " flag for each control point. (alt_hue_path[i] refers to the\n"
18729 " interpolation interval between the i and i + 1 control points). \n"
18730 "\n"
18731 ""},
18732 { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
18733 "Set color map1 colors using a piece-wise linear relationship \n"
18734 "\n"
18735 "DESCRIPTION:\n"
18736 "\n"
18737 " This is a version of plscmap1l that supports alpha transparency. It\n"
18738 " sets color map1 colors using a piece-wise linear relationship between\n"
18739 " position in the color map (from 0 to 1) and position in HLS or RGB\n"
18740 " color space (see the PLplot documentation) with alpha value (0.0 -\n"
18741 " 1.0). It may be called at any time. \n"
18742 "\n"
18743 " This function is used in example 30. \n"
18744 "\n"
18745 "\n"
18746 "\n"
18747 "SYNOPSIS:\n"
18748 "\n"
18749 "plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n"
18750 "\n"
18751 "ARGUMENTS:\n"
18752 "\n"
18753 " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
18754 "\n"
18755 " npts (PLINT, input) : number of control points \n"
18756 "\n"
18757 " pos (PLFLT *, input) : position for each control point (between 0.0\n"
18758 " and 1.0, in ascending order) \n"
18759 "\n"
18760 " coord1 (PLFLT *, input) : first coordinate (H or R) for each\n"
18761 " control point \n"
18762 "\n"
18763 " coord2 (PLFLT *, input) : second coordinate (L or G) for each\n"
18764 " control point \n"
18765 "\n"
18766 " coord3 (PLFLT *, input) : third coordinate (S or B) for each\n"
18767 " control point \n"
18768 "\n"
18769 " coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n"
18770 " each control point \n"
18771 "\n"
18772 " alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n"
18773 " flag for each control point. (alt_hue_path[i] refers to the\n"
18774 " interpolation interval between the i and i + 1 control points). \n"
18775 "\n"
18776 ""},
18777 { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
18778 "Set number of colors in color map1 \n"
18779 "\n"
18780 "DESCRIPTION:\n"
18781 "\n"
18782 " Set number of colors in color map1, (re-)allocate color map1, and set\n"
18783 " default values if this is the first allocation (see the PLplot\n"
18784 " documentation). \n"
18785 "\n"
18786 " Redacted form: plscmap1n(ncol1)\n"
18787 "\n"
18788 " This function is used in examples 8,11,20,21. \n"
18789 "\n"
18790 "\n"
18791 "\n"
18792 "SYNOPSIS:\n"
18793 "\n"
18794 "plscmap1n(ncol1)\n"
18795 "\n"
18796 "ARGUMENTS:\n"
18797 "\n"
18798 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
18799 " the map1 palette. If this number is zero or less, then the value\n"
18800 " from the previous call to plscmap1n is used and if there is no\n"
18801 " previous call, then a default value is used. \n"
18802 "\n"
18803 ""},
18804 { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, NULL},
18805 { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, NULL},
18806 { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
18807 "Set a given color from color map0 by 8 bit RGB value \n"
18808 "\n"
18809 "ESCRIPTION:\n"
18810 "\n"
18811 " Set a given color by 8-bit RGB value for color map0 (see the PLplot\n"
18812 " documentation). Overwrites the previous color value for the given\n"
18813 " index and, thus, does not result in any additional allocation of space\n"
18814 " for colors. \n"
18815 "\n"
18816 " Redacted form: plscol0(icol0, r, g, b)\n"
18817 "\n"
18818 " This function is used in any example 31. \n"
18819 "\n"
18820 "\n"
18821 "\n"
18822 "YNOPSIS:\n"
18823 "\n"
18824 "lscol0(icol0, r, g, b)\n"
18825 "\n"
18826 "RGUMENTS:\n"
18827 "\n"
18828 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18829 " number of colors (which is set by default, by plscmap0n, or even\n"
18830 " by plscmap0). \n"
18831 "\n"
18832 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18833 " degree of red in the color. \n"
18834 "\n"
18835 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18836 " degree of green in the color. \n"
18837 "\n"
18838 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18839 " degree of blue in the color. \n"
18840 "\n"
18841 ""},
18842 { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
18843 "Set a given color from color map0 by 8 bit RGB value and double alpha value. \n"
18844 "\n"
18845 "ESCRIPTION:\n"
18846 "\n"
18847 " Set a given color by 8-bit RGB value and double alpha value for color \n"
18848 " map0 (see the PLplot documentation). Overwrites the previous color\n"
18849 " value for the given index and, thus, does not result in any\n"
18850 " additional allocation of space for colors. \n"
18851 "\n"
18852 " This function is used in example 30. \n"
18853 "\n"
18854 "\n"
18855 "\n"
18856 "YNOPSIS:\n"
18857 "\n"
18858 "lscol0a(icol0, r, g, b, a)\n"
18859 "\n"
18860 "RGUMENTS:\n"
18861 "\n"
18862 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
18863 " number of colors (which is set by default, by plscmap0n, or even\n"
18864 " by plscmap0). \n"
18865 "\n"
18866 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18867 " degree of red in the color. \n"
18868 "\n"
18869 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18870 " degree of green in the color. \n"
18871 "\n"
18872 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18873 " degree of blue in the color. \n"
18874 "\n"
18875 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18876 " value of the color. \n"
18877 "\n"
18878 ""},
18879 { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
18880 "Set the background color by 8-bit RGB value \n"
18881 "\n"
18882 "DESCRIPTION:\n"
18883 "\n"
18884 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18885 " (see the PLplot documentation). \n"
18886 "\n"
18887 " Redacted form: plscolbg(r, g, b)\n"
18888 "\n"
18889 " This function is used in examples 15,31. \n"
18890 "\n"
18891 "\n"
18892 "\n"
18893 "SYNOPSIS:\n"
18894 "\n"
18895 "plscolbg(r, g, b)\n"
18896 "\n"
18897 "ARGUMENTS:\n"
18898 "\n"
18899 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18900 " degree of red in the color. \n"
18901 "\n"
18902 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18903 " degree of green in the color. \n"
18904 "\n"
18905 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18906 " degree of blue in the color. \n"
18907 "\n"
18908 ""},
18909 { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
18910 "Set the background color by 8-bit RGB value and double alpha value. \n"
18911 "\n"
18912 "DESCRIPTION:\n"
18913 "\n"
18914 " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
18915 " (see the PLplot documentation) and double alpha value. \n"
18916 "\n"
18917 " This function is used in example 31. \n"
18918 "\n"
18919 "\n"
18920 "\n"
18921 "SYNOPSIS:\n"
18922 "\n"
18923 "plscolbga(r, g, b, a)\n"
18924 "\n"
18925 "ARGUMENTS:\n"
18926 "\n"
18927 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18928 " degree of red in the color. \n"
18929 "\n"
18930 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18931 " degree of green in the color. \n"
18932 "\n"
18933 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
18934 " degree of blue in the color. \n"
18935 "\n"
18936 " a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n"
18937 " value of the color. \n"
18938 "\n"
18939 ""},
18940 { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
18941 "Used to globally turn color output on/off \n"
18942 "\n"
18943 "DESCRIPTION:\n"
18944 "\n"
18945 " Used to globally turn color output on/off for those drivers/devices\n"
18946 " that support it. \n"
18947 "\n"
18948 " Redacted form: plscolor(color)\n"
18949 "\n"
18950 " This function is used in example 31. \n"
18951 "\n"
18952 "\n"
18953 "\n"
18954 "SYNOPSIS:\n"
18955 "\n"
18956 "plscolor(color)\n"
18957 "\n"
18958 "ARGUMENTS:\n"
18959 "\n"
18960 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
18961 " turned off. If non-zero, color is turned on. \n"
18962 "\n"
18963 ""},
18964 { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
18965 "Set device-compression level \n"
18966 "\n"
18967 "DESCRIPTION:\n"
18968 "\n"
18969 " Set device-compression level. Only used for drivers that provide\n"
18970 " compression. This function, if used, should be invoked before a call\n"
18971 " to plinit. \n"
18972 "\n"
18973 " Redacted form: plscompression(compression)\n"
18974 "\n"
18975 " This function is used in example 31. \n"
18976 "\n"
18977 "\n"
18978 "\n"
18979 "SYNOPSIS:\n"
18980 "\n"
18981 "plscompression(compression)\n"
18982 "\n"
18983 "ARGUMENTS:\n"
18984 "\n"
18985 " compression (PLINT, input) : The desired compression level. This is\n"
18986 " a device-dependent value. Currently only the jpeg and png devices\n"
18987 " use these values. For jpeg value is the jpeg quality which should\n"
18988 " normally be in the range 0-95. Higher values denote higher quality\n"
18989 " and hence larger image sizes. For png values are in the range -1\n"
18990 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
18991 " A value of -1 denotes the default zlib compression level. Values\n"
18992 " in the range 10-99 are divided by 10 and then used as the zlib\n"
18993 " compression level. Higher compression levels correspond to greater\n"
18994 " compression and small file sizes at the expense of more\n"
18995 " computation. \n"
18996 "\n"
18997 ""},
18998 { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
18999 "Set the device (keyword) name \n"
19000 "\n"
19001 "DESCRIPTION:\n"
19002 "\n"
19003 " Set the device (keyword) name. \n"
19004 "\n"
19005 " Redacted form: plsdev(devname)\n"
19006 "\n"
19007 " This function is used in examples 1,14,20. \n"
19008 "\n"
19009 "\n"
19010 "\n"
19011 "SYNOPSIS:\n"
19012 "\n"
19013 "plsdev(devname)\n"
19014 "\n"
19015 "ARGUMENTS:\n"
19016 "\n"
19017 " devname (const char *, input) : Pointer to device (keyword) name\n"
19018 " string. \n"
19019 "\n"
19020 ""},
19021 { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
19022 "Set parameters that define current device-space window \n"
19023 "\n"
19024 "DESCRIPTION:\n"
19025 "\n"
19026 " Set relative margin width, aspect ratio, and relative justification\n"
19027 " that define current device-space window. If you want to just use the\n"
19028 " previous value for any of these, just pass in the magic value\n"
19029 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19030 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19031 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19032 " to a device-specific value. \n"
19033 "\n"
19034 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19035 "\n"
19036 " This function is used in example 31. \n"
19037 "\n"
19038 "\n"
19039 "\n"
19040 "SYNOPSIS:\n"
19041 "\n"
19042 "plsdidev(mar, aspect, jx, jy)\n"
19043 "\n"
19044 "ARGUMENTS:\n"
19045 "\n"
19046 " mar (PLFLT, input) : Relative margin width. \n"
19047 "\n"
19048 " aspect (PLFLT, input) : Aspect ratio. \n"
19049 "\n"
19050 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19051 " the range -0.5 to 0.5. \n"
19052 "\n"
19053 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19054 " the range -0.5 to 0.5. \n"
19055 "\n"
19056 ""},
19057 { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
19058 "Set up transformation from metafile coordinates \n"
19059 "\n"
19060 "DESCRIPTION:\n"
19061 "\n"
19062 " Set up transformation from metafile coordinates. The size of the plot\n"
19063 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19064 " general-purpose facility just yet (not sure why the user would need\n"
19065 " it, for one). \n"
19066 "\n"
19067 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19068 " dimypmm)\n"
19069 "\n"
19070 " This function is not used in any examples. \n"
19071 "\n"
19072 "\n"
19073 "\n"
19074 "SYNOPSIS:\n"
19075 "\n"
19076 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19077 "\n"
19078 "ARGUMENTS:\n"
19079 "\n"
19080 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
19081 "\n"
19082 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
19083 "\n"
19084 " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
19085 "\n"
19086 " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
19087 "\n"
19088 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
19089 "\n"
19090 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
19091 "\n"
19092 ""},
19093 { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
19094 "Set plot orientation \n"
19095 "\n"
19096 "DESCRIPTION:\n"
19097 "\n"
19098 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19099 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19100 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19101 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19102 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19103 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19104 " not called the default value of rot is 0. \n"
19105 "\n"
19106 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19107 " probably want to change the aspect ratio to a value suitable for the\n"
19108 " plot orientation using a call to plsdidev or the command-line options\n"
19109 " -a or -freeaspect. For more documentation of those options see the\n"
19110 " PLplot documentation. Such command-line options can be set internally\n"
19111 " using plsetopt or set directly using the command line and parsed using\n"
19112 " a call to plparseopts. \n"
19113 "\n"
19114 " Redacted form: plsdiori(rot)\n"
19115 "\n"
19116 " This function is not used in any examples. \n"
19117 "\n"
19118 "\n"
19119 "\n"
19120 "SYNOPSIS:\n"
19121 "\n"
19122 "plsdiori(rot)\n"
19123 "\n"
19124 "ARGUMENTS:\n"
19125 "\n"
19126 " rot (PLFLT, input) : Plot orientation parameter. \n"
19127 "\n"
19128 ""},
19129 { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
19130 "Set parameters that define current plot-space window \n"
19131 "\n"
19132 "DESCRIPTION:\n"
19133 "\n"
19134 " Set relative minima and maxima that define the current plot-space\n"
19135 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19136 " xmax, and ymax are 0., 0., 1., and 1. \n"
19137 "\n"
19138 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19139 "\n"
19140 " This function is used in example 31. \n"
19141 "\n"
19142 "\n"
19143 "\n"
19144 "SYNOPSIS:\n"
19145 "\n"
19146 "plsdiplt(xmin, ymin, xmax, ymax)\n"
19147 "\n"
19148 "ARGUMENTS:\n"
19149 "\n"
19150 " xmin (PLFLT, input) : Relative minimum in x. \n"
19151 "\n"
19152 " ymin (PLFLT, input) : Relative minimum in y. \n"
19153 "\n"
19154 " xmax (PLFLT, input) : Relative maximum in x. \n"
19155 "\n"
19156 " ymax (PLFLT, input) : Relative maximum in y. \n"
19157 "\n"
19158 ""},
19159 { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
19160 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
19161 "\n"
19162 "DESCRIPTION:\n"
19163 "\n"
19164 " Set relative minima and maxima incrementally (zoom mode) that define\n"
19165 " the current plot-space window. This function has the same effect as\n"
19166 " plsdiplt if that function has not been previously called. Otherwise,\n"
19167 " this function implements zoom mode using the transformation min_used =\n"
19168 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
19169 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19170 " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
19171 "\n"
19172 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
19173 "\n"
19174 " This function is used in example 31. \n"
19175 "\n"
19176 "\n"
19177 "\n"
19178 "SYNOPSIS:\n"
19179 "\n"
19180 "plsdiplz(xmin, ymin, xmax, ymax)\n"
19181 "\n"
19182 "ARGUMENTS:\n"
19183 "\n"
19184 " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
19185 "\n"
19186 " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
19187 "\n"
19188 " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
19189 "\n"
19190 " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
19191 "\n"
19192 ""},
19193 { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
19194 "Set seed for internal random number generator. \n"
19195 "\n"
19196 "DESCRIPTION:\n"
19197 "\n"
19198 " Set the seed for the internal random number generator. See plrandd for\n"
19199 " further details. \n"
19200 "\n"
19201 " Redacted form: plseed(seed)\n"
19202 "\n"
19203 " This function is used in example 21. \n"
19204 "\n"
19205 "\n"
19206 "\n"
19207 "SYNOPSIS:\n"
19208 "\n"
19209 "plseed(seed)\n"
19210 "\n"
19211 "ARGUMENTS:\n"
19212 "\n"
19213 " seed (unsigned int, input) : Seed for random number generator. \n"
19214 "\n"
19215 ""},
19216 { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
19217 "Set the escape character for text strings \n"
19218 "\n"
19219 "DESCRIPTION:\n"
19220 "\n"
19221 " Set the escape character for text strings. From C (in contrast to\n"
19222 " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
19223 " selected characters are allowed to prevent the user from shooting\n"
19224 " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
19225 " with C's use of backslash as a character escape). Here are the\n"
19226 " allowed escape characters and their corresponding decimal ASCII\n"
19227 " values: !, ASCII 33 \n"
19228 " #, ASCII 35 \n"
19229 " $, ASCII 36 \n"
19230 " %, ASCII 37 \n"
19231 " &, ASCII 38 \n"
19232 " *, ASCII 42 \n"
19233 " @, ASCII 64 \n"
19234 " ^, ASCII 94 \n"
19235 " ~, ASCII 126 \n"
19236 "\n"
19237 "\n"
19238 " Redacted form: General: plsesc(esc)\n"
19239 " Perl/PDL: Not available? \n"
19240 "\n"
19241 "\n"
19242 " This function is used in example 29. \n"
19243 "\n"
19244 "\n"
19245 "\n"
19246 "SYNOPSIS:\n"
19247 "\n"
19248 "plsesc(esc)\n"
19249 "\n"
19250 "ARGUMENTS:\n"
19251 "\n"
19252 " esc (char, input) : Escape character. \n"
19253 "\n"
19254 ""},
19255 { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
19256 "Set any command-line option \n"
19257 "\n"
19258 "DESCRIPTION:\n"
19259 "\n"
19260 " Set any command-line option internally from a program before it\n"
19261 " invokes plinit. opt is the name of the command-line option and optarg\n"
19262 " is the corresponding command-line option argument. \n"
19263 "\n"
19264 " This function returns 0 on success. \n"
19265 "\n"
19266 " Redacted form: plsetopt(opt, optarg)\n"
19267 "\n"
19268 " This function is used in example 14. \n"
19269 "\n"
19270 "\n"
19271 "\n"
19272 "SYNOPSIS:\n"
19273 "\n"
19274 "int plsetopt(opt, optarg)\n"
19275 "\n"
19276 "ARGUMENTS:\n"
19277 "\n"
19278 " opt (const char *, input) : Pointer to string containing the\n"
19279 " command-line option. \n"
19280 "\n"
19281 " optarg (const char *, input) : Pointer to string containing the\n"
19282 " argument of the command-line option. \n"
19283 "\n"
19284 ""},
19285 { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
19286 "Set family file parameters \n"
19287 "\n"
19288 "DESCRIPTION:\n"
19289 "\n"
19290 " Sets variables dealing with output file familying. Does nothing if\n"
19291 " familying not supported by the driver. This routine, if used, must be\n"
19292 " called before initializing PLplot. See the PLplot documentation for\n"
19293 " more information. \n"
19294 "\n"
19295 " Redacted form: plsfam(fam, num, bmax)\n"
19296 "\n"
19297 " This function is used in examples 14,31. \n"
19298 "\n"
19299 "\n"
19300 "\n"
19301 "SYNOPSIS:\n"
19302 "\n"
19303 "plsfam(fam, num, bmax)\n"
19304 "\n"
19305 "ARGUMENTS:\n"
19306 "\n"
19307 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
19308 " is enabled. \n"
19309 "\n"
19310 " num (PLINT, input) : Current family file number. \n"
19311 "\n"
19312 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19313 " file. \n"
19314 "\n"
19315 ""},
19316 { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
19317 "Set FCI (font characterization integer) \n"
19318 "\n"
19319 "DESCRIPTION:\n"
19320 "\n"
19321 " Sets font characteristics to be used at the start of the next string\n"
19322 " using the FCI approach. See the PLplot documentation for more\n"
19323 " information. \n"
19324 "\n"
19325 " Redacted form: General: plsfci(fci)\n"
19326 " Perl/PDL: Not available? \n"
19327 "\n"
19328 "\n"
19329 " This function is used in example 23. \n"
19330 "\n"
19331 "\n"
19332 "\n"
19333 "SYNOPSIS:\n"
19334 "\n"
19335 "plsfci(fci)\n"
19336 "\n"
19337 "ARGUMENTS:\n"
19338 "\n"
19339 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19340 " of FCI. \n"
19341 "\n"
19342 ""},
19343 { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
19344 "Set output file name \n"
19345 "\n"
19346 "DESCRIPTION:\n"
19347 "\n"
19348 " Sets the current output file name, if applicable. If the file name\n"
19349 " has not been specified and is required by the driver, the user will be\n"
19350 " prompted for it. If using the X-windows output driver, this sets the\n"
19351 " display name. This routine, if used, must be called before\n"
19352 " initializing PLplot. \n"
19353 "\n"
19354 " Redacted form: plsfnam(fnam)\n"
19355 "\n"
19356 " This function is used in examples 1,20. \n"
19357 "\n"
19358 "\n"
19359 "\n"
19360 "SYNOPSIS:\n"
19361 "\n"
19362 "plsfnam(fnam)\n"
19363 "\n"
19364 "ARGUMENTS:\n"
19365 "\n"
19366 " fnam (const char *, input) : Pointer to file name string. \n"
19367 "\n"
19368 ""},
19369 { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
19370 "Set family, style and weight of the current font \n"
19371 "\n"
19372 "DESCRIPTION:\n"
19373 "\n"
19374 " Sets the current font. See the PLplot documentation for more\n"
19375 " information on font selection. \n"
19376 "\n"
19377 " Redacted form: plsfont(family, style, weight)\n"
19378 "\n"
19379 " This function is used in example 23. \n"
19380 "\n"
19381 "\n"
19382 "\n"
19383 "SYNOPSIS:\n"
19384 "\n"
19385 "plsfont(family, style, weight)\n"
19386 "\n"
19387 "ARGUMENTS:\n"
19388 "\n"
19389 " family (PLINT, input) : Font family to select for the current font.\n"
19390 " The available values are given by the PL_FCI_* constants in\n"
19391 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19392 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19393 " signifies that the font family should not be altered. \n"
19394 "\n"
19395 " style (PLINT, input) : Font style to select for the current font.\n"
19396 " The available values are given by the PL_FCI_* constants in\n"
19397 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19398 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19399 " should not be altered. \n"
19400 "\n"
19401 " weight (PLINT, input) : Font weight to select for the current font.\n"
19402 " The available values are given by the PL_FCI_* constants in\n"
19403 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19404 " negative value signifies that the font weight should not be\n"
19405 " altered. \n"
19406 "\n"
19407 ""},
19408 { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
19409 "Shade regions on the basis of value \n"
19410 "\n"
19411 "DESCRIPTION:\n"
19412 "\n"
19413 " Shade regions on the basis of value. This is the high-level routine\n"
19414 " for making continuous color shaded plots with cmap1 while plshade (or\n"
19415 " plshade1) are used for individual shaded regions using either cmap0 or\n"
19416 " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19417 " function. See the following discussion of the arguments and the PLplot\n"
19418 " documentation for more information. \n"
19419 "\n"
19420 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19421 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19422 " pltr_data)\n"
19423 " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19424 " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19425 " pltr_data)\n"
19426 "\n"
19427 "\n"
19428 " This function is used in examples 16,21. \n"
19429 "\n"
19430 "\n"
19431 "\n"
19432 "SYNOPSIS:\n"
19433 "\n"
19434 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19435 "\n"
19436 "ARGUMENTS:\n"
19437 "\n"
19438 " a (PLFLT **, input) : Contains ** pointer to array to be plotted.\n"
19439 " The array must have been declared as PLFLT a[nx][ny]. \n"
19440 "\n"
19441 " nx (PLINT, input) : First dimension of array \"a\". \n"
19442 "\n"
19443 " ny (PLINT, input) : Second dimension of array \"a\". \n"
19444 "\n"
19445 " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
19446 " specifying regions excluded from the shading plot. This function\n"
19447 " accepts x and y coordinates as input arguments and must return 0\n"
19448 " if the point is in the excluded region or 1 otherwise. This\n"
19449 " argument can be NULL if all the values are valid. \n"
19450 "\n"
19451 " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19452 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19453 " at (xmax,ymin) and so on. \n"
19454 "\n"
19455 " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19456 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19457 " at (xmax,ymin) and so on. \n"
19458 "\n"
19459 " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19460 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19461 " at (xmax,ymin) and so on. \n"
19462 "\n"
19463 " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
19464 " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19465 " at (xmax,ymin) and so on. \n"
19466 "\n"
19467 " clevel (PLFLT *, input) : Pointer to array containing the data\n"
19468 " levels corresponding to the edges of each shaded region that will\n"
19469 " be plotted by this function. To work properly the levels should\n"
19470 " be monotonic. \n"
19471 "\n"
19472 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19473 " of shade edge values in clevel). \n"
19474 "\n"
19475 " fill_width (PLFLT, input) : Defines line width used by the fill\n"
19476 " pattern. \n"
19477 "\n"
19478 " cont_color (PLINT, input) : Defines pen color used for contours\n"
19479 " defining edges of shaded regions. The pen color is only temporary\n"
19480 " set for the contour drawing. Set this value to zero or less if no\n"
19481 " shade edge contours are wanted. \n"
19482 "\n"
19483 " cont_width (PLFLT, input) : Defines line width used for contours\n"
19484 " defining edges of shaded regions. This value may not be honored\n"
19485 " by all drivers. The pen width is only temporary set for the\n"
19486 " contour drawing. Set this value to zero or less if no shade edge\n"
19487 " contours are wanted. \n"
19488 "\n"
19489 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : Routine used to\n"
19490 " fill the region. Use plfill. Future version of PLplot may have\n"
19491 " other fill routines. \n"
19492 "\n"
19493 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19494 " map to rectangles after coordinate transformation with pltrl. \n"
19495 " Otherwise, set rectangular to false. If rectangular is set to\n"
19496 " true, plshade tries to save time by filling large rectangles. \n"
19497 " This optimization fails if the coordinate transformation distorts\n"
19498 " the shape of rectangles. For example a plot in polar coordinates\n"
19499 " has to have rectangular set to false. \n"
19500 "\n"
19501 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19502 " Pointer to function that defines transformation between indices\n"
19503 " in array z and the world coordinates (C only). Transformation\n"
19504 " functions are provided in the PLplot library: pltr0 for identity\n"
19505 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
19506 " defined by one- and two-dimensional arrays. In addition,\n"
19507 " user-supplied routines for the transformation can be used as well.\n"
19508 " Examples of all of these approaches are given in the PLplot\n"
19509 " documentation. The transformation function should have the form\n"
19510 " given by any of pltr0, pltr1, or pltr2. \n"
19511 "\n"
19512 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
19513 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
19514 " externally supplied. \n"
19515 "\n"
19516 ""},
19517 { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
19518 "Shade individual region on the basis of value \n"
19519 "\n"
19520 "ESCRIPTION:\n"
19521 "\n"
19522 " Shade individual region on the basis of value. Use plshades if you\n"
19523 " want to shade a number of regions using continuous colors. plshade is\n"
19524 " identical to plshade1 except for the type of the first parameter. See\n"
19525 " plshade1 for further discussion. \n"
19526 "\n"
19527 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
19528 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
19529 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
19530 " Perl/PDL: Not available? \n"
19531 "\n"
19532 "\n"
19533 " This function is used in example 15. \n"
19534 "\n"
19535 "\n"
19536 "\n"
19537 "YNOPSIS:\n"
19538 "\n"
19539 "lshade(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"
19540 "\n"
19541 "RGUMENTS:\n"
19542 "\n"
19543 " a (PLFLT **, input) : \n"
19544 "\n"
19545 " nx (PLINT, input) : \n"
19546 "\n"
19547 " ny (PLINT, input) : \n"
19548 "\n"
19549 " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
19550 "\n"
19551 " xmin (PLFLT, input) : \n"
19552 "\n"
19553 " xmax (PLFLT, input) : \n"
19554 "\n"
19555 " ymin (PLFLT, input) : \n"
19556 "\n"
19557 " ymax (PLFLT, input) : \n"
19558 "\n"
19559 " shade_min (PLFLT, input) : \n"
19560 "\n"
19561 " shade_max (PLFLT, input) : \n"
19562 "\n"
19563 " sh_cmap (PLINT, input) : \n"
19564 "\n"
19565 " sh_color (PLFLT, input) : \n"
19566 "\n"
19567 " sh_width (PLFLT, input) : \n"
19568 "\n"
19569 " min_color (PLINT, input) : \n"
19570 "\n"
19571 " min_width (PLFLT, input) : \n"
19572 "\n"
19573 " max_color (PLINT, input) : \n"
19574 "\n"
19575 " max_width (PLFLT, input) : \n"
19576 "\n"
19577 " fill (void (*) (PLINT, PLFLT *, PLFLT *), input) : \n"
19578 "\n"
19579 " rectangular (PLBOOL, input) : \n"
19580 "\n"
19581 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
19582 "\n"
19583 " pltr_data (PLPointer, input) : \n"
19584 "\n"
19585 ""},
19586 { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
19587 "Assign a function to use for generating custom axis labels \n"
19588 "\n"
19589 "DESCRIPTION:\n"
19590 "\n"
19591 " This function allows a user to provide their own function to provide\n"
19592 " axis label text. The user function is given the numeric value for a\n"
19593 " point on an axis and returns a string label to correspond with that\n"
19594 " value. Custom axis labels can be enabled by passing appropriate\n"
19595 " arguments to plenv, plbox, plbox3 and similar functions. \n"
19596 "\n"
19597 " This function is used in example 19. \n"
19598 "\n"
19599 "\n"
19600 "\n"
19601 "SYNOPSIS:\n"
19602 "\n"
19603 "plslabelfunc(label_func, label_data)\n"
19604 "\n"
19605 "ARGUMENTS:\n"
19606 "\n"
19607 " label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n"
19608 " This is the custom label function. In order to reset to the\n"
19609 " default labelling, set this to NULL. The labelling function\n"
19610 " parameters are, in order: axis: This indicates which axis a\n"
19611 " label is being requested for. The value will be one of PL_X_AXIS,\n"
19612 " PL_Y_AXIS or PL_Z_AXIS. \n"
19613 "\n"
19614 " value: This is the value along the axis which is being labelled. \n"
19615 "\n"
19616 " label_text: The string representation of the label value. \n"
19617 "\n"
19618 " length: The maximum length in characters allowed for label_text. \n"
19619 "\n"
19620 "\n"
19621 " label_data (void *, input) : This parameter may be used to pass\n"
19622 " data to the label_func function. \n"
19623 "\n"
19624 ""},
19625 { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
19626 "Set length of major ticks \n"
19627 "\n"
19628 "DESCRIPTION:\n"
19629 "\n"
19630 " This sets up the length of the major ticks. The actual length is the\n"
19631 " product of the default length and a scaling factor as for character\n"
19632 " height. \n"
19633 "\n"
19634 " Redacted form: plsmaj(def, scale)\n"
19635 "\n"
19636 " This function is used in example 29. \n"
19637 "\n"
19638 "\n"
19639 "\n"
19640 "SYNOPSIS:\n"
19641 "\n"
19642 "plsmaj(def, scale)\n"
19643 "\n"
19644 "ARGUMENTS:\n"
19645 "\n"
19646 " def (PLFLT, input) : The default length of a major tick in\n"
19647 " millimeters, should be set to zero if the default length is to\n"
19648 " remain unchanged. \n"
19649 "\n"
19650 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19651 " actual tick length. \n"
19652 "\n"
19653 ""},
19654 { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
19655 "Set the memory area to be plotted (RGB) \n"
19656 "\n"
19657 "DESCRIPTION:\n"
19658 "\n"
19659 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
19660 " the dev member of the stream structure. Also set the number of pixels\n"
19661 " in the memory passed in \n"
19662 " plotmem, which is a block of memory \n"
19663 " maxy by \n"
19664 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
19665 "\n"
19666 " This memory will have to be freed by the user! \n"
19667 "\n"
19668 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
19669 "\n"
19670 " This function is not used in any examples. \n"
19671 "\n"
19672 "\n"
19673 "\n"
19674 "SYNOPSIS:\n"
19675 "\n"
19676 "plsmem(maxx, maxy, plotmem)\n"
19677 "\n"
19678 "ARGUMENTS:\n"
19679 "\n"
19680 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19681 "\n"
19682 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19683 "\n"
19684 " plotmem (void *, input) : Pointer to the beginning of the\n"
19685 " user-supplied memory area. \n"
19686 "\n"
19687 ""},
19688 { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
19689 "Set the memory area to be plotted (RGBA) \n"
19690 "\n"
19691 "DESCRIPTION:\n"
19692 "\n"
19693 " Set the memory area to be plotted (with the memcairo driver) as the\n"
19694 " dev member of the stream structure. Also set the number of pixels in\n"
19695 " the memory passed in \n"
19696 " plotmem, which is a block of memory \n"
19697 " maxy by \n"
19698 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
19699 "\n"
19700 " This memory will have to be freed by the user! \n"
19701 "\n"
19702 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
19703 "\n"
19704 " This function is not used in any examples. \n"
19705 "\n"
19706 "\n"
19707 "\n"
19708 "SYNOPSIS:\n"
19709 "\n"
19710 "plsmema(maxx, maxy, plotmem)\n"
19711 "\n"
19712 "ARGUMENTS:\n"
19713 "\n"
19714 " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
19715 "\n"
19716 " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
19717 "\n"
19718 " plotmem (void *, input) : Pointer to the beginning of the\n"
19719 " user-supplied memory area. \n"
19720 "\n"
19721 ""},
19722 { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
19723 "Set length of minor ticks \n"
19724 "\n"
19725 "DESCRIPTION:\n"
19726 "\n"
19727 " This sets up the length of the minor ticks and the length of the\n"
19728 " terminals on error bars. The actual length is the product of the\n"
19729 " default length and a scaling factor as for character height. \n"
19730 "\n"
19731 " Redacted form: plsmin(def, scale)\n"
19732 "\n"
19733 " This function is used in example 29. \n"
19734 "\n"
19735 "\n"
19736 "\n"
19737 "SYNOPSIS:\n"
19738 "\n"
19739 "plsmin(def, scale)\n"
19740 "\n"
19741 "ARGUMENTS:\n"
19742 "\n"
19743 " def (PLFLT, input) : The default length of a minor tick in\n"
19744 " millimeters, should be set to zero if the default length is to\n"
19745 " remain unchanged. \n"
19746 "\n"
19747 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19748 " actual tick length. \n"
19749 "\n"
19750 ""},
19751 { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
19752 "Set orientation \n"
19753 "\n"
19754 "DESCRIPTION:\n"
19755 "\n"
19756 " Set integer plot orientation parameter. This function is identical to\n"
19757 " plsdiori except for the type of the argument, and should be used in\n"
19758 " the same way. See the PLplot documentation for details. \n"
19759 "\n"
19760 " Redacted form: plsori(ori)\n"
19761 "\n"
19762 " This function is used in example 3. \n"
19763 "\n"
19764 "\n"
19765 "\n"
19766 "SYNOPSIS:\n"
19767 "\n"
19768 "plsori(ori)\n"
19769 "\n"
19770 "ARGUMENTS:\n"
19771 "\n"
19772 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
19773 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
19774 " angle. \n"
19775 "\n"
19776 ""},
19777 { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
19778 "Set page parameters \n"
19779 "\n"
19780 "DESCRIPTION:\n"
19781 "\n"
19782 " Sets the page configuration (optional). If an individual parameter is\n"
19783 " zero then that parameter value is not updated. Not all parameters are\n"
19784 " recognized by all drivers and the interpretation is device-dependent.\n"
19785 " The X-window driver uses the length and offset parameters to determine\n"
19786 " the window size and location. The length and offset values are\n"
19787 " expressed in units that are specific to the current driver. For\n"
19788 " instance: screen drivers will usually interpret them as number of\n"
19789 " pixels, whereas printer drivers will usually use mm. This routine, if\n"
19790 " used, must be called before initializing PLplot. \n"
19791 "\n"
19792 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19793 "\n"
19794 " This function is used in examples 14 and 31. \n"
19795 "\n"
19796 "\n"
19797 "\n"
19798 "SYNOPSIS:\n"
19799 "\n"
19800 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
19801 "\n"
19802 "ARGUMENTS:\n"
19803 "\n"
19804 " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
19805 "\n"
19806 " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
19807 "\n"
19808 " xleng (PLINT , input) : Page length, x. \n"
19809 "\n"
19810 " yleng (PLINT, input) : Page length, y. \n"
19811 "\n"
19812 " xoff (PLINT, input) : Page offset, x. \n"
19813 "\n"
19814 " yoff (PLINT, input) : Page offset, y. \n"
19815 "\n"
19816 ""},
19817 { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
19818 "Set the colors for color table 0 from a cmap0 file \n"
19819 "\n"
19820 "DESCRIPTION:\n"
19821 "\n"
19822 " Set the colors for color table 0 from a cmap0 file \n"
19823 "\n"
19824 " Redacted form: plspal0(filename)\n"
19825 "\n"
19826 " This function is in example 16. \n"
19827 "\n"
19828 "\n"
19829 "\n"
19830 "SYNOPSIS:\n"
19831 "\n"
19832 "plspal0(filename)\n"
19833 "\n"
19834 "ARGUMENTS:\n"
19835 "\n"
19836 " filename (const char *, input) : The name of the cmap0 file, or a\n"
19837 " empty to string to specify the default cmap0 file. \n"
19838 "\n"
19839 ""},
19840 { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
19841 "Set the colors for color table 1 from a cmap1 file \n"
19842 "\n"
19843 "DESCRIPTION:\n"
19844 "\n"
19845 " Set the colors for color table 1 from a cmap1 file \n"
19846 "\n"
19847 " Redacted form: plspal1(filename)\n"
19848 "\n"
19849 " This function is in example 16. \n"
19850 "\n"
19851 "\n"
19852 "\n"
19853 "SYNOPSIS:\n"
19854 "\n"
19855 "plspal1(filename)\n"
19856 "\n"
19857 "ARGUMENTS:\n"
19858 "\n"
19859 " filename (const char *, input) : The name of the cmap1 file, or a\n"
19860 " empty to string to specify the default cmap1 file. \n"
19861 "\n"
19862 ""},
19863 { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
19864 "Set the pause (on end-of-page) status \n"
19865 "\n"
19866 "DESCRIPTION:\n"
19867 "\n"
19868 " Set the pause (on end-of-page) status. \n"
19869 "\n"
19870 " Redacted form: plspause(pause)\n"
19871 "\n"
19872 " This function is in examples 14,20. \n"
19873 "\n"
19874 "\n"
19875 "\n"
19876 "SYNOPSIS:\n"
19877 "\n"
19878 "plspause(pause)\n"
19879 "\n"
19880 "ARGUMENTS:\n"
19881 "\n"
19882 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
19883 " end-of-page for those drivers which support this. Otherwise there\n"
19884 " is no pause. \n"
19885 "\n"
19886 ""},
19887 { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
19888 "Set current output stream \n"
19889 "\n"
19890 "DESCRIPTION:\n"
19891 "\n"
19892 " Sets the number of the current output stream. The stream number\n"
19893 " defaults to 0 unless changed by this routine. The first use of this\n"
19894 " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
19895 "\n"
19896 " Redacted form: plsstrm(strm)\n"
19897 "\n"
19898 " This function is examples 1,14,20. \n"
19899 "\n"
19900 "\n"
19901 "\n"
19902 "SYNOPSIS:\n"
19903 "\n"
19904 "plsstrm(strm)\n"
19905 "\n"
19906 "ARGUMENTS:\n"
19907 "\n"
19908 " strm (PLINT, input) : The current stream number. \n"
19909 "\n"
19910 ""},
19911 { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
19912 "Set the number of subpages in x and y \n"
19913 "\n"
19914 "DESCRIPTION:\n"
19915 "\n"
19916 " Set the number of subpages in x and y. \n"
19917 "\n"
19918 " Redacted form: plssub(nx, ny)\n"
19919 "\n"
19920 " This function is examples 1,2,14,21,25,27. \n"
19921 "\n"
19922 "\n"
19923 "\n"
19924 "SYNOPSIS:\n"
19925 "\n"
19926 "plssub(nx, ny)\n"
19927 "\n"
19928 "ARGUMENTS:\n"
19929 "\n"
19930 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
19931 " of window columns). \n"
19932 "\n"
19933 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
19934 " of window rows). \n"
19935 "\n"
19936 ""},
19937 { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
19938 "Set symbol size \n"
19939 "\n"
19940 "DESCRIPTION:\n"
19941 "\n"
19942 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
19943 " plsym. The actual height of a symbol is the product of the default\n"
19944 " symbol size and a scaling factor as for the character height. \n"
19945 "\n"
19946 " Redacted form: plssym(def, scale)\n"
19947 "\n"
19948 " This function is used in example 29. \n"
19949 "\n"
19950 "\n"
19951 "\n"
19952 "SYNOPSIS:\n"
19953 "\n"
19954 "plssym(def, scale)\n"
19955 "\n"
19956 "ARGUMENTS:\n"
19957 "\n"
19958 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
19959 " should be set to zero if the default height is to remain\n"
19960 " unchanged. \n"
19961 "\n"
19962 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19963 " actual symbol height. \n"
19964 "\n"
19965 ""},
19966 { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
19967 "Initialization \n"
19968 "\n"
19969 "DESCRIPTION:\n"
19970 "\n"
19971 " Initializing the plotting package. The program prompts for the device\n"
19972 " keyword or number of the desired output device. Hitting a RETURN in\n"
19973 " response to the prompt is the same as selecting the first device. If\n"
19974 " only one device is enabled when PLplot is installed, plstar will issue\n"
19975 " no prompt. The output device is divided into nx by ny subpages, each\n"
19976 " of which may be used independently. The subroutine pladv is used to\n"
19977 " advance from one subpage to the next. \n"
19978 "\n"
19979 " Redacted form: plstar(nx, ny)\n"
19980 "\n"
19981 " This function is used in example 1. \n"
19982 "\n"
19983 "\n"
19984 "\n"
19985 "SYNOPSIS:\n"
19986 "\n"
19987 "plstar(nx, ny)\n"
19988 "\n"
19989 "ARGUMENTS:\n"
19990 "\n"
19991 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
19992 " horizontal direction. \n"
19993 "\n"
19994 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
19995 " vertical direction. \n"
19996 "\n"
19997 ""},
19998 { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
19999 "Initialization \n"
20000 "\n"
20001 "DESCRIPTION:\n"
20002 "\n"
20003 " Alternative to plstar for initializing the plotting package. The\n"
20004 " device name keyword for the desired output device must be supplied as\n"
20005 " an argument. The device keywords are the same as those printed out by\n"
20006 " plstar. If the requested device is not available, or if the input\n"
20007 " string is empty or begins with ``?'', the prompted start up of plstar\n"
20008 " is used. This routine also divides the output device into nx by ny\n"
20009 " subpages, each of which may be used independently. The subroutine\n"
20010 " pladv is used to advance from one subpage to the next. \n"
20011 "\n"
20012 " Redacted form: General: plstart(device, nx, ny)\n"
20013 " Perl/PDL: plstart(nx, ny, device)\n"
20014 "\n"
20015 "\n"
20016 " This function is not used in any examples. \n"
20017 "\n"
20018 "\n"
20019 "\n"
20020 "SYNOPSIS:\n"
20021 "\n"
20022 "plstart(device, nx, ny)\n"
20023 "\n"
20024 "ARGUMENTS:\n"
20025 "\n"
20026 " device (const char *, input) : Device name (keyword) of the\n"
20027 " required output device. If NULL or if the first character is a\n"
20028 " ``?'', the normal (prompted) start up is used. \n"
20029 "\n"
20030 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20031 " horizontal direction. \n"
20032 "\n"
20033 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20034 " vertical direction. \n"
20035 "\n"
20036 ""},
20037 { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
20038 "Set a global coordinate transform function \n"
20039 "\n"
20040 "DESCRIPTION:\n"
20041 "\n"
20042 " This function can be used to define a coordinate transformation which\n"
20043 " affects all elements drawn within the current plot window. The\n"
20044 " transformation function is similar to that provided for the plmap and\n"
20045 " plmeridians functions. The data parameter may be used to pass extra\n"
20046 " data to transform_fun. \n"
20047 "\n"
20048 " Redacted form: General: plstransform(transform_fun, data)\n"
20049 "\n"
20050 "\n"
20051 " This function is used in examples 19 and 22. \n"
20052 "\n"
20053 "\n"
20054 "\n"
20055 "SYNOPSIS:\n"
20056 "\n"
20057 "plstransform(transform_fun, data)\n"
20058 "\n"
20059 "ARGUMENTS:\n"
20060 "\n"
20061 " transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n"
20062 " input) : Pointer to a function that defines a transformation\n"
20063 " from the input (x, y) coordinate to a new plot world coordinate. A\n"
20064 " NULL pointer means that no transform is applied. \n"
20065 "\n"
20066 " data (PLPointer, input) : Optional extra data for \n"
20067 " transform_fun. \n"
20068 "\n"
20069 ""},
20070 { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
20071 "Plot a glyph at the specified points \n"
20072 "\n"
20073 "DESCRIPTION:\n"
20074 "\n"
20075 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20076 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
20077 " is specified with a PLplot user string. Note that the user string is\n"
20078 " not actually limited to one glyph so it is possible (but not normally\n"
20079 " useful) to plot more than one glyph at the specified points with this\n"
20080 " function. As with plmtex and plptex, the user string can contain FCI\n"
20081 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20082 " else PLplot escapes for Hershey or unicode text to determine the\n"
20083 " glyph. \n"
20084 "\n"
20085 " Redacted form: plstring(x, y, string)\n"
20086 "\n"
20087 " This function is used in examples 4, 21 and 26. \n"
20088 "\n"
20089 "\n"
20090 "\n"
20091 "SYNOPSIS:\n"
20092 "\n"
20093 "plstring(n, x, y, string)\n"
20094 "\n"
20095 "ARGUMENTS:\n"
20096 "\n"
20097 " n (PLINT, input) : Number of points in the x and y arrays. \n"
20098 "\n"
20099 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20100 " points. \n"
20101 "\n"
20102 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20103 " points. \n"
20104 "\n"
20105 " string (const char *, input) : PLplot user string corresponding to\n"
20106 " the glyph to be plotted at each of the n points. \n"
20107 "\n"
20108 ""},
20109 { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
20110 "Plot a glyph at the specified 3D points \n"
20111 "\n"
20112 "DESCRIPTION:\n"
20113 "\n"
20114 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20115 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20116 " this function similar to what is done for plline3. The glyph is\n"
20117 " specified with a PLplot user string. Note that the user string is not\n"
20118 " actually limited to one glyph so it is possible (but not normally\n"
20119 " useful) to plot more than one glyph at the specified points with this\n"
20120 " function. As with plmtex and plptex, the user string can contain FCI\n"
20121 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20122 " else PLplot escapes for Hershey or unicode text to determine the\n"
20123 " glyph. \n"
20124 "\n"
20125 " Redacted form: plstring3(x, y, z, string)\n"
20126 "\n"
20127 " This function is used in example 18. \n"
20128 "\n"
20129 "\n"
20130 "\n"
20131 "SYNOPSIS:\n"
20132 "\n"
20133 "plstring3(n, x, y, z, string)\n"
20134 "\n"
20135 "ARGUMENTS:\n"
20136 "\n"
20137 " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
20138 "\n"
20139 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20140 " points. \n"
20141 "\n"
20142 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20143 " points. \n"
20144 "\n"
20145 " z (PLFLT *, input) : Pointer to an array with Z coordinates of\n"
20146 " points. \n"
20147 "\n"
20148 " string (const char *, input) : PLplot user string corresponding to\n"
20149 " the glyph to be plotted at each of the n points. \n"
20150 "\n"
20151 ""},
20152 { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
20153 "Add a point to a strip chart \n"
20154 "\n"
20155 "DESCRIPTION:\n"
20156 "\n"
20157 " Add a point to a given pen of a given strip chart. There is no need\n"
20158 " for all pens to have the same number of points or to be equally\n"
20159 " sampled in the x coordinate. Allocates memory and rescales as\n"
20160 " necessary. \n"
20161 "\n"
20162 " Redacted form: plstripa(id, p, x, y)\n"
20163 "\n"
20164 " This function is used in example 17. \n"
20165 "\n"
20166 "\n"
20167 "\n"
20168 "SYNOPSIS:\n"
20169 "\n"
20170 "plstripa(id, p, x, y)\n"
20171 "\n"
20172 "ARGUMENTS:\n"
20173 "\n"
20174 " id (PLINT, input) : Identification number (set up in plstripc) of\n"
20175 " the strip chart. \n"
20176 "\n"
20177 " p (PLINT, input) : Pen number (ranges from 0 to 3). \n"
20178 "\n"
20179 " x (PLFLT, input) : X coordinate of point to plot. \n"
20180 "\n"
20181 " y (PLFLT, input) : Y coordinate of point to plot. \n"
20182 "\n"
20183 ""},
20184 { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
20185 "Create a 4-pen strip chart \n"
20186 "\n"
20187 "DESCRIPTION:\n"
20188 "\n"
20189 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20190 "\n"
20191 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20192 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20193 " styline, legline, labx, laby, labz)\n"
20194 " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
20195 " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
20196 " ypsec, legline, labx, laby, labtop)\n"
20197 "\n"
20198 "\n"
20199 " This function is used in example 17. \n"
20200 "\n"
20201 "\n"
20202 "\n"
20203 "SYNOPSIS:\n"
20204 "\n"
20205 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20206 "\n"
20207 "ARGUMENTS:\n"
20208 "\n"
20209 " id (PLINT *, output) : Identification number of strip chart to use\n"
20210 " on plstripa and plstripd. \n"
20211 "\n"
20212 " xspec (char *, input) : X-axis specification as in plbox. \n"
20213 "\n"
20214 " yspec (char *, input) : Y-axis specification as in plbox. \n"
20215 "\n"
20216 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20217 " change as data are added. \n"
20218 "\n"
20219 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20220 " change as data are added. \n"
20221 "\n"
20222 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
20223 " is multiplied by the factor (1 + \n"
20224 " xjump). \n"
20225 "\n"
20226 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20227 " change as data are added. \n"
20228 "\n"
20229 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20230 " change as data are added. \n"
20231 "\n"
20232 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
20233 "\n"
20234 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
20235 "\n"
20236 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
20237 " true, otherwise not. \n"
20238 "\n"
20239 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
20240 " otherwise slide display. \n"
20241 "\n"
20242 " colbox (PLINT, input) : Plot box color index (cmap0). \n"
20243 "\n"
20244 " collab (PLINT, input) : Legend color index (cmap0). \n"
20245 "\n"
20246 " colline (PLINT *, input) : Pointer to array with color indices\n"
20247 " (cmap0) for the 4 pens. \n"
20248 "\n"
20249 " styline (PLINT *, input) : Pointer to array with line styles for\n"
20250 " the 4 pens. \n"
20251 "\n"
20252 " legline (char **, input) : Pointer to character array containing\n"
20253 " legends for the 4 pens. \n"
20254 "\n"
20255 " labx (char *, input) : X-axis label. \n"
20256 "\n"
20257 " laby (char *, input) : Y-axis label. \n"
20258 "\n"
20259 " labtop (char *, input) : Plot title. \n"
20260 "\n"
20261 ""},
20262 { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
20263 "Deletes and releases memory used by a strip chart \n"
20264 "\n"
20265 "DESCRIPTION:\n"
20266 "\n"
20267 " Deletes and releases memory used by a strip chart. \n"
20268 "\n"
20269 " Redacted form: plstripd(id)\n"
20270 "\n"
20271 " This function is used in example 17. \n"
20272 "\n"
20273 "\n"
20274 "\n"
20275 "SYNOPSIS:\n"
20276 "\n"
20277 "plstripd(id)\n"
20278 "\n"
20279 "ARGUMENTS:\n"
20280 "\n"
20281 " id (PLINT, input) : Identification number of strip chart to delete. \n"
20282 "\n"
20283 ""},
20284 { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
20285 "Set line style \n"
20286 "\n"
20287 "DESCRIPTION:\n"
20288 "\n"
20289 " This sets up the line style for all lines subsequently drawn. A line\n"
20290 " consists of segments in which the pen is alternately down and up. The\n"
20291 " lengths of these segments are passed in the arrays mark and space\n"
20292 " respectively. The number of mark-space pairs is specified by nels. \n"
20293 " In order to return the line style to the default continuous line,\n"
20294 " plstyl should be called with nels=0.(see also pllsty) \n"
20295 "\n"
20296 " Redacted form: plstyl(mark, space)\n"
20297 "\n"
20298 " This function is used in examples 1,9,14. \n"
20299 "\n"
20300 "\n"
20301 "\n"
20302 "SYNOPSIS:\n"
20303 "\n"
20304 "plstyl(nels, mark, space)\n"
20305 "\n"
20306 "ARGUMENTS:\n"
20307 "\n"
20308 " nels (PLINT, input) : The number of mark and space elements in a\n"
20309 " line. Thus a simple broken line can be obtained by setting\n"
20310 " nels=1. A continuous line is specified by setting nels=0. \n"
20311 "\n"
20312 " mark (PLINT *, input) : Pointer to array with the lengths of the\n"
20313 " segments during which the pen is down, measured in micrometers. \n"
20314 "\n"
20315 " space (PLINT *, input) : Pointer to array with the lengths of the\n"
20316 " segments during which the pen is up, measured in micrometers. \n"
20317 "\n"
20318 ""},
20319 { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
20320 "Set arrow style for vector plots \n"
20321 "\n"
20322 "DESCRIPTION:\n"
20323 "\n"
20324 " Set the style for the arrow used by plvect to plot vectors. \n"
20325 "\n"
20326 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20327 "\n"
20328 " This function is used in example 22. \n"
20329 "\n"
20330 "\n"
20331 "\n"
20332 "SYNOPSIS:\n"
20333 "\n"
20334 "plsvect(arrowx, arrowy, npts, fill)\n"
20335 "\n"
20336 "ARGUMENTS:\n"
20337 "\n"
20338 " arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n"
20339 " containing the x and y points which make up the arrow. The arrow\n"
20340 " is plotted by joining these points to form a polygon. The scaling\n"
20341 " assumes that the x and y points in the arrow lie in the range -0.5\n"
20342 " <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n"
20343 " style will be reset to its default. \n"
20344 "\n"
20345 " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
20346 " arrowy. \n"
20347 "\n"
20348 " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
20349 " fill is false then the arrow is open. \n"
20350 "\n"
20351 ""},
20352 { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
20353 "Specify viewport in absolute coordinates \n"
20354 "\n"
20355 "DESCRIPTION:\n"
20356 "\n"
20357 " Alternate routine to plvpor for setting up the viewport. This routine\n"
20358 " should be used only if the viewport is required to have a definite\n"
20359 " size in millimeters. The routine plgspa is useful for finding out the\n"
20360 " size of the current subpage. \n"
20361 "\n"
20362 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20363 "\n"
20364 " This function is used in example 10. \n"
20365 "\n"
20366 "\n"
20367 "\n"
20368 "SYNOPSIS:\n"
20369 "\n"
20370 "plsvpa(xmin, xmax, ymin, ymax)\n"
20371 "\n"
20372 "ARGUMENTS:\n"
20373 "\n"
20374 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20375 " viewport from the left-hand edge of the subpage in millimeters. \n"
20376 "\n"
20377 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20378 " viewport from the left-hand edge of the subpage in millimeters. \n"
20379 "\n"
20380 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20381 " viewport from the bottom edge of the subpage in millimeters. \n"
20382 "\n"
20383 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20384 " from the bottom edge of the subpage in millimeters. \n"
20385 "\n"
20386 ""},
20387 { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
20388 "Set x axis parameters \n"
20389 "\n"
20390 "DESCRIPTION:\n"
20391 "\n"
20392 " Sets values of the digmax and digits flags for the x axis. See the\n"
20393 " PLplot documentation for more information. \n"
20394 "\n"
20395 " Redacted form: plsxax(digmax, digits)\n"
20396 "\n"
20397 " This function is used in example 31. \n"
20398 "\n"
20399 "\n"
20400 "\n"
20401 "SYNOPSIS:\n"
20402 "\n"
20403 "plsxax(digmax, digits)\n"
20404 "\n"
20405 "ARGUMENTS:\n"
20406 "\n"
20407 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20408 " digits for the x axis. If nonzero, the printed label will be\n"
20409 " switched to a floating point representation when the number of\n"
20410 " digits exceeds digmax. \n"
20411 "\n"
20412 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20413 " its value here has no effect since it is set only by plbox or\n"
20414 " plbox3. However, the user may obtain its value after a call to\n"
20415 " either of these functions by calling plgxax. \n"
20416 "\n"
20417 ""},
20418 { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
20419 "Set y axis parameters \n"
20420 "\n"
20421 "DESCRIPTION:\n"
20422 "\n"
20423 " Identical to plsxax, except that arguments are flags for y axis. See\n"
20424 " the description of plsxax for more detail. \n"
20425 "\n"
20426 " Redacted form: plsyax(digmax, digits)\n"
20427 "\n"
20428 " This function is used in examples 1,14,31. \n"
20429 "\n"
20430 "\n"
20431 "\n"
20432 "SYNOPSIS:\n"
20433 "\n"
20434 "plsyax(digmax, digits)\n"
20435 "\n"
20436 "ARGUMENTS:\n"
20437 "\n"
20438 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20439 " digits for the y axis. If nonzero, the printed label will be\n"
20440 " switched to a floating point representation when the number of\n"
20441 " digits exceeds digmax. \n"
20442 "\n"
20443 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20444 " its value here has no effect since it is set only by plbox or\n"
20445 " plbox3. However, the user may obtain its value after a call to\n"
20446 " either of these functions by calling plgyax. \n"
20447 "\n"
20448 ""},
20449 { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
20450 "Plot a glyph at the specified points \n"
20451 "\n"
20452 "DESCRIPTION:\n"
20453 "\n"
20454 " Plot a glyph at the specified points. (This function is largely\n"
20455 " superseded by plstring which gives access to many[!] more glyphs.) \n"
20456 "\n"
20457 " Redacted form: plsym(x, y, code)\n"
20458 "\n"
20459 " This function is used in example 7. \n"
20460 "\n"
20461 "\n"
20462 "\n"
20463 "SYNOPSIS:\n"
20464 "\n"
20465 "plsym(n, x, y, code)\n"
20466 "\n"
20467 "ARGUMENTS:\n"
20468 "\n"
20469 " n (PLINT, input) : Number of points in the x and y arrays. \n"
20470 "\n"
20471 " x (PLFLT *, input) : Pointer to an array with X coordinates of\n"
20472 " points. \n"
20473 "\n"
20474 " y (PLFLT *, input) : Pointer to an array with Y coordinates of\n"
20475 " points. \n"
20476 "\n"
20477 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
20478 " to be plotted at each of the n points. \n"
20479 "\n"
20480 ""},
20481 { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
20482 "Set z axis parameters \n"
20483 "\n"
20484 "DESCRIPTION:\n"
20485 "\n"
20486 " Identical to plsxax, except that arguments are flags for z axis. See\n"
20487 " the description of plsxax for more detail. \n"
20488 "\n"
20489 " Redacted form: plszax(digmax, digits)\n"
20490 "\n"
20491 " This function is used in example 31. \n"
20492 "\n"
20493 "\n"
20494 "\n"
20495 "SYNOPSIS:\n"
20496 "\n"
20497 "plszax(digmax, digits)\n"
20498 "\n"
20499 "ARGUMENTS:\n"
20500 "\n"
20501 " digmax (PLINT, input) : Variable to set the maximum number of\n"
20502 " digits for the z axis. If nonzero, the printed label will be\n"
20503 " switched to a floating point representation when the number of\n"
20504 " digits exceeds digmax. \n"
20505 "\n"
20506 " digits (PLINT, input) : Field digits value. Currently, changing\n"
20507 " its value here has no effect since it is set only by plbox or\n"
20508 " plbox3. However, the user may obtain its value after a call to\n"
20509 " either of these functions by calling plgzax. \n"
20510 "\n"
20511 ""},
20512 { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
20513 "Switch to text screen \n"
20514 "\n"
20515 "DESCRIPTION:\n"
20516 "\n"
20517 " Sets an interactive device to text mode, used in conjunction with\n"
20518 " plgra to allow graphics and text to be interspersed. On a device\n"
20519 " which supports separate text and graphics windows, this command causes\n"
20520 " control to be switched to the text window. This can be useful for\n"
20521 " printing diagnostic messages or getting user input, which would\n"
20522 " otherwise interfere with the plots. The program must switch back to\n"
20523 " the graphics window before issuing plot commands, as the text (or\n"
20524 " console) device will probably become quite confused otherwise. If\n"
20525 " already in text mode, this command is ignored. It is also ignored on\n"
20526 " devices which only support a single window or use a different method\n"
20527 " for shifting focus (see also plgra). \n"
20528 "\n"
20529 " Redacted form: pltext()\n"
20530 "\n"
20531 " This function is used in example 1. \n"
20532 "\n"
20533 "\n"
20534 "\n"
20535 "SYNOPSIS:\n"
20536 "\n"
20537 "pltext()\n"
20538 "\n"
20539 ""},
20540 { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
20541 "Set format for date / time labels \n"
20542 "\n"
20543 "DESCRIPTION:\n"
20544 "\n"
20545 " Sets the format for date / time labels. To enable date / time format\n"
20546 " labels see the options to plbox and plenv. \n"
20547 "\n"
20548 " Redacted form: pltimefmt(fmt)\n"
20549 "\n"
20550 " This function is used in example 29. \n"
20551 "\n"
20552 "\n"
20553 "\n"
20554 "SYNOPSIS:\n"
20555 "\n"
20556 "pltimefmt(fmt)\n"
20557 "\n"
20558 "ARGUMENTS:\n"
20559 "\n"
20560 " fmt (const char *, fmt) : This string is passed directly to the\n"
20561 " system strftime. See the system documentation for a full list of\n"
20562 " conversion specifications for your system. All conversion\n"
20563 " specifications take the form of a '%' character followed by\n"
20564 " further conversion specification character. All other text is\n"
20565 " printed as-is. Common options include: %c: The preferred date and\n"
20566 " time representation for the current locale. \n"
20567 " %d: The day of the month as a decimal number. \n"
20568 " %H: The hour as a decimal number using a 24-hour clock. \n"
20569 " %j: The day of the year as a decimal number. \n"
20570 " %m: The month as a decimal number. \n"
20571 " %M: The minute as a decimal number. \n"
20572 " %S: The second as a decimal number. \n"
20573 " %y: The year as a decimal number without a century. \n"
20574 " %Y: The year as a decimal number including a century. \n"
20575 "\n"
20576 ""},
20577 { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
20578 "Specify viewport using aspect ratio only \n"
20579 "\n"
20580 "DESCRIPTION:\n"
20581 "\n"
20582 " Sets the viewport so that the ratio of the length of the y axis to\n"
20583 " that of the x axis is equal to aspect. \n"
20584 "\n"
20585 " Redacted form: plvasp(aspect)\n"
20586 "\n"
20587 " This function is used in example 13. \n"
20588 "\n"
20589 "\n"
20590 "\n"
20591 "SYNOPSIS:\n"
20592 "\n"
20593 "plvasp(aspect)\n"
20594 "\n"
20595 "ARGUMENTS:\n"
20596 "\n"
20597 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20598 " axis. \n"
20599 "\n"
20600 ""},
20601 { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
20602 "Vector plot \n"
20603 "\n"
20604 "DESCRIPTION:\n"
20605 "\n"
20606 " Draws a vector plot of the vector (\n"
20607 " u[\n"
20608 " nx][\n"
20609 " ny],\n"
20610 " v[\n"
20611 " nx][\n"
20612 " ny]). The scaling factor for the vectors is given by scale. A\n"
20613 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
20614 " additional data required by the transformation routine is used to map\n"
20615 " indices within the array to the world coordinates. The style of the\n"
20616 " vector arrow may be set using plsvect. \n"
20617 "\n"
20618 " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
20619 "\n"
20620 " This function is used in example 22. \n"
20621 "\n"
20622 "\n"
20623 "\n"
20624 "SYNOPSIS:\n"
20625 "\n"
20626 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
20627 "\n"
20628 "ARGUMENTS:\n"
20629 "\n"
20630 " u, v (PLFLT **, input) : Pointers to a pair of vectored\n"
20631 " two-dimensional arrays containing the x and y components of the\n"
20632 " vector data to be plotted. \n"
20633 "\n"
20634 " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
20635 "\n"
20636 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
20637 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
20638 " automatically calculated for the data. If scale < 0 then the\n"
20639 " scaling factor is automatically calculated for the data and then\n"
20640 " multiplied by -\n"
20641 " scale. If scale > 0 then the scaling factor is set to scale. \n"
20642 "\n"
20643 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20644 " Pointer to function that defines transformation between indices\n"
20645 " in array z and the world coordinates (C only). Transformation\n"
20646 " functions are provided in the PLplot library: pltr0 for identity\n"
20647 " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20648 " defined by one- and two-dimensional arrays. In addition,\n"
20649 " user-supplied routines for the transformation can be used as well.\n"
20650 " Examples of all of these approaches are given in the PLplot\n"
20651 " documentation. The transformation function should have the form\n"
20652 " given by any of pltr0, pltr1, or pltr2. \n"
20653 "\n"
20654 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20655 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20656 " externally supplied. \n"
20657 "\n"
20658 ""},
20659 { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
20660 "Specify viewport using coordinates and aspect ratio \n"
20661 "\n"
20662 "DESCRIPTION:\n"
20663 "\n"
20664 " Device-independent routine for setting up the viewport. The viewport\n"
20665 " is chosen to be the largest with the given aspect ratio that fits\n"
20666 " within the specified region (in terms of normalized subpage\n"
20667 " coordinates). This routine is functionally equivalent to plvpor when\n"
20668 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
20669 " routine reserves no extra space at the edges for labels. \n"
20670 "\n"
20671 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20672 "\n"
20673 " This function is used in example 9. \n"
20674 "\n"
20675 "\n"
20676 "\n"
20677 "SYNOPSIS:\n"
20678 "\n"
20679 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
20680 "\n"
20681 "ARGUMENTS:\n"
20682 "\n"
20683 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20684 " left-hand edge of the viewport. \n"
20685 "\n"
20686 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20687 " right-hand edge of the viewport. \n"
20688 "\n"
20689 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20690 " bottom edge of the viewport. \n"
20691 "\n"
20692 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20693 " edge of the viewport. \n"
20694 "\n"
20695 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
20696 " axis. \n"
20697 "\n"
20698 ""},
20699 { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
20700 "Specify viewport using coordinates \n"
20701 "\n"
20702 "DESCRIPTION:\n"
20703 "\n"
20704 " Device-independent routine for setting up the viewport. This defines\n"
20705 " the viewport in terms of normalized subpage coordinates which run from\n"
20706 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
20707 " current subpage. Use the alternate routine plsvpa in order to create\n"
20708 " a viewport of a definite size. \n"
20709 "\n"
20710 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
20711 "\n"
20712 " This function is used in examples\n"
20713 " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
20714 "\n"
20715 "\n"
20716 "\n"
20717 "SYNOPSIS:\n"
20718 "\n"
20719 "plvpor(xmin, xmax, ymin, ymax)\n"
20720 "\n"
20721 "ARGUMENTS:\n"
20722 "\n"
20723 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
20724 " left-hand edge of the viewport. \n"
20725 "\n"
20726 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
20727 " right-hand edge of the viewport. \n"
20728 "\n"
20729 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
20730 " bottom edge of the viewport. \n"
20731 "\n"
20732 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
20733 " edge of the viewport. \n"
20734 "\n"
20735 ""},
20736 { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
20737 "Select standard viewport \n"
20738 "\n"
20739 "DESCRIPTION:\n"
20740 "\n"
20741 " Sets up a standard viewport, leaving a left-hand margin of seven\n"
20742 " character heights, and four character heights around the other three\n"
20743 " sides. \n"
20744 "\n"
20745 " Redacted form: plvsta()\n"
20746 "\n"
20747 " This function is used in examples 1,12,14,17,25,29. \n"
20748 "\n"
20749 "\n"
20750 "\n"
20751 "SYNOPSIS:\n"
20752 "\n"
20753 "plvsta()\n"
20754 "\n"
20755 ""},
20756 { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
20757 "Set up window for 3-d plotting \n"
20758 "\n"
20759 "DESCRIPTION:\n"
20760 "\n"
20761 " Sets up a window for a three-dimensional surface plot within the\n"
20762 " currently defined two-dimensional window. The enclosing box for the\n"
20763 " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
20764 " user-coordinate space is mapped into a box of world coordinate size\n"
20765 " basex by basey by height so that xmin maps to -\n"
20766 " basex/2, xmax maps to basex/2, ymin maps to -\n"
20767 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
20768 " The resulting world-coordinate box is then viewed by an observer at\n"
20769 " altitude alt and azimuth az. This routine must be called before\n"
20770 " plbox3 or plot3d. For a more complete description of\n"
20771 " three-dimensional plotting see the PLplot documentation. \n"
20772 "\n"
20773 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
20774 " zmin, zmax, alt, az)\n"
20775 "\n"
20776 " This function is examples 8,11,18,21. \n"
20777 "\n"
20778 "\n"
20779 "\n"
20780 "SYNOPSIS:\n"
20781 "\n"
20782 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
20783 "\n"
20784 "ARGUMENTS:\n"
20785 "\n"
20786 " basex (PLFLT, input) : The x coordinate size of the\n"
20787 " world-coordinate box. \n"
20788 "\n"
20789 " basey (PLFLT, input) : The y coordinate size of the\n"
20790 " world-coordinate box. \n"
20791 "\n"
20792 " height (PLFLT, input) : The z coordinate size of the\n"
20793 " world-coordinate box. \n"
20794 "\n"
20795 " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
20796 "\n"
20797 " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
20798 "\n"
20799 " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
20800 "\n"
20801 " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
20802 "\n"
20803 " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
20804 "\n"
20805 " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
20806 "\n"
20807 " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
20808 " plane. \n"
20809 "\n"
20810 " az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n"
20811 " observer is looking face onto the ZX plane, and as az is\n"
20812 " increased, the observer moves clockwise around the box when viewed\n"
20813 " from above the XY plane. \n"
20814 "\n"
20815 ""},
20816 { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
20817 "Set pen width \n"
20818 "\n"
20819 "DESCRIPTION:\n"
20820 "\n"
20821 " Sets the pen width. \n"
20822 "\n"
20823 " Redacted form: plwidth(width)\n"
20824 "\n"
20825 " This function is used in examples 1,2. \n"
20826 "\n"
20827 "\n"
20828 "\n"
20829 "SYNOPSIS:\n"
20830 "\n"
20831 "plwidth(width)\n"
20832 "\n"
20833 "ARGUMENTS:\n"
20834 "\n"
20835 " width (PLFLT, input) : The desired pen width. If width is negative\n"
20836 " or the same as the previous value no action is taken. width = 0.\n"
20837 " should be interpreted as as the minimum valid pen width for the\n"
20838 " device. The interpretation of positive width values is also\n"
20839 " device dependent. \n"
20840 "\n"
20841 ""},
20842 { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
20843 "Specify world coordinates of viewport boundaries \n"
20844 "\n"
20845 "DESCRIPTION:\n"
20846 "\n"
20847 " Sets up the world coordinates of the edges of the viewport. \n"
20848 "\n"
20849 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
20850 "\n"
20851 " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
20852 "\n"
20853 "\n"
20854 "\n"
20855 "SYNOPSIS:\n"
20856 "\n"
20857 "plwind(xmin, xmax, ymin, ymax)\n"
20858 "\n"
20859 "ARGUMENTS:\n"
20860 "\n"
20861 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
20862 " of the viewport. \n"
20863 "\n"
20864 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
20865 " of the viewport. \n"
20866 "\n"
20867 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
20868 " the viewport. \n"
20869 "\n"
20870 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
20871 " viewport. \n"
20872 "\n"
20873 ""},
20874 { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
20875 "Enter or leave xor mode \n"
20876 "\n"
20877 "DESCRIPTION:\n"
20878 "\n"
20879 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
20880 " those drivers (e.g., the xwin driver) that support it. Enables\n"
20881 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
20882 " is not capable of xor operation it returns a status of false. \n"
20883 "\n"
20884 " Redacted form: plxormod(mode, status)\n"
20885 "\n"
20886 " This function is used in examples 1,20. \n"
20887 "\n"
20888 "\n"
20889 "\n"
20890 "SYNOPSIS:\n"
20891 "\n"
20892 "plxormod(mode, status)\n"
20893 "\n"
20894 "ARGUMENTS:\n"
20895 "\n"
20896 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
20897 " is false means leave xor mode. \n"
20898 "\n"
20899 " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
20900 " of true (false) means driver is capable (incapable) of xor mode. \n"
20901 "\n"
20902 ""},
20903 { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
20904 "Plot continental outline in world coordinates. \n"
20905 "\n"
20906 "DESCRIPTION:\n"
20907 "\n"
20908 " Plots continental outlines in world coordinates. examples/c/x19c\n"
20909 " demonstrates how to use this function to create different\n"
20910 " projections. \n"
20911 "\n"
20912 " Redacted form: General: plmap(mapform, type, minlong, maxlong,\n"
20913 " minlat, maxlat)\n"
20914 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20915 "\n"
20916 "\n"
20917 " This function is used in example 19. \n"
20918 "\n"
20919 "\n"
20920 "\n"
20921 "SYNOPSIS:\n"
20922 "\n"
20923 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
20924 "\n"
20925 "ARGUMENTS:\n"
20926 "\n"
20927 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20928 " supplied function to transform the coordinate longitudes and\n"
20929 " latitudes to a plot coordinate system. By using this transform,\n"
20930 " we can change from a longitude, latitude coordinate to a polar\n"
20931 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20932 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20933 " After the call to mapform(), x[] and y[] should be replaced by\n"
20934 " the corresponding plot coordinates. If no transform is desired,\n"
20935 " mapform can be replaced by NULL. \n"
20936 "\n"
20937 " type (char *, input) : type is a character string. The value of\n"
20938 " this parameter determines the type of background. The possible\n"
20939 " values are: \"globe\" -- continental outlines \n"
20940 " \"usa\" -- USA and state boundaries \n"
20941 " \"cglobe\" -- continental outlines and countries \n"
20942 " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
20943 "\n"
20944 "\n"
20945 " minlong (PLFLT, input) : The value of the longitude on the left\n"
20946 " side of the plot. The value of minlong must be less than the\n"
20947 " value of maxlong, and the quantity maxlong-minlong must be less\n"
20948 " than or equal to 360. \n"
20949 "\n"
20950 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
20951 " side of the plot. \n"
20952 "\n"
20953 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
20954 " background. One can always use -90.0 as the boundary outside the\n"
20955 " plot window will be automatically eliminated. However, the\n"
20956 " program will be faster if one can reduce the size of the\n"
20957 " background plotted. \n"
20958 "\n"
20959 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
20960 " background. One can always use 90.0 as the boundary outside the\n"
20961 " plot window will be automatically eliminated. \n"
20962 "\n"
20963 ""},
20964 { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
20965 "Plot latitude and longitude lines. \n"
20966 "\n"
20967 "DESCRIPTION:\n"
20968 "\n"
20969 " Displays latitude and longitude on the current plot. The lines are\n"
20970 " plotted in the current color and line style. \n"
20971 "\n"
20972 " Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n"
20973 " maxlong, minlat, maxlat)\n"
20974 " F95, Java, Perl/PDL, Python: Not implemented? \n"
20975 "\n"
20976 "\n"
20977 " This function is used in example 19. \n"
20978 "\n"
20979 "\n"
20980 "\n"
20981 "SYNOPSIS:\n"
20982 "\n"
20983 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
20984 "\n"
20985 "ARGUMENTS:\n"
20986 "\n"
20987 " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
20988 " supplied function to transform the coordinate longitudes and\n"
20989 " latitudes to a plot coordinate system. By using this transform,\n"
20990 " we can change from a longitude, latitude coordinate to a polar\n"
20991 " stereographic project, for example. Initially, x[0]..[n-1] are\n"
20992 " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
20993 " After the call to mapform(), x[] and y[] should be replaced by\n"
20994 " the corresponding plot coordinates. If no transform is desired,\n"
20995 " mapform can be replaced by NULL. \n"
20996 "\n"
20997 " dlong (PLFLT, input) : The interval in degrees at which the\n"
20998 " longitude lines are to be plotted. \n"
20999 "\n"
21000 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
21001 " lines are to be plotted. \n"
21002 "\n"
21003 " minlong (PLFLT, input) : The value of the longitude on the left\n"
21004 " side of the plot. The value of minlong must be less than the\n"
21005 " value of maxlong, and the quantity maxlong-minlong must be less\n"
21006 " than or equal to 360. \n"
21007 "\n"
21008 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
21009 " side of the plot. \n"
21010 "\n"
21011 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
21012 " background. One can always use -90.0 as the boundary outside the\n"
21013 " plot window will be automatically eliminated. However, the\n"
21014 " program will be faster if one can reduce the size of the\n"
21015 " background plotted. \n"
21016 "\n"
21017 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
21018 " background. One can always use 90.0 as the boundary outside the\n"
21019 " plot window will be automatically eliminated. \n"
21020 "\n"
21021 ""},
21022 { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
21023 "Plot a 2D matrix using color map1 with automatic colour adjustment \n"
21024 "\n"
21025 "DESCRIPTION:\n"
21026 "\n"
21027 " Plot a 2D matrix using color palette 1. The color scale is\n"
21028 " automatically adjusted to use the maximum and minimum values in idata\n"
21029 " as valuemin and valuemax in a call to plimagefr. \n"
21030 "\n"
21031 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
21032 " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
21033 "\n"
21034 "\n"
21035 " This function is used in example 20. \n"
21036 "\n"
21037 "\n"
21038 "\n"
21039 "SYNOPSIS:\n"
21040 "\n"
21041 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
21042 "\n"
21043 "ARGUMENTS:\n"
21044 "\n"
21045 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
21046 " plot. Should have dimensions idata[nx][ny]. \n"
21047 "\n"
21048 " nx, ny (PLINT, input) : Dimensions of idata \n"
21049 "\n"
21050 " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to stretch\n"
21051 " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
21052 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
21053 "\n"
21054 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
21055 " (inclusive) will be plotted. \n"
21056 "\n"
21057 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
21058 " points whose plot coordinates fall inside the window of (Dxmin,\n"
21059 " Dymin) to (Dxmax, Dymax). \n"
21060 "\n"
21061 ""},
21062 { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
21063 "Plot a 2D matrix using color map1 \n"
21064 "\n"
21065 "DESCRIPTION:\n"
21066 "\n"
21067 " Plot a 2D matrix using color map1. \n"
21068 "\n"
21069 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
21070 " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
21071 "\n"
21072 "\n"
21073 " This function is used in example 20. \n"
21074 "\n"
21075 "\n"
21076 "\n"
21077 "SYNOPSIS:\n"
21078 "\n"
21079 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
21080 "\n"
21081 "ARGUMENTS:\n"
21082 "\n"
21083 " idata (PLFLT**, input) : A 2D array of values (intensities) to\n"
21084 " plot. Should have dimensions idata[nx][ny]. \n"
21085 "\n"
21086 " nx, ny (PLINT, input) : Dimensions of idata \n"
21087 "\n"
21088 " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
21089 " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
21090 " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
21091 "\n"
21092 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
21093 " (inclusive) will be plotted. \n"
21094 "\n"
21095 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
21096 " values to use for value to color mappings. A datum equal to or\n"
21097 " less than valuemin will be plotted with color 0.0, while a datum\n"
21098 " equal to or greater than valuemax will be plotted with color 1.0. \n"
21099 " Data between valuemin and valuemax map linearly to colors between\n"
21100 " 0.0 and 1.0. \n"
21101 "\n"
21102 " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
21103 " Pointer to function that defines a transformation between the\n"
21104 " data in the array idata and world coordinates. An input\n"
21105 " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
21106 " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
21107 " Some transformation functions are provided in the PLplot library:\n"
21108 " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
21109 " mappings respectively defined by one- and two-dimensional arrays. \n"
21110 " In addition, user-supplied routines for the transformation can be\n"
21111 " used as well. Examples of all of these approaches are given in\n"
21112 " the PLplot documentation. The transformation function should have\n"
21113 " the form given by any of pltr0, pltr1, or pltr2. \n"
21114 "\n"
21115 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21116 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
21117 " externally supplied. \n"
21118 "\n"
21119 ""},
21120 { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
21121 { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
21122 { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
21123 { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
21124 { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
21125 { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
21126 { NULL, NULL, 0, NULL }
21127 };
21128
21129
21130 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21131
21132 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
21133 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
21134 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
21135 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21136 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
21137 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};
21138 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};
21139 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};
21140 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};
21141 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};
21142 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
21143 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
21144 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
21145 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
21146
21147 static swig_type_info *swig_type_initial[] = {
21148 &_swigt__p_PLGraphicsIn,
21149 &_swigt__p_PLcGrid,
21150 &_swigt__p_PLcGrid2,
21151 &_swigt__p_char,
21152 &_swigt__p_double,
21153 &_swigt__p_f_double_double__int,
21154 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
21155 &_swigt__p_f_int_double_p_char_int_p_void__void,
21156 &_swigt__p_f_int_p_double_p_double__void,
21157 &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
21158 &_swigt__p_int,
21159 &_swigt__p_p_char,
21160 &_swigt__p_p_double,
21161 &_swigt__p_unsigned_int,
21162 };
21163
21164 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
21165 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
21166 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
21167 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21168 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
21169 static swig_cast_info _swigc__p_f_double_double__int[] = { {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
21170 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}};
21171 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}};
21172 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}};
21173 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}};
21174 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21175 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
21176 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
21177 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21178
21179 static swig_cast_info *swig_cast_initial[] = {
21180 _swigc__p_PLGraphicsIn,
21181 _swigc__p_PLcGrid,
21182 _swigc__p_PLcGrid2,
21183 _swigc__p_char,
21184 _swigc__p_double,
21185 _swigc__p_f_double_double__int,
21186 _swigc__p_f_double_double_p_double_p_double_p_void__void,
21187 _swigc__p_f_int_double_p_char_int_p_void__void,
21188 _swigc__p_f_int_p_double_p_double__void,
21189 _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
21190 _swigc__p_int,
21191 _swigc__p_p_char,
21192 _swigc__p_p_double,
21193 _swigc__p_unsigned_int,
21194 };
21195
21196
21197 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21198
21199 static swig_const_info swig_const_table[] = {
21200 {0, 0, 0, 0.0, 0, 0}};
21201
21202 #ifdef __cplusplus
21203 }
21204 #endif
21205 /* -----------------------------------------------------------------------------
21206 * Type initialization:
21207 * This problem is tough by the requirement that no dynamic
21208 * memory is used. Also, since swig_type_info structures store pointers to
21209 * swig_cast_info structures and swig_cast_info structures store pointers back
21210 * to swig_type_info structures, we need some lookup code at initialization.
21211 * The idea is that swig generates all the structures that are needed.
21212 * The runtime then collects these partially filled structures.
21213 * The SWIG_InitializeModule function takes these initial arrays out of
21214 * swig_module, and does all the lookup, filling in the swig_module.types
21215 * array with the correct data and linking the correct swig_cast_info
21216 * structures together.
21217 *
21218 * The generated swig_type_info structures are assigned staticly to an initial
21219 * array. We just loop through that array, and handle each type individually.
21220 * First we lookup if this type has been already loaded, and if so, use the
21221 * loaded structure instead of the generated one. Then we have to fill in the
21222 * cast linked list. The cast data is initially stored in something like a
21223 * two-dimensional array. Each row corresponds to a type (there are the same
21224 * number of rows as there are in the swig_type_initial array). Each entry in
21225 * a column is one of the swig_cast_info structures for that type.
21226 * The cast_initial array is actually an array of arrays, because each row has
21227 * a variable number of columns. So to actually build the cast linked list,
21228 * we find the array of casts associated with the type, and loop through it
21229 * adding the casts to the list. The one last trick we need to do is making
21230 * sure the type pointer in the swig_cast_info struct is correct.
21231 *
21232 * First off, we lookup the cast->type name to see if it is already loaded.
21233 * There are three cases to handle:
21234 * 1) If the cast->type has already been loaded AND the type we are adding
21235 * casting info to has not been loaded (it is in this module), THEN we
21236 * replace the cast->type pointer with the type pointer that has already
21237 * been loaded.
21238 * 2) If BOTH types (the one we are adding casting info to, and the
21239 * cast->type) are loaded, THEN the cast info has already been loaded by
21240 * the previous module so we just ignore it.
21241 * 3) Finally, if cast->type has not already been loaded, then we add that
21242 * swig_cast_info to the linked list (because the cast->type) pointer will
21243 * be correct.
21244 * ----------------------------------------------------------------------------- */
21245
21246 #ifdef __cplusplus
21247 extern "C" {
21248 #if 0
21249 } /* c-mode */
21250 #endif
21251 #endif
21252
21253 #if 0
21254 #define SWIGRUNTIME_DEBUG
21255 #endif
21256
21257
21258 SWIGRUNTIME void
21259 SWIG_InitializeModule(void *clientdata) {
21260 size_t i;
21261 swig_module_info *module_head, *iter;
21262 int found, init;
21263
21264 clientdata = clientdata;
21265
21266 /* check to see if the circular list has been setup, if not, set it up */
21267 if (swig_module.next==0) {
21268 /* Initialize the swig_module */
21269 swig_module.type_initial = swig_type_initial;
21270 swig_module.cast_initial = swig_cast_initial;
21271 swig_module.next = &swig_module;
21272 init = 1;
21273 } else {
21274 init = 0;
21275 }
21276
21277 /* Try and load any already created modules */
21278 module_head = SWIG_GetModule(clientdata);
21279 if (!module_head) {
21280 /* This is the first module loaded for this interpreter */
21281 /* so set the swig module into the interpreter */
21282 SWIG_SetModule(clientdata, &swig_module);
21283 module_head = &swig_module;
21284 } else {
21285 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
21286 found=0;
21287 iter=module_head;
21288 do {
21289 if (iter==&swig_module) {
21290 found=1;
21291 break;
21292 }
21293 iter=iter->next;
21294 } while (iter!= module_head);
21295
21296 /* if the is found in the list, then all is done and we may leave */
21297 if (found) return;
21298 /* otherwise we must add out module into the list */
21299 swig_module.next = module_head->next;
21300 module_head->next = &swig_module;
21301 }
21302
21303 /* When multiple interpeters are used, a module could have already been initialized in
21304 a different interpreter, but not yet have a pointer in this interpreter.
21305 In this case, we do not want to continue adding types... everything should be
21306 set up already */
21307 if (init == 0) return;
21308
21309 /* Now work on filling in swig_module.types */
21310 #ifdef SWIGRUNTIME_DEBUG
21311 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
21312 #endif
21313 for (i = 0; i < swig_module.size; ++i) {
21314 swig_type_info *type = 0;
21315 swig_type_info *ret;
21316 swig_cast_info *cast;
21317
21318 #ifdef SWIGRUNTIME_DEBUG
21319 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21320 #endif
21321
21322 /* if there is another module already loaded */
21323 if (swig_module.next != &swig_module) {
21324 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
21325 }
21326 if (type) {
21327 /* Overwrite clientdata field */
21328 #ifdef SWIGRUNTIME_DEBUG
21329 printf("SWIG_InitializeModule: found type %s\n", type->name);
21330 #endif
21331 if (swig_module.type_initial[i]->clientdata) {
21332 type->clientdata = swig_module.type_initial[i]->clientdata;
21333 #ifdef SWIGRUNTIME_DEBUG
21334 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
21335 #endif
21336 }
21337 } else {
21338 type = swig_module.type_initial[i];
21339 }
21340
21341 /* Insert casting types */
21342 cast = swig_module.cast_initial[i];
21343 while (cast->type) {
21344 /* Don't need to add information already in the list */
21345 ret = 0;
21346 #ifdef SWIGRUNTIME_DEBUG
21347 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
21348 #endif
21349 if (swig_module.next != &swig_module) {
21350 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
21351 #ifdef SWIGRUNTIME_DEBUG
21352 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
21353 #endif
21354 }
21355 if (ret) {
21356 if (type == swig_module.type_initial[i]) {
21357 #ifdef SWIGRUNTIME_DEBUG
21358 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
21359 #endif
21360 cast->type = ret;
21361 ret = 0;
21362 } else {
21363 /* Check for casting already in the list */
21364 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
21365 #ifdef SWIGRUNTIME_DEBUG
21366 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
21367 #endif
21368 if (!ocast) ret = 0;
21369 }
21370 }
21371
21372 if (!ret) {
21373 #ifdef SWIGRUNTIME_DEBUG
21374 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
21375 #endif
21376 if (type->cast) {
21377 type->cast->prev = cast;
21378 cast->next = type->cast;
21379 }
21380 type->cast = cast;
21381 }
21382 cast++;
21383 }
21384 /* Set entry in modules->types array equal to the type */
21385 swig_module.types[i] = type;
21386 }
21387 swig_module.types[i] = 0;
21388
21389 #ifdef SWIGRUNTIME_DEBUG
21390 printf("**** SWIG_InitializeModule: Cast List ******\n");
21391 for (i = 0; i < swig_module.size; ++i) {
21392 int j = 0;
21393 swig_cast_info *cast = swig_module.cast_initial[i];
21394 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21395 while (cast->type) {
21396 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21397 cast++;
21398 ++j;
21399 }
21400 printf("---- Total casts: %d\n",j);
21401 }
21402 printf("**** SWIG_InitializeModule: Cast List ******\n");
21403 #endif
21404 }
21405
21406 /* This function will propagate the clientdata field of type to
21407 * any new swig_type_info structures that have been added into the list
21408 * of equivalent types. It is like calling
21409 * SWIG_TypeClientData(type, clientdata) a second time.
21410 */
21411 SWIGRUNTIME void
21412 SWIG_PropagateClientData(void) {
21413 size_t i;
21414 swig_cast_info *equiv;
21415 static int init_run = 0;
21416
21417 if (init_run) return;
21418 init_run = 1;
21419
21420 for (i = 0; i < swig_module.size; i++) {
21421 if (swig_module.types[i]->clientdata) {
21422 equiv = swig_module.types[i]->cast;
21423 while (equiv) {
21424 if (!equiv->converter) {
21425 if (equiv->type && !equiv->type->clientdata)
21426 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21427 }
21428 equiv = equiv->next;
21429 }
21430 }
21431 }
21432 }
21433
21434 #ifdef __cplusplus
21435 #if 0
21436 {
21437 /* c-mode */
21438 #endif
21439 }
21440 #endif
21441
21442
21443
21444 #ifdef __cplusplus
21445 extern "C" {
21446 #endif
21447
21448 /* Python-specific SWIG API */
21449 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21450 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21451 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21452
21453 /* -----------------------------------------------------------------------------
21454 * global variable support code.
21455 * ----------------------------------------------------------------------------- */
21456
21457 typedef struct swig_globalvar {
21458 char *name; /* Name of global variable */
21459 PyObject *(*get_attr)(void); /* Return the current value */
21460 int (*set_attr)(PyObject *); /* Set the value */
21461 struct swig_globalvar *next;
21462 } swig_globalvar;
21463
21464 typedef struct swig_varlinkobject {
21465 PyObject_HEAD
21466 swig_globalvar *vars;
21467 } swig_varlinkobject;
21468
21469 SWIGINTERN PyObject *
21470 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
21471 #if PY_VERSION_HEX >= 0x03000000
21472 return PyUnicode_InternFromString("<Swig global variables>");
21473 #else
21474 return PyString_FromString("<Swig global variables>");
21475 #endif
21476 }
21477
21478 SWIGINTERN PyObject *
21479 swig_varlink_str(swig_varlinkobject *v) {
21480 #if PY_VERSION_HEX >= 0x03000000
21481 PyObject *str = PyUnicode_InternFromString("(");
21482 PyObject *tail;
21483 PyObject *joined;
21484 swig_globalvar *var;
21485 for (var = v->vars; var; var=var->next) {
21486 tail = PyUnicode_FromString(var->name);
21487 joined = PyUnicode_Concat(str, tail);
21488 Py_DecRef(str);
21489 Py_DecRef(tail);
21490 str = joined;
21491 if (var->next) {
21492 tail = PyUnicode_InternFromString(", ");
21493 joined = PyUnicode_Concat(str, tail);
21494 Py_DecRef(str);
21495 Py_DecRef(tail);
21496 str = joined;
21497 }
21498 }
21499 tail = PyUnicode_InternFromString(")");
21500 joined = PyUnicode_Concat(str, tail);
21501 Py_DecRef(str);
21502 Py_DecRef(tail);
21503 str = joined;
21504 #else
21505 PyObject *str = PyString_FromString("(");
21506 swig_globalvar *var;
21507 for (var = v->vars; var; var=var->next) {
21508 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
21509 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
21510 }
21511 PyString_ConcatAndDel(&str,PyString_FromString(")"));
21512 #endif
21513 return str;
21514 }
21515
21516 SWIGINTERN int
21517 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
21518 char *tmp;
21519 PyObject *str = swig_varlink_str(v);
21520 fprintf(fp,"Swig global variables ");
21521 fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
21522 SWIG_Python_str_DelForPy3(tmp);
21523 Py_DECREF(str);
21524 return 0;
21525 }
21526
21527 SWIGINTERN void
21528 swig_varlink_dealloc(swig_varlinkobject *v) {
21529 swig_globalvar *var = v->vars;
21530 while (var) {
21531 swig_globalvar *n = var->next;
21532 free(var->name);
21533 free(var);
21534 var = n;
21535 }
21536 }
21537
21538 SWIGINTERN PyObject *
21539 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21540 PyObject *res = NULL;
21541 swig_globalvar *var = v->vars;
21542 while (var) {
21543 if (strcmp(var->name,n) == 0) {
21544 res = (*var->get_attr)();
21545 break;
21546 }
21547 var = var->next;
21548 }
21549 if (res == NULL && !PyErr_Occurred()) {
21550 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21551 }
21552 return res;
21553 }
21554
21555 SWIGINTERN int
21556 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21557 int res = 1;
21558 swig_globalvar *var = v->vars;
21559 while (var) {
21560 if (strcmp(var->name,n) == 0) {
21561 res = (*var->set_attr)(p);
21562 break;
21563 }
21564 var = var->next;
21565 }
21566 if (res == 1 && !PyErr_Occurred()) {
21567 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21568 }
21569 return res;
21570 }
21571
21572 SWIGINTERN PyTypeObject*
21573 swig_varlink_type(void) {
21574 static char varlink__doc__[] = "Swig var link object";
21575 static PyTypeObject varlink_type;
21576 static int type_init = 0;
21577 if (!type_init) {
21578 const PyTypeObject tmp = {
21579 /* PyObject header changed in Python 3 */
21580 #if PY_VERSION_HEX >= 0x03000000
21581 PyVarObject_HEAD_INIT(NULL, 0)
21582 #else
21583 PyObject_HEAD_INIT(NULL)
21584 0, /* ob_size */
21585 #endif
21586 (char *)"swigvarlink", /* tp_name */
21587 sizeof(swig_varlinkobject), /* tp_basicsize */
21588 0, /* tp_itemsize */
21589 (destructor) swig_varlink_dealloc, /* tp_dealloc */
21590 (printfunc) swig_varlink_print, /* tp_print */
21591 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
21592 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
21593 0, /* tp_compare */
21594 (reprfunc) swig_varlink_repr, /* tp_repr */
21595 0, /* tp_as_number */
21596 0, /* tp_as_sequence */
21597 0, /* tp_as_mapping */
21598 0, /* tp_hash */
21599 0, /* tp_call */
21600 (reprfunc) swig_varlink_str, /* tp_str */
21601 0, /* tp_getattro */
21602 0, /* tp_setattro */
21603 0, /* tp_as_buffer */
21604 0, /* tp_flags */
21605 varlink__doc__, /* tp_doc */
21606 0, /* tp_traverse */
21607 0, /* tp_clear */
21608 0, /* tp_richcompare */
21609 0, /* tp_weaklistoffset */
21610 #if PY_VERSION_HEX >= 0x02020000
21611 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21612 #endif
21613 #if PY_VERSION_HEX >= 0x02030000
21614 0, /* tp_del */
21615 #endif
21616 #if PY_VERSION_HEX >= 0x02060000
21617 0, /* tp_version */
21618 #endif
21619 #ifdef COUNT_ALLOCS
21620 0,0,0,0 /* tp_alloc -> tp_next */
21621 #endif
21622 };
21623 varlink_type = tmp;
21624 type_init = 1;
21625 #if PY_VERSION_HEX < 0x02020000
21626 varlink_type.ob_type = &PyType_Type;
21627 #else
21628 if (PyType_Ready(&varlink_type) < 0)
21629 return NULL;
21630 #endif
21631 }
21632 return &varlink_type;
21633 }
21634
21635 /* Create a variable linking object for use later */
21636 SWIGINTERN PyObject *
21637 SWIG_Python_newvarlink(void) {
21638 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
21639 if (result) {
21640 result->vars = 0;
21641 }
21642 return ((PyObject*) result);
21643 }
21644
21645 SWIGINTERN void
21646 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21647 swig_varlinkobject *v = (swig_varlinkobject *) p;
21648 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21649 if (gv) {
21650 size_t size = strlen(name)+1;
21651 gv->name = (char *)malloc(size);
21652 if (gv->name) {
21653 strncpy(gv->name,name,size);
21654 gv->get_attr = get_attr;
21655 gv->set_attr = set_attr;
21656 gv->next = v->vars;
21657 }
21658 }
21659 v->vars = gv;
21660 }
21661
21662 SWIGINTERN PyObject *
21663 SWIG_globals(void) {
21664 static PyObject *_SWIG_globals = 0;
21665 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
21666 return _SWIG_globals;
21667 }
21668
21669 /* -----------------------------------------------------------------------------
21670 * constants/methods manipulation
21671 * ----------------------------------------------------------------------------- */
21672
21673 /* Install Constants */
21674 SWIGINTERN void
21675 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21676 PyObject *obj = 0;
21677 size_t i;
21678 for (i = 0; constants[i].type; ++i) {
21679 switch(constants[i].type) {
21680 case SWIG_PY_POINTER:
21681 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21682 break;
21683 case SWIG_PY_BINARY:
21684 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21685 break;
21686 default:
21687 obj = 0;
21688 break;
21689 }
21690 if (obj) {
21691 PyDict_SetItemString(d, constants[i].name, obj);
21692 Py_DECREF(obj);
21693 }
21694 }
21695 }
21696
21697 /* -----------------------------------------------------------------------------*/
21698 /* Fix SwigMethods to carry the callback ptrs when needed */
21699 /* -----------------------------------------------------------------------------*/
21700
21701 SWIGINTERN void
21702 SWIG_Python_FixMethods(PyMethodDef *methods,
21703 swig_const_info *const_table,
21704 swig_type_info **types,
21705 swig_type_info **types_initial) {
21706 size_t i;
21707 for (i = 0; methods[i].ml_name; ++i) {
21708 const char *c = methods[i].ml_doc;
21709 if (c && (c = strstr(c, "swig_ptr: "))) {
21710 int j;
21711 swig_const_info *ci = 0;
21712 const char *name = c + 10;
21713 for (j = 0; const_table[j].type; ++j) {
21714 if (strncmp(const_table[j].name, name,
21715 strlen(const_table[j].name)) == 0) {
21716 ci = &(const_table[j]);
21717 break;
21718 }
21719 }
21720 if (ci) {
21721 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
21722 if (ptr) {
21723 size_t shift = (ci->ptype) - types;
21724 swig_type_info *ty = types_initial[shift];
21725 size_t ldoc = (c - methods[i].ml_doc);
21726 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21727 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21728 if (ndoc) {
21729 char *buff = ndoc;
21730 strncpy(buff, methods[i].ml_doc, ldoc);
21731 buff += ldoc;
21732 strncpy(buff, "swig_ptr: ", 10);
21733 buff += 10;
21734 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21735 methods[i].ml_doc = ndoc;
21736 }
21737 }
21738 }
21739 }
21740 }
21741 }
21742
21743 #ifdef __cplusplus
21744 }
21745 #endif
21746
21747 /* -----------------------------------------------------------------------------*
21748 * Partial Init method
21749 * -----------------------------------------------------------------------------*/
21750
21751 #ifdef __cplusplus
21752 extern "C"
21753 #endif
21754
21755 SWIGEXPORT
21756 #if PY_VERSION_HEX >= 0x03000000
21757 PyObject*
21758 #else
21759 void
21760 #endif
21761 SWIG_init(void) {
21762 PyObject *m, *d, *md;
21763 #if PY_VERSION_HEX >= 0x03000000
21764 static struct PyModuleDef SWIG_module = {
21765 # if PY_VERSION_HEX >= 0x03020000
21766 PyModuleDef_HEAD_INIT,
21767 # else
21768 {
21769 PyObject_HEAD_INIT(NULL)
21770 NULL, /* m_init */
21771 0, /* m_index */
21772 NULL, /* m_copy */
21773 },
21774 # endif
21775 (char *) SWIG_name,
21776 NULL,
21777 -1,
21778 SwigMethods,
21779 NULL,
21780 NULL,
21781 NULL,
21782 NULL
21783 };
21784 #endif
21785
21786 #if defined(SWIGPYTHON_BUILTIN)
21787 static SwigPyClientData SwigPyObject_clientdata = {
21788 0, 0, 0, 0, 0, 0, 0
21789 };
21790 static PyGetSetDef this_getset_def = {
21791 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
21792 };
21793 static SwigPyGetSet thisown_getset_closure = {
21794 (PyCFunction) SwigPyObject_own,
21795 (PyCFunction) SwigPyObject_own
21796 };
21797 static PyGetSetDef thisown_getset_def = {
21798 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
21799 };
21800 PyObject *metatype_args;
21801 PyTypeObject *builtin_pytype;
21802 int builtin_base_count;
21803 swig_type_info *builtin_basetype;
21804 PyObject *tuple;
21805 PyGetSetDescrObject *static_getset;
21806 PyTypeObject *metatype;
21807 SwigPyClientData *cd;
21808 PyObject *public_interface, *public_symbol;
21809 PyObject *this_descr;
21810 PyObject *thisown_descr;
21811 int i;
21812
21813 (void)builtin_pytype;
21814 (void)builtin_base_count;
21815 (void)builtin_basetype;
21816 (void)tuple;
21817 (void)static_getset;
21818
21819 /* metatype is used to implement static member variables. */
21820 metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
21821 assert(metatype_args);
21822 metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
21823 assert(metatype);
21824 Py_DECREF(metatype_args);
21825 metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
21826 assert(PyType_Ready(metatype) >= 0);
21827 #endif
21828
21829 /* Fix SwigMethods to carry the callback ptrs when needed */
21830 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
21831
21832 #if PY_VERSION_HEX >= 0x03000000
21833 m = PyModule_Create(&SWIG_module);
21834 #else
21835 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21836 #endif
21837 md = d = PyModule_GetDict(m);
21838
21839 SWIG_InitializeModule(0);
21840
21841 #ifdef SWIGPYTHON_BUILTIN
21842 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
21843 assert(SwigPyObject_stype);
21844 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
21845 if (!cd) {
21846 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
21847 SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
21848 } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
21849 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
21850 # if PY_VERSION_HEX >= 0x03000000
21851 return NULL;
21852 # else
21853 return;
21854 # endif
21855 }
21856
21857 /* All objects have a 'this' attribute */
21858 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
21859 (void)this_descr;
21860
21861 /* All objects have a 'thisown' attribute */
21862 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
21863 (void)thisown_descr;
21864
21865 public_interface = PyList_New(0);
21866 public_symbol = 0;
21867 (void)public_symbol;
21868
21869 PyDict_SetItemString(md, "__all__", public_interface);
21870 Py_DECREF(public_interface);
21871 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
21872 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
21873 for (i = 0; swig_const_table[i].name != 0; ++i)
21874 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
21875 #endif
21876
21877 SWIG_InstallConstants(d,swig_const_table);
21878
21879
21880 import_array();
21881
21882 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
21883 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
21884 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
21885 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
21886 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
21887 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
21888 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
21889 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
21890 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
21891 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
21892 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
21893 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
21894 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
21895 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
21896 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
21897 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
21898 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
21899 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
21900 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
21901 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
21902 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
21903 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
21904 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
21905 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
21906 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
21907 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
21908 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
21909 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
21910 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
21911 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
21912 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
21913 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
21914 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
21915 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
21916 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
21917 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
21918 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
21919 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
21920 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
21921 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
21922 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
21923 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
21924 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
21925 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
21926 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
21927 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
21928 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
21929 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
21930 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
21931 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
21932 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
21933 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
21934 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
21935 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
21936 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
21937 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
21938 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
21939 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
21940 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
21941 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
21942 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
21943 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
21944 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
21945 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
21946 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
21947 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
21948 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
21949 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
21950 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
21951 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
21952 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
21953 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
21954 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
21955 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
21956 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
21957 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
21958 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
21959 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
21960 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
21961 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
21962 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
21963 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
21964 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
21965 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
21966 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
21967 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
21968 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
21969 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
21970 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
21971 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
21972 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
21973 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
21974 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
21975 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
21976 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
21977 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
21978 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
21979 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
21980 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
21981 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
21982 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
21983 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
21984 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
21985 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
21986 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
21987 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
21988 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
21989 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
21990 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
21991 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
21992 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
21993 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
21994 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
21995 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
21996 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
21997 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
21998 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
21999 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
22000 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
22001 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
22002 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
22003 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
22004 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
22005 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
22006 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
22007 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
22008 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
22009 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
22010 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
22011 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
22012 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
22013 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
22014 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
22015 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
22016 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
22017 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
22018 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
22019 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
22020 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
22021 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
22022 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
22023 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
22024 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
22025 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
22026 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
22027 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
22028 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
22029 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
22030 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
22031 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
22032 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
22033 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
22034 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
22035 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
22036 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
22037 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
22038 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
22039 #if PY_VERSION_HEX >= 0x03000000
22040 return m;
22041 #else
22042 return;
22043 #endif
22044 }
22045