PLplot  5.12.0
 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.12
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #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 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
125 /* Use debug wrappers with the Python release dll */
126 # undef _DEBUG
127 # include <Python.h>
128 # define _DEBUG
129 #else
130 # include <Python.h>
131 #endif
132 
133 /* -----------------------------------------------------------------------------
134  * swigrun.swg
135  *
136  * This file contains generic C API SWIG runtime support for pointer
137  * type checking.
138  * ----------------------------------------------------------------------------- */
139 
140 /* This should only be incremented when either the layout of swig_type_info changes,
141  or for whatever reason, the runtime changes incompatibly */
142 #define SWIG_RUNTIME_VERSION "4"
143 
144 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
145 #ifdef SWIG_TYPE_TABLE
146 # define SWIG_QUOTE_STRING(x) #x
147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
149 #else
150 # define SWIG_TYPE_TABLE_NAME
151 #endif
152 
153 /*
154  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
155  creating a static or dynamic library from the SWIG runtime code.
156  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
157 
158  But only do this if strictly necessary, ie, if you have problems
159  with your compiler or suchlike.
160 */
161 
162 #ifndef SWIGRUNTIME
163 # define SWIGRUNTIME SWIGINTERN
164 #endif
165 
166 #ifndef SWIGRUNTIMEINLINE
167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
168 #endif
169 
170 /* Generic buffer size */
171 #ifndef SWIG_BUFFER_SIZE
172 # define SWIG_BUFFER_SIZE 1024
173 #endif
174 
175 /* Flags for pointer conversions */
176 #define SWIG_POINTER_DISOWN 0x1
177 #define SWIG_CAST_NEW_MEMORY 0x2
178 
179 /* Flags for new pointer objects */
180 #define SWIG_POINTER_OWN 0x1
181 
182 
183 /*
184  Flags/methods for returning states.
185 
186  The SWIG conversion methods, as ConvertPtr, return an integer
187  that tells if the conversion was successful or not. And if not,
188  an error code can be returned (see swigerrors.swg for the codes).
189 
190  Use the following macros/flags to set or process the returning
191  states.
192 
193  In old versions of SWIG, code such as the following was usually written:
194 
195  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
196  // success code
197  } else {
198  //fail code
199  }
200 
201  Now you can be more explicit:
202 
203  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
204  if (SWIG_IsOK(res)) {
205  // success code
206  } else {
207  // fail code
208  }
209 
210  which is the same really, but now you can also do
211 
212  Type *ptr;
213  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
214  if (SWIG_IsOK(res)) {
215  // success code
216  if (SWIG_IsNewObj(res) {
217  ...
218  delete *ptr;
219  } else {
220  ...
221  }
222  } else {
223  // fail code
224  }
225 
226  I.e., now SWIG_ConvertPtr can return new objects and you can
227  identify the case and take care of the deallocation. Of course that
228  also requires SWIG_ConvertPtr to return new result values, such as
229 
230  int SWIG_ConvertPtr(obj, ptr,...) {
231  if (<obj is ok>) {
232  if (<need new object>) {
233  *ptr = <ptr to new allocated object>;
234  return SWIG_NEWOBJ;
235  } else {
236  *ptr = <ptr to old object>;
237  return SWIG_OLDOBJ;
238  }
239  } else {
240  return SWIG_BADOBJ;
241  }
242  }
243 
244  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
245  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
246  SWIG errors code.
247 
248  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
249  allows to return the 'cast rank', for example, if you have this
250 
251  int food(double)
252  int fooi(int);
253 
254  and you call
255 
256  food(1) // cast rank '1' (1 -> 1.0)
257  fooi(1) // cast rank '0'
258 
259  just use the SWIG_AddCast()/SWIG_CheckState()
260 */
261 
262 #define SWIG_OK (0)
263 #define SWIG_ERROR (-1)
264 #define SWIG_IsOK(r) (r >= 0)
265 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
266 
267 /* The CastRankLimit says how many bits are used for the cast rank */
268 #define SWIG_CASTRANKLIMIT (1 << 8)
269 /* The NewMask denotes the object was created (using new/malloc) */
270 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
271 /* The TmpMask is for in/out typemaps that use temporal objects */
272 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
273 /* Simple returning values */
274 #define SWIG_BADOBJ (SWIG_ERROR)
275 #define SWIG_OLDOBJ (SWIG_OK)
276 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
277 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
278 /* Check, add and del mask methods */
279 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
280 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
281 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
282 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
283 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
284 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
285 
286 /* Cast-Rank Mode */
287 #if defined(SWIG_CASTRANK_MODE)
288 # ifndef SWIG_TypeRank
289 # define SWIG_TypeRank unsigned long
290 # endif
291 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
292 # define SWIG_MAXCASTRANK (2)
293 # endif
294 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
295 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
296 SWIGINTERNINLINE int SWIG_AddCast(int r) {
297  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
298 }
300  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
301 }
302 #else /* no cast-rank mode */
303 # define SWIG_AddCast(r) (r)
304 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
305 #endif
306 
307 
308 #include <string.h>
309 
310 #ifdef __cplusplus
311 extern "C" {
312 #endif
313 
314 typedef void *(*swig_converter_func)(void *, int *);
315 typedef struct swig_type_info *(*swig_dycast_func)(void **);
316 
317 /* Structure to store information on one type */
318 typedef struct swig_type_info {
319  const char *name; /* mangled name of this type */
320  const char *str; /* human readable name of this type */
321  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
322  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
323  void *clientdata; /* language specific type data */
324  int owndata; /* flag if the structure owns the clientdata */
326 
327 /* Structure to store a type and conversion function used for casting */
328 typedef struct swig_cast_info {
329  swig_type_info *type; /* pointer to type that is equivalent to this type */
330  swig_converter_func converter; /* function to cast the void pointers */
331  struct swig_cast_info *next; /* pointer to next cast in linked list */
332  struct swig_cast_info *prev; /* pointer to the previous cast */
334 
335 /* Structure used to store module information
336  * Each module generates one structure like this, and the runtime collects
337  * all of these structures and stores them in a circularly linked list.*/
338 typedef struct swig_module_info {
339  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
340  size_t size; /* Number of types in this module */
341  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
342  swig_type_info **type_initial; /* Array of initially generated type structures */
343  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
344  void *clientdata; /* Language specific module data */
346 
347 /*
348  Compare two type names skipping the space characters, therefore
349  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
350 
351  Return 0 when the two name types are equivalent, as in
352  strncmp, but skipping ' '.
353 */
354 SWIGRUNTIME int
355 SWIG_TypeNameComp(const char *f1, const char *l1,
356  const char *f2, const char *l2) {
357  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
358  while ((*f1 == ' ') && (f1 != l1)) ++f1;
359  while ((*f2 == ' ') && (f2 != l2)) ++f2;
360  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
361  }
362  return (int)((l1 - f1) - (l2 - f2));
363 }
364 
365 /*
366  Check type equivalence in a name list like <name1>|<name2>|...
367  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
368 */
369 SWIGRUNTIME int
370 SWIG_TypeCmp(const char *nb, const char *tb) {
371  int equiv = 1;
372  const char* te = tb + strlen(tb);
373  const char* ne = nb;
374  while (equiv != 0 && *ne) {
375  for (nb = ne; *ne; ++ne) {
376  if (*ne == '|') break;
377  }
378  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
379  if (*ne) ++ne;
380  }
381  return equiv;
382 }
383 
384 /*
385  Check type equivalence in a name list like <name1>|<name2>|...
386  Return 0 if not equal, 1 if equal
387 */
388 SWIGRUNTIME int
389 SWIG_TypeEquiv(const char *nb, const char *tb) {
390  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
391 }
392 
393 /*
394  Check the typename
395 */
397 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
398  if (ty) {
399  swig_cast_info *iter = ty->cast;
400  while (iter) {
401  if (strcmp(iter->type->name, c) == 0) {
402  if (iter == ty->cast)
403  return iter;
404  /* Move iter to the top of the linked list */
405  iter->prev->next = iter->next;
406  if (iter->next)
407  iter->next->prev = iter->prev;
408  iter->next = ty->cast;
409  iter->prev = 0;
410  if (ty->cast) ty->cast->prev = iter;
411  ty->cast = iter;
412  return iter;
413  }
414  iter = iter->next;
415  }
416  }
417  return 0;
418 }
419 
420 /*
421  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
422 */
425  if (ty) {
426  swig_cast_info *iter = ty->cast;
427  while (iter) {
428  if (iter->type == from) {
429  if (iter == ty->cast)
430  return iter;
431  /* Move iter to the top of the linked list */
432  iter->prev->next = iter->next;
433  if (iter->next)
434  iter->next->prev = iter->prev;
435  iter->next = ty->cast;
436  iter->prev = 0;
437  if (ty->cast) ty->cast->prev = iter;
438  ty->cast = iter;
439  return iter;
440  }
441  iter = iter->next;
442  }
443  }
444  return 0;
445 }
446 
447 /*
448  Cast a pointer up an inheritance hierarchy
449 */
450 SWIGRUNTIMEINLINE void *
451 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
452  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
453 }
454 
455 /*
456  Dynamic pointer casting. Down an inheritance hierarchy
457 */
460  swig_type_info *lastty = ty;
461  if (!ty || !ty->dcast) return ty;
462  while (ty && (ty->dcast)) {
463  ty = (*ty->dcast)(ptr);
464  if (ty) lastty = ty;
465  }
466  return lastty;
467 }
468 
469 /*
470  Return the name associated with this type
471 */
472 SWIGRUNTIMEINLINE const char *
474  return ty->name;
475 }
476 
477 /*
478  Return the pretty name associated with this type,
479  that is an unmangled type name in a form presentable to the user.
480 */
481 SWIGRUNTIME const char *
483  /* The "str" field contains the equivalent pretty names of the
484  type, separated by vertical-bar characters. We choose
485  to print the last name, as it is often (?) the most
486  specific. */
487  if (!type) return NULL;
488  if (type->str != NULL) {
489  const char *last_name = type->str;
490  const char *s;
491  for (s = type->str; *s; s++)
492  if (*s == '|') last_name = s+1;
493  return last_name;
494  }
495  else
496  return type->name;
497 }
498 
499 /*
500  Set the clientdata field for a type
501 */
502 SWIGRUNTIME void
504  swig_cast_info *cast = ti->cast;
505  /* if (ti->clientdata == clientdata) return; */
506  ti->clientdata = clientdata;
507 
508  while (cast) {
509  if (!cast->converter) {
510  swig_type_info *tc = cast->type;
511  if (!tc->clientdata) {
512  SWIG_TypeClientData(tc, clientdata);
513  }
514  }
515  cast = cast->next;
516  }
517 }
518 SWIGRUNTIME void
520  SWIG_TypeClientData(ti, clientdata);
521  ti->owndata = 1;
522 }
523 
524 /*
525  Search for a swig_type_info structure only by mangled name
526  Search is a O(log #types)
527 
528  We start searching at module start, and finish searching when start == end.
529  Note: if start == end at the beginning of the function, we go all the way around
530  the circular list.
531 */
534  swig_module_info *end,
535  const char *name) {
536  swig_module_info *iter = start;
537  do {
538  if (iter->size) {
539  register size_t l = 0;
540  register size_t r = iter->size - 1;
541  do {
542  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
543  register size_t i = (l + r) >> 1;
544  const char *iname = iter->types[i]->name;
545  if (iname) {
546  register int compare = strcmp(name, iname);
547  if (compare == 0) {
548  return iter->types[i];
549  } else if (compare < 0) {
550  if (i) {
551  r = i - 1;
552  } else {
553  break;
554  }
555  } else if (compare > 0) {
556  l = i + 1;
557  }
558  } else {
559  break; /* should never happen */
560  }
561  } while (l <= r);
562  }
563  iter = iter->next;
564  } while (iter != end);
565  return 0;
566 }
567 
568 /*
569  Search for a swig_type_info structure for either a mangled name or a human readable name.
570  It first searches the mangled names of the types, which is a O(log #types)
571  If a type is not found it then searches the human readable names, which is O(#types).
572 
573  We start searching at module start, and finish searching when start == end.
574  Note: if start == end at the beginning of the function, we go all the way around
575  the circular list.
576 */
579  swig_module_info *end,
580  const char *name) {
581  /* STEP 1: Search the name field using binary search */
582  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
583  if (ret) {
584  return ret;
585  } else {
586  /* STEP 2: If the type hasn't been found, do a complete search
587  of the str field (the human readable name) */
588  swig_module_info *iter = start;
589  do {
590  register size_t i = 0;
591  for (; i < iter->size; ++i) {
592  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
593  return iter->types[i];
594  }
595  iter = iter->next;
596  } while (iter != end);
597  }
598 
599  /* neither found a match */
600  return 0;
601 }
602 
603 /*
604  Pack binary data into a string
605 */
606 SWIGRUNTIME char *
607 SWIG_PackData(char *c, void *ptr, size_t sz) {
608  static const char hex[17] = "0123456789abcdef";
609  register const unsigned char *u = (unsigned char *) ptr;
610  register const unsigned char *eu = u + sz;
611  for (; u != eu; ++u) {
612  register unsigned char uu = *u;
613  *(c++) = hex[(uu & 0xf0) >> 4];
614  *(c++) = hex[uu & 0xf];
615  }
616  return c;
617 }
618 
619 /*
620  Unpack binary data from a string
621 */
622 SWIGRUNTIME const char *
623 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
624  register unsigned char *u = (unsigned char *) ptr;
625  register const unsigned char *eu = u + sz;
626  for (; u != eu; ++u) {
627  register char d = *(c++);
628  register unsigned char uu;
629  if ((d >= '0') && (d <= '9'))
630  uu = ((d - '0') << 4);
631  else if ((d >= 'a') && (d <= 'f'))
632  uu = ((d - ('a'-10)) << 4);
633  else
634  return (char *) 0;
635  d = *(c++);
636  if ((d >= '0') && (d <= '9'))
637  uu |= (d - '0');
638  else if ((d >= 'a') && (d <= 'f'))
639  uu |= (d - ('a'-10));
640  else
641  return (char *) 0;
642  *u = uu;
643  }
644  return c;
645 }
646 
647 /*
648  Pack 'void *' into a string buffer.
649 */
650 SWIGRUNTIME char *
651 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
652  char *r = buff;
653  if ((2*sizeof(void *) + 2) > bsz) return 0;
654  *(r++) = '_';
655  r = SWIG_PackData(r,&ptr,sizeof(void *));
656  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
657  strcpy(r,name);
658  return buff;
659 }
660 
661 SWIGRUNTIME const char *
662 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
663  if (*c != '_') {
664  if (strcmp(c,"NULL") == 0) {
665  *ptr = (void *) 0;
666  return name;
667  } else {
668  return 0;
669  }
670  }
671  return SWIG_UnpackData(++c,ptr,sizeof(void *));
672 }
673 
674 SWIGRUNTIME char *
675 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
676  char *r = buff;
677  size_t lname = (name ? strlen(name) : 0);
678  if ((2*sz + 2 + lname) > bsz) return 0;
679  *(r++) = '_';
680  r = SWIG_PackData(r,ptr,sz);
681  if (lname) {
682  strncpy(r,name,lname+1);
683  } else {
684  *r = 0;
685  }
686  return buff;
687 }
688 
689 SWIGRUNTIME const char *
690 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
691  if (*c != '_') {
692  if (strcmp(c,"NULL") == 0) {
693  memset(ptr,0,sz);
694  return name;
695  } else {
696  return 0;
697  }
698  }
699  return SWIG_UnpackData(++c,ptr,sz);
700 }
701 
702 #ifdef __cplusplus
703 }
704 #endif
705 
706 /* Errors in SWIG */
707 #define SWIG_UnknownError -1
708 #define SWIG_IOError -2
709 #define SWIG_RuntimeError -3
710 #define SWIG_IndexError -4
711 #define SWIG_TypeError -5
712 #define SWIG_DivisionByZero -6
713 #define SWIG_OverflowError -7
714 #define SWIG_SyntaxError -8
715 #define SWIG_ValueError -9
716 #define SWIG_SystemError -10
717 #define SWIG_AttributeError -11
718 #define SWIG_MemoryError -12
719 #define SWIG_NullReferenceError -13
720 
721 
722 
723 /* Compatibility macros for Python 3 */
724 #if PY_VERSION_HEX >= 0x03000000
725 
726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
727 #define PyInt_Check(x) PyLong_Check(x)
728 #define PyInt_AsLong(x) PyLong_AsLong(x)
729 #define PyInt_FromLong(x) PyLong_FromLong(x)
730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
731 #define PyString_Check(name) PyBytes_Check(name)
732 #define PyString_FromString(x) PyUnicode_FromString(x)
733 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
734 #define PyString_AsString(str) PyBytes_AsString(str)
735 #define PyString_Size(str) PyBytes_Size(str)
736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
740 
741 #endif
742 
743 #ifndef Py_TYPE
744 # define Py_TYPE(op) ((op)->ob_type)
745 #endif
746 
747 /* SWIG APIs for compatibility of both Python 2 & 3 */
748 
749 #if PY_VERSION_HEX >= 0x03000000
750 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
751 #else
752 # define SWIG_Python_str_FromFormat PyString_FromFormat
753 #endif
754 
755 
756 /* Warning: This function will allocate a new string in Python 3,
757  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
758  */
759 SWIGINTERN char*
761 {
762 #if PY_VERSION_HEX >= 0x03000000
763  char *cstr;
764  char *newstr;
765  Py_ssize_t len;
766  str = PyUnicode_AsUTF8String(str);
767  PyBytes_AsStringAndSize(str, &cstr, &len);
768  newstr = (char *) malloc(len+1);
769  memcpy(newstr, cstr, len+1);
770  Py_XDECREF(str);
771  return newstr;
772 #else
773  return PyString_AsString(str);
774 #endif
775 }
776 
777 #if PY_VERSION_HEX >= 0x03000000
778 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
779 #else
780 # define SWIG_Python_str_DelForPy3(x)
781 #endif
782 
783 
784 SWIGINTERN PyObject*
786 {
787 #if PY_VERSION_HEX >= 0x03000000
788  return PyUnicode_FromString(c);
789 #else
790  return PyString_FromString(c);
791 #endif
792 }
793 
794 /* Add PyOS_snprintf for old Pythons */
795 #if PY_VERSION_HEX < 0x02020000
796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
797 # define PyOS_snprintf _snprintf
798 # else
799 # define PyOS_snprintf snprintf
800 # endif
801 #endif
802 
803 /* A crude PyString_FromFormat implementation for old Pythons */
804 #if PY_VERSION_HEX < 0x02020000
805 
806 #ifndef SWIG_PYBUFFER_SIZE
807 # define SWIG_PYBUFFER_SIZE 1024
808 #endif
809 
810 static PyObject *
811 PyString_FromFormat(const char *fmt, ...) {
812  va_list ap;
813  char buf[SWIG_PYBUFFER_SIZE * 2];
814  int res;
815  va_start(ap, fmt);
816  res = vsnprintf(buf, sizeof(buf), fmt, ap);
817  va_end(ap);
818  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
819 }
820 #endif
821 
822 /* Add PyObject_Del for old Pythons */
823 #if PY_VERSION_HEX < 0x01060000
824 # define PyObject_Del(op) PyMem_DEL((op))
825 #endif
826 #ifndef PyObject_DEL
827 # define PyObject_DEL PyObject_Del
828 #endif
829 
830 /* A crude PyExc_StopIteration exception for old Pythons */
831 #if PY_VERSION_HEX < 0x02020000
832 # ifndef PyExc_StopIteration
833 # define PyExc_StopIteration PyExc_RuntimeError
834 # endif
835 # ifndef PyObject_GenericGetAttr
836 # define PyObject_GenericGetAttr 0
837 # endif
838 #endif
839 
840 /* Py_NotImplemented is defined in 2.1 and up. */
841 #if PY_VERSION_HEX < 0x02010000
842 # ifndef Py_NotImplemented
843 # define Py_NotImplemented PyExc_RuntimeError
844 # endif
845 #endif
846 
847 /* A crude PyString_AsStringAndSize implementation for old Pythons */
848 #if PY_VERSION_HEX < 0x02010000
849 # ifndef PyString_AsStringAndSize
850 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
851 # endif
852 #endif
853 
854 /* PySequence_Size for old Pythons */
855 #if PY_VERSION_HEX < 0x02000000
856 # ifndef PySequence_Size
857 # define PySequence_Size PySequence_Length
858 # endif
859 #endif
860 
861 /* PyBool_FromLong for old Pythons */
862 #if PY_VERSION_HEX < 0x02030000
863 static
864 PyObject *PyBool_FromLong(long ok)
865 {
866  PyObject *result = ok ? Py_True : Py_False;
867  Py_INCREF(result);
868  return result;
869 }
870 #endif
871 
872 /* Py_ssize_t for old Pythons */
873 /* This code is as recommended by: */
874 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
876 typedef int Py_ssize_t;
877 # define PY_SSIZE_T_MAX INT_MAX
878 # define PY_SSIZE_T_MIN INT_MIN
879 typedef inquiry lenfunc;
880 typedef intargfunc ssizeargfunc;
881 typedef intintargfunc ssizessizeargfunc;
882 typedef intobjargproc ssizeobjargproc;
883 typedef intintobjargproc ssizessizeobjargproc;
884 typedef getreadbufferproc readbufferproc;
885 typedef getwritebufferproc writebufferproc;
886 typedef getsegcountproc segcountproc;
887 typedef getcharbufferproc charbufferproc;
888 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
889 {
890  long result = 0;
891  PyObject *i = PyNumber_Int(x);
892  if (i) {
893  result = PyInt_AsLong(i);
894  Py_DECREF(i);
895  }
896  return result;
897 }
898 #endif
899 
900 #if PY_VERSION_HEX < 0x02050000
901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
902 #endif
903 
904 #if PY_VERSION_HEX < 0x02040000
905 #define Py_VISIT(op) \
906  do { \
907  if (op) { \
908  int vret = visit((op), arg); \
909  if (vret) \
910  return vret; \
911  } \
912  } while (0)
913 #endif
914 
915 #if PY_VERSION_HEX < 0x02030000
916 typedef struct {
917  PyTypeObject type;
918  PyNumberMethods as_number;
919  PyMappingMethods as_mapping;
920  PySequenceMethods as_sequence;
921  PyBufferProcs as_buffer;
922  PyObject *name, *slots;
924 #endif
925 
926 #if PY_VERSION_HEX < 0x02030000
927 typedef destructor freefunc;
928 #endif
929 
930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
931  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
932  (PY_MAJOR_VERSION > 3))
933 # define SWIGPY_USE_CAPSULE
934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
935 #endif
936 
937 #if PY_VERSION_HEX < 0x03020000
938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
940 #endif
941 
942 /* -----------------------------------------------------------------------------
943  * error manipulation
944  * ----------------------------------------------------------------------------- */
945 
946 SWIGRUNTIME PyObject*
948  PyObject* type = 0;
949  switch(code) {
950  case SWIG_MemoryError:
951  type = PyExc_MemoryError;
952  break;
953  case SWIG_IOError:
954  type = PyExc_IOError;
955  break;
956  case SWIG_RuntimeError:
957  type = PyExc_RuntimeError;
958  break;
959  case SWIG_IndexError:
960  type = PyExc_IndexError;
961  break;
962  case SWIG_TypeError:
963  type = PyExc_TypeError;
964  break;
965  case SWIG_DivisionByZero:
966  type = PyExc_ZeroDivisionError;
967  break;
968  case SWIG_OverflowError:
969  type = PyExc_OverflowError;
970  break;
971  case SWIG_SyntaxError:
972  type = PyExc_SyntaxError;
973  break;
974  case SWIG_ValueError:
975  type = PyExc_ValueError;
976  break;
977  case SWIG_SystemError:
978  type = PyExc_SystemError;
979  break;
980  case SWIG_AttributeError:
981  type = PyExc_AttributeError;
982  break;
983  default:
984  type = PyExc_RuntimeError;
985  }
986  return type;
987 }
988 
989 
990 SWIGRUNTIME void
991 SWIG_Python_AddErrorMsg(const char* mesg)
992 {
993  PyObject *type = 0;
994  PyObject *value = 0;
995  PyObject *traceback = 0;
996 
997  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
998  if (value) {
999  char *tmp;
1000  PyObject *old_str = PyObject_Str(value);
1001  PyErr_Clear();
1002  Py_XINCREF(type);
1003 
1004  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1006  Py_DECREF(old_str);
1007  Py_DECREF(value);
1008  } else {
1009  PyErr_SetString(PyExc_RuntimeError, mesg);
1010  }
1011 }
1012 
1013 #if defined(SWIG_PYTHON_NO_THREADS)
1014 # if defined(SWIG_PYTHON_THREADS)
1015 # undef SWIG_PYTHON_THREADS
1016 # endif
1017 #endif
1018 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1019 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1020 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1021 # define SWIG_PYTHON_USE_GIL
1022 # endif
1023 # endif
1024 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1025 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1026 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1027 # endif
1028 # ifdef __cplusplus /* C++ code */
1029  class SWIG_Python_Thread_Block {
1030  bool status;
1031  PyGILState_STATE state;
1032  public:
1033  void end() { if (status) { PyGILState_Release(state); status = false;} }
1034  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1035  ~SWIG_Python_Thread_Block() { end(); }
1036  };
1037  class SWIG_Python_Thread_Allow {
1038  bool status;
1039  PyThreadState *save;
1040  public:
1041  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1042  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1043  ~SWIG_Python_Thread_Allow() { end(); }
1044  };
1045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1046 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1048 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1049 # else /* C code */
1050 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1051 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1052 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1053 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1054 # endif
1055 # else /* Old thread way, not implemented, user must provide it */
1056 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1057 # define SWIG_PYTHON_INITIALIZE_THREADS
1058 # endif
1059 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1060 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1061 # endif
1062 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1063 # define SWIG_PYTHON_THREAD_END_BLOCK
1064 # endif
1065 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1066 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1067 # endif
1068 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1069 # define SWIG_PYTHON_THREAD_END_ALLOW
1070 # endif
1071 # endif
1072 #else /* No thread support */
1073 # define SWIG_PYTHON_INITIALIZE_THREADS
1074 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1075 # define SWIG_PYTHON_THREAD_END_BLOCK
1076 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1077 # define SWIG_PYTHON_THREAD_END_ALLOW
1078 #endif
1079 
1080 /* -----------------------------------------------------------------------------
1081  * Python API portion that goes into the runtime
1082  * ----------------------------------------------------------------------------- */
1083 
1084 #ifdef __cplusplus
1085 extern "C" {
1086 #endif
1087 
1088 /* -----------------------------------------------------------------------------
1089  * Constant declarations
1090  * ----------------------------------------------------------------------------- */
1091 
1092 /* Constant Types */
1093 #define SWIG_PY_POINTER 4
1094 #define SWIG_PY_BINARY 5
1095 
1096 /* Constant information structure */
1097 typedef struct swig_const_info {
1098  int type;
1099  char *name;
1100  long lvalue;
1101  double dvalue;
1102  void *pvalue;
1104 } swig_const_info;
1105 
1106 
1107 /* -----------------------------------------------------------------------------
1108  * Wrapper of PyInstanceMethod_New() used in Python 3
1109  * It is exported to the generated module, used for -fastproxy
1110  * ----------------------------------------------------------------------------- */
1111 #if PY_VERSION_HEX >= 0x03000000
1112 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1113 {
1114  return PyInstanceMethod_New(func);
1115 }
1116 #else
1117 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1118 {
1119  return NULL;
1120 }
1121 #endif
1122 
1123 #ifdef __cplusplus
1124 }
1125 #endif
1126 
1127 
1128 /* -----------------------------------------------------------------------------
1129  * pyrun.swg
1130  *
1131  * This file contains the runtime support for Python modules
1132  * and includes code for managing global variables and pointer
1133  * type checking.
1134  *
1135  * ----------------------------------------------------------------------------- */
1136 
1137 /* Common SWIG API */
1138 
1139 /* for raw pointers */
1140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1141 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1143 
1144 #ifdef SWIGPYTHON_BUILTIN
1145 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1146 #else
1147 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1148 #endif
1149 
1150 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1151 
1152 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1153 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1154 #define swig_owntype int
1155 
1156 /* for raw packed data */
1157 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1158 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1159 
1160 /* for class or struct pointers */
1161 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1162 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1163 
1164 /* for C or C++ function pointers */
1165 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1166 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1167 
1168 /* for C++ member pointers, ie, member methods */
1169 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1170 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1171 
1172 
1173 /* Runtime API */
1174 
1175 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1176 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1177 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1178 
1179 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1180 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1181 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1182 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1183 #define SWIG_fail goto fail
1184 
1185 
1186 /* Runtime API implementation */
1187 
1188 /* Error manipulation */
1189 
1190 SWIGINTERN void
1191 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1193  PyErr_SetObject(errtype, obj);
1194  Py_DECREF(obj);
1196 }
1197 
1198 SWIGINTERN void
1199 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1201  PyErr_SetString(errtype, msg);
1203 }
1204 
1205 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1206 
1207 /* Set a constant value */
1208 
1209 #if defined(SWIGPYTHON_BUILTIN)
1210 
1211 SWIGINTERN void
1212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1213  PyObject *s = PyString_InternFromString(key);
1214  PyList_Append(seq, s);
1215  Py_DECREF(s);
1216 }
1217 
1218 SWIGINTERN void
1219 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1220 #if PY_VERSION_HEX < 0x02030000
1221  PyDict_SetItemString(d, (char *)name, obj);
1222 #else
1223  PyDict_SetItemString(d, name, obj);
1224 #endif
1225  Py_DECREF(obj);
1226  if (public_interface)
1227  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1228 }
1229 
1230 #else
1231 
1232 SWIGINTERN void
1233 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1234 #if PY_VERSION_HEX < 0x02030000
1235  PyDict_SetItemString(d, (char *)name, obj);
1236 #else
1237  PyDict_SetItemString(d, name, obj);
1238 #endif
1239  Py_DECREF(obj);
1240 }
1241 
1242 #endif
1243 
1244 /* Append a value to the result obj */
1245 
1246 SWIGINTERN PyObject*
1247 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1249  if (!result) {
1250  result = obj;
1251  } else if (result == Py_None) {
1252  Py_DECREF(result);
1253  result = obj;
1254  } else {
1255  if (!PyList_Check(result)) {
1256  PyObject *o2 = result;
1257  result = PyList_New(1);
1258  PyList_SetItem(result, 0, o2);
1259  }
1260  PyList_Append(result,obj);
1261  Py_DECREF(obj);
1262  }
1263  return result;
1264 #else
1265  PyObject* o2;
1266  PyObject* o3;
1267  if (!result) {
1268  result = obj;
1269  } else if (result == Py_None) {
1270  Py_DECREF(result);
1271  result = obj;
1272  } else {
1273  if (!PyTuple_Check(result)) {
1274  o2 = result;
1275  result = PyTuple_New(1);
1276  PyTuple_SET_ITEM(result, 0, o2);
1277  }
1278  o3 = PyTuple_New(1);
1279  PyTuple_SET_ITEM(o3, 0, obj);
1280  o2 = result;
1281  result = PySequence_Concat(o2, o3);
1282  Py_DECREF(o2);
1283  Py_DECREF(o3);
1284  }
1285  return result;
1286 #endif
1287 }
1288 
1289 /* Unpack the argument tuple */
1290 
1291 SWIGINTERN int
1292 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1293 {
1294  if (!args) {
1295  if (!min && !max) {
1296  return 1;
1297  } else {
1298  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1299  name, (min == max ? "" : "at least "), (int)min);
1300  return 0;
1301  }
1302  }
1303  if (!PyTuple_Check(args)) {
1304  if (min <= 1 && max >= 1) {
1305  register int i;
1306  objs[0] = args;
1307  for (i = 1; i < max; ++i) {
1308  objs[i] = 0;
1309  }
1310  return 2;
1311  }
1312  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1313  return 0;
1314  } else {
1315  register Py_ssize_t l = PyTuple_GET_SIZE(args);
1316  if (l < min) {
1317  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1318  name, (min == max ? "" : "at least "), (int)min, (int)l);
1319  return 0;
1320  } else if (l > max) {
1321  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1322  name, (min == max ? "" : "at most "), (int)max, (int)l);
1323  return 0;
1324  } else {
1325  register int i;
1326  for (i = 0; i < l; ++i) {
1327  objs[i] = PyTuple_GET_ITEM(args, i);
1328  }
1329  for (; l < max; ++l) {
1330  objs[l] = 0;
1331  }
1332  return i + 1;
1333  }
1334  }
1335 }
1336 
1337 /* A functor is a function object with one single object argument */
1338 #if PY_VERSION_HEX >= 0x02020000
1339 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1340 #else
1341 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1342 #endif
1343 
1344 /*
1345  Helper for static pointer initialization for both C and C++ code, for example
1346  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1347 */
1348 #ifdef __cplusplus
1349 #define SWIG_STATIC_POINTER(var) var
1350 #else
1351 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1352 #endif
1353 
1354 /* -----------------------------------------------------------------------------
1355  * Pointer declarations
1356  * ----------------------------------------------------------------------------- */
1357 
1358 /* Flags for new pointer objects */
1359 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1360 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1361 
1362 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1363 
1364 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1365 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1366 
1367 #ifdef __cplusplus
1368 extern "C" {
1369 #endif
1370 
1371 /* How to access Py_None */
1372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1373 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1374 # ifndef SWIG_PYTHON_BUILD_NONE
1375 # define SWIG_PYTHON_BUILD_NONE
1376 # endif
1377 # endif
1378 #endif
1379 
1380 #ifdef SWIG_PYTHON_BUILD_NONE
1381 # ifdef Py_None
1382 # undef Py_None
1383 # define Py_None SWIG_Py_None()
1384 # endif
1385 SWIGRUNTIMEINLINE PyObject *
1386 _SWIG_Py_None(void)
1387 {
1388  PyObject *none = Py_BuildValue((char*)"");
1389  Py_DECREF(none);
1390  return none;
1391 }
1392 SWIGRUNTIME PyObject *
1393 SWIG_Py_None(void)
1394 {
1395  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1396  return none;
1397 }
1398 #endif
1399 
1400 /* The python void return value */
1401 
1402 SWIGRUNTIMEINLINE PyObject *
1404 {
1405  PyObject *none = Py_None;
1406  Py_INCREF(none);
1407  return none;
1408 }
1409 
1410 /* SwigPyClientData */
1411 
1412 typedef struct {
1413  PyObject *klass;
1414  PyObject *newraw;
1415  PyObject *newargs;
1416  PyObject *destroy;
1417  int delargs;
1419  PyTypeObject *pytype;
1421 
1422 SWIGRUNTIMEINLINE int
1424 {
1426  return data ? data->implicitconv : 0;
1427 }
1428 
1429 SWIGRUNTIMEINLINE PyObject *
1431  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1432  PyObject *klass = data ? data->klass : 0;
1433  return (klass ? klass : PyExc_RuntimeError);
1434 }
1435 
1436 
1438 SwigPyClientData_New(PyObject* obj)
1439 {
1440  if (!obj) {
1441  return 0;
1442  } else {
1443  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1444  /* the klass element */
1445  data->klass = obj;
1446  Py_INCREF(data->klass);
1447  /* the newraw method and newargs arguments used to create a new raw instance */
1448  if (PyClass_Check(obj)) {
1449  data->newraw = 0;
1450  data->newargs = obj;
1451  Py_INCREF(obj);
1452  } else {
1453 #if (PY_VERSION_HEX < 0x02020000)
1454  data->newraw = 0;
1455 #else
1456  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1457 #endif
1458  if (data->newraw) {
1459  Py_INCREF(data->newraw);
1460  data->newargs = PyTuple_New(1);
1461  PyTuple_SetItem(data->newargs, 0, obj);
1462  } else {
1463  data->newargs = obj;
1464  }
1465  Py_INCREF(data->newargs);
1466  }
1467  /* the destroy method, aka as the C++ delete method */
1468  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1469  if (PyErr_Occurred()) {
1470  PyErr_Clear();
1471  data->destroy = 0;
1472  }
1473  if (data->destroy) {
1474  int flags;
1475  Py_INCREF(data->destroy);
1476  flags = PyCFunction_GET_FLAGS(data->destroy);
1477 #ifdef METH_O
1478  data->delargs = !(flags & (METH_O));
1479 #else
1480  data->delargs = 0;
1481 #endif
1482  } else {
1483  data->delargs = 0;
1484  }
1485  data->implicitconv = 0;
1486  data->pytype = 0;
1487  return data;
1488  }
1489 }
1490 
1491 SWIGRUNTIME void
1493  Py_XDECREF(data->newraw);
1494  Py_XDECREF(data->newargs);
1495  Py_XDECREF(data->destroy);
1496 }
1497 
1498 /* =============== SwigPyObject =====================*/
1499 
1500 typedef struct {
1501  PyObject_HEAD
1502  void *ptr;
1504  int own;
1505  PyObject *next;
1506 #ifdef SWIGPYTHON_BUILTIN
1507  PyObject *dict;
1508 #endif
1509 } SwigPyObject;
1510 
1511 SWIGRUNTIME PyObject *
1513 {
1514  return PyLong_FromVoidPtr(v->ptr);
1515 }
1516 
1517 SWIGRUNTIME PyObject *
1518 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1519 {
1520  PyObject *res = NULL;
1521  PyObject *args = PyTuple_New(1);
1522  if (args) {
1523  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1524  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1525  if (ofmt) {
1526 #if PY_VERSION_HEX >= 0x03000000
1527  res = PyUnicode_Format(ofmt,args);
1528 #else
1529  res = PyString_Format(ofmt,args);
1530 #endif
1531  Py_DECREF(ofmt);
1532  }
1533  Py_DECREF(args);
1534  }
1535  }
1536  return res;
1537 }
1538 
1539 SWIGRUNTIME PyObject *
1541 {
1542  return SwigPyObject_format("%o",v);
1543 }
1544 
1545 SWIGRUNTIME PyObject *
1547 {
1548  return SwigPyObject_format("%x",v);
1549 }
1550 
1551 SWIGRUNTIME PyObject *
1552 #ifdef METH_NOARGS
1554 #else
1555 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1556 #endif
1557 {
1558  const char *name = SWIG_TypePrettyName(v->ty);
1559  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1560  if (v->next) {
1561 # ifdef METH_NOARGS
1562  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1563 # else
1564  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1565 # endif
1566 # if PY_VERSION_HEX >= 0x03000000
1567  PyObject *joined = PyUnicode_Concat(repr, nrep);
1568  Py_DecRef(repr);
1569  Py_DecRef(nrep);
1570  repr = joined;
1571 # else
1572  PyString_ConcatAndDel(&repr,nrep);
1573 # endif
1574  }
1575  return repr;
1576 }
1577 
1578 SWIGRUNTIME int
1580 {
1581  void *i = v->ptr;
1582  void *j = w->ptr;
1583  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1584 }
1585 
1586 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1587 SWIGRUNTIME PyObject*
1589 {
1590  PyObject* res;
1591  if( op != Py_EQ && op != Py_NE ) {
1592  Py_INCREF(Py_NotImplemented);
1593  return Py_NotImplemented;
1594  }
1595  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1596  return res;
1597 }
1598 
1599 
1600 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1601 
1602 #ifdef SWIGPYTHON_BUILTIN
1603 static swig_type_info *SwigPyObject_stype = 0;
1604 SWIGRUNTIME PyTypeObject*
1605 SwigPyObject_type(void) {
1606  SwigPyClientData *cd;
1607  assert(SwigPyObject_stype);
1608  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1609  assert(cd);
1610  assert(cd->pytype);
1611  return cd->pytype;
1612 }
1613 #else
1614 SWIGRUNTIME PyTypeObject*
1616  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1617  return type;
1618 }
1619 #endif
1620 
1622 SwigPyObject_Check(PyObject *op) {
1623 #ifdef SWIGPYTHON_BUILTIN
1624  PyTypeObject *target_tp = SwigPyObject_type();
1625  if (PyType_IsSubtype(op->ob_type, target_tp))
1626  return 1;
1627  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1628 #else
1629  return (Py_TYPE(op) == SwigPyObject_type())
1630  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1631 #endif
1632 }
1633 
1634 SWIGRUNTIME PyObject *
1635 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1636 
1637 SWIGRUNTIME void
1639 {
1640  SwigPyObject *sobj = (SwigPyObject *) v;
1641  PyObject *next = sobj->next;
1642  if (sobj->own == SWIG_POINTER_OWN) {
1643  swig_type_info *ty = sobj->ty;
1644  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1645  PyObject *destroy = data ? data->destroy : 0;
1646  if (destroy) {
1647  /* destroy is always a VARARGS method */
1648  PyObject *res;
1649  if (data->delargs) {
1650  /* we need to create a temporary object to carry the destroy operation */
1651  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1652  res = SWIG_Python_CallFunctor(destroy, tmp);
1653  Py_DECREF(tmp);
1654  } else {
1655  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1656  PyObject *mself = PyCFunction_GET_SELF(destroy);
1657  res = ((*meth)(mself, v));
1658  }
1659  Py_XDECREF(res);
1660  }
1661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1662  else {
1663  const char *name = SWIG_TypePrettyName(ty);
1664  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1665  }
1666 #endif
1667  }
1668  Py_XDECREF(next);
1669  PyObject_DEL(v);
1670 }
1671 
1672 SWIGRUNTIME PyObject*
1673 SwigPyObject_append(PyObject* v, PyObject* next)
1674 {
1675  SwigPyObject *sobj = (SwigPyObject *) v;
1676 #ifndef METH_O
1677  PyObject *tmp = 0;
1678  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1679  next = tmp;
1680 #endif
1681  if (!SwigPyObject_Check(next)) {
1682  return NULL;
1683  }
1684  sobj->next = next;
1685  Py_INCREF(next);
1686  return SWIG_Py_Void();
1687 }
1688 
1689 SWIGRUNTIME PyObject*
1690 #ifdef METH_NOARGS
1691 SwigPyObject_next(PyObject* v)
1692 #else
1693 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1694 #endif
1695 {
1696  SwigPyObject *sobj = (SwigPyObject *) v;
1697  if (sobj->next) {
1698  Py_INCREF(sobj->next);
1699  return sobj->next;
1700  } else {
1701  return SWIG_Py_Void();
1702  }
1703 }
1704 
1705 SWIGINTERN PyObject*
1706 #ifdef METH_NOARGS
1707 SwigPyObject_disown(PyObject *v)
1708 #else
1709 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1710 #endif
1711 {
1712  SwigPyObject *sobj = (SwigPyObject *)v;
1713  sobj->own = 0;
1714  return SWIG_Py_Void();
1715 }
1716 
1717 SWIGINTERN PyObject*
1718 #ifdef METH_NOARGS
1719 SwigPyObject_acquire(PyObject *v)
1720 #else
1721 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1722 #endif
1723 {
1724  SwigPyObject *sobj = (SwigPyObject *)v;
1725  sobj->own = SWIG_POINTER_OWN;
1726  return SWIG_Py_Void();
1727 }
1728 
1729 SWIGINTERN PyObject*
1730 SwigPyObject_own(PyObject *v, PyObject *args)
1731 {
1732  PyObject *val = 0;
1733 #if (PY_VERSION_HEX < 0x02020000)
1734  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1735 #elif (PY_VERSION_HEX < 0x02050000)
1736  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1737 #else
1738  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1739 #endif
1740  {
1741  return NULL;
1742  }
1743  else
1744  {
1745  SwigPyObject *sobj = (SwigPyObject *)v;
1746  PyObject *obj = PyBool_FromLong(sobj->own);
1747  if (val) {
1748 #ifdef METH_NOARGS
1749  if (PyObject_IsTrue(val)) {
1751  } else {
1753  }
1754 #else
1755  if (PyObject_IsTrue(val)) {
1756  SwigPyObject_acquire(v,args);
1757  } else {
1758  SwigPyObject_disown(v,args);
1759  }
1760 #endif
1761  }
1762  return obj;
1763  }
1764 }
1765 
1766 #ifdef METH_O
1767 static PyMethodDef
1768 swigobject_methods[] = {
1769  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1770  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1771  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1772  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1773  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1774  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1775  {0, 0, 0, 0}
1776 };
1777 #else
1778 static PyMethodDef
1779 swigobject_methods[] = {
1780  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1781  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1782  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1783  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1784  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1785  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1786  {0, 0, 0, 0}
1787 };
1788 #endif
1789 
1790 #if PY_VERSION_HEX < 0x02020000
1791 SWIGINTERN PyObject *
1793 {
1794  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1795 }
1796 #endif
1797 
1798 SWIGRUNTIME PyTypeObject*
1800  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1801 
1802  static PyNumberMethods SwigPyObject_as_number = {
1803  (binaryfunc)0, /*nb_add*/
1804  (binaryfunc)0, /*nb_subtract*/
1805  (binaryfunc)0, /*nb_multiply*/
1806  /* nb_divide removed in Python 3 */
1807 #if PY_VERSION_HEX < 0x03000000
1808  (binaryfunc)0, /*nb_divide*/
1809 #endif
1810  (binaryfunc)0, /*nb_remainder*/
1811  (binaryfunc)0, /*nb_divmod*/
1812  (ternaryfunc)0,/*nb_power*/
1813  (unaryfunc)0, /*nb_negative*/
1814  (unaryfunc)0, /*nb_positive*/
1815  (unaryfunc)0, /*nb_absolute*/
1816  (inquiry)0, /*nb_nonzero*/
1817  0, /*nb_invert*/
1818  0, /*nb_lshift*/
1819  0, /*nb_rshift*/
1820  0, /*nb_and*/
1821  0, /*nb_xor*/
1822  0, /*nb_or*/
1823 #if PY_VERSION_HEX < 0x03000000
1824  0, /*nb_coerce*/
1825 #endif
1826  (unaryfunc)SwigPyObject_long, /*nb_int*/
1827 #if PY_VERSION_HEX < 0x03000000
1828  (unaryfunc)SwigPyObject_long, /*nb_long*/
1829 #else
1830  0, /*nb_reserved*/
1831 #endif
1832  (unaryfunc)0, /*nb_float*/
1833 #if PY_VERSION_HEX < 0x03000000
1834  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1835  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1836 #endif
1837 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1838  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1839 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1840  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1841 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1842  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1843 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1844  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1845 #endif
1846  };
1847 
1848  static PyTypeObject swigpyobject_type;
1849  static int type_init = 0;
1850  if (!type_init) {
1851  const PyTypeObject tmp = {
1852  /* PyObject header changed in Python 3 */
1853 #if PY_VERSION_HEX >= 0x03000000
1854  PyVarObject_HEAD_INIT(NULL, 0)
1855 #else
1856  PyObject_HEAD_INIT(NULL)
1857  0, /* ob_size */
1858 #endif
1859  (char *)"SwigPyObject", /* tp_name */
1860  sizeof(SwigPyObject), /* tp_basicsize */
1861  0, /* tp_itemsize */
1862  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1863  0, /* tp_print */
1864 #if PY_VERSION_HEX < 0x02020000
1865  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1866 #else
1867  (getattrfunc)0, /* tp_getattr */
1868 #endif
1869  (setattrfunc)0, /* tp_setattr */
1870 #if PY_VERSION_HEX >= 0x03000000
1871  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1872 #else
1873  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1874 #endif
1875  (reprfunc)SwigPyObject_repr, /* tp_repr */
1876  &SwigPyObject_as_number, /* tp_as_number */
1877  0, /* tp_as_sequence */
1878  0, /* tp_as_mapping */
1879  (hashfunc)0, /* tp_hash */
1880  (ternaryfunc)0, /* tp_call */
1881  0, /* tp_str */
1882  PyObject_GenericGetAttr, /* tp_getattro */
1883  0, /* tp_setattro */
1884  0, /* tp_as_buffer */
1885  Py_TPFLAGS_DEFAULT, /* tp_flags */
1886  swigobject_doc, /* tp_doc */
1887  0, /* tp_traverse */
1888  0, /* tp_clear */
1889  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1890  0, /* tp_weaklistoffset */
1891 #if PY_VERSION_HEX >= 0x02020000
1892  0, /* tp_iter */
1893  0, /* tp_iternext */
1894  swigobject_methods, /* tp_methods */
1895  0, /* tp_members */
1896  0, /* tp_getset */
1897  0, /* tp_base */
1898  0, /* tp_dict */
1899  0, /* tp_descr_get */
1900  0, /* tp_descr_set */
1901  0, /* tp_dictoffset */
1902  0, /* tp_init */
1903  0, /* tp_alloc */
1904  0, /* tp_new */
1905  0, /* tp_free */
1906  0, /* tp_is_gc */
1907  0, /* tp_bases */
1908  0, /* tp_mro */
1909  0, /* tp_cache */
1910  0, /* tp_subclasses */
1911  0, /* tp_weaklist */
1912 #endif
1913 #if PY_VERSION_HEX >= 0x02030000
1914  0, /* tp_del */
1915 #endif
1916 #if PY_VERSION_HEX >= 0x02060000
1917  0, /* tp_version */
1918 #endif
1919 #ifdef COUNT_ALLOCS
1920  0,0,0,0 /* tp_alloc -> tp_next */
1921 #endif
1922  };
1923  swigpyobject_type = tmp;
1924  type_init = 1;
1925 #if PY_VERSION_HEX < 0x02020000
1926  swigpyobject_type.ob_type = &PyType_Type;
1927 #else
1928  if (PyType_Ready(&swigpyobject_type) < 0)
1929  return NULL;
1930 #endif
1931  }
1932  return &swigpyobject_type;
1933 }
1934 
1935 SWIGRUNTIME PyObject *
1936 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1937 {
1938  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1939  if (sobj) {
1940  sobj->ptr = ptr;
1941  sobj->ty = ty;
1942  sobj->own = own;
1943  sobj->next = 0;
1944  }
1945  return (PyObject *)sobj;
1946 }
1947 
1948 /* -----------------------------------------------------------------------------
1949  * Implements a simple Swig Packed type, and use it instead of string
1950  * ----------------------------------------------------------------------------- */
1951 
1952 typedef struct {
1953  PyObject_HEAD
1954  void *pack;
1956  size_t size;
1957 } SwigPyPacked;
1958 
1959 SWIGRUNTIME int
1961 {
1962  char result[SWIG_BUFFER_SIZE];
1963  fputs("<Swig Packed ", fp);
1964  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1965  fputs("at ", fp);
1966  fputs(result, fp);
1967  }
1968  fputs(v->ty->name,fp);
1969  fputs(">", fp);
1970  return 0;
1971 }
1972 
1973 SWIGRUNTIME PyObject *
1975 {
1976  char result[SWIG_BUFFER_SIZE];
1977  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1978  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1979  } else {
1980  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1981  }
1982 }
1983 
1984 SWIGRUNTIME PyObject *
1986 {
1987  char result[SWIG_BUFFER_SIZE];
1988  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1989  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1990  } else {
1991  return SWIG_Python_str_FromChar(v->ty->name);
1992  }
1993 }
1994 
1995 SWIGRUNTIME int
1997 {
1998  size_t i = v->size;
1999  size_t j = w->size;
2000  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2001  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2002 }
2003 
2004 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2005 
2006 SWIGRUNTIME PyTypeObject*
2008  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2009  return type;
2010 }
2011 
2013 SwigPyPacked_Check(PyObject *op) {
2014  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2015  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2016 }
2017 
2018 SWIGRUNTIME void
2020 {
2021  if (SwigPyPacked_Check(v)) {
2022  SwigPyPacked *sobj = (SwigPyPacked *) v;
2023  free(sobj->pack);
2024  }
2025  PyObject_DEL(v);
2026 }
2027 
2028 SWIGRUNTIME PyTypeObject*
2030  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2031  static PyTypeObject swigpypacked_type;
2032  static int type_init = 0;
2033  if (!type_init) {
2034  const PyTypeObject tmp = {
2035  /* PyObject header changed in Python 3 */
2036 #if PY_VERSION_HEX>=0x03000000
2037  PyVarObject_HEAD_INIT(NULL, 0)
2038 #else
2039  PyObject_HEAD_INIT(NULL)
2040  0, /* ob_size */
2041 #endif
2042  (char *)"SwigPyPacked", /* tp_name */
2043  sizeof(SwigPyPacked), /* tp_basicsize */
2044  0, /* tp_itemsize */
2045  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2046  (printfunc)SwigPyPacked_print, /* tp_print */
2047  (getattrfunc)0, /* tp_getattr */
2048  (setattrfunc)0, /* tp_setattr */
2049 #if PY_VERSION_HEX>=0x03000000
2050  0, /* tp_reserved in 3.0.1 */
2051 #else
2052  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2053 #endif
2054  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2055  0, /* tp_as_number */
2056  0, /* tp_as_sequence */
2057  0, /* tp_as_mapping */
2058  (hashfunc)0, /* tp_hash */
2059  (ternaryfunc)0, /* tp_call */
2060  (reprfunc)SwigPyPacked_str, /* tp_str */
2061  PyObject_GenericGetAttr, /* tp_getattro */
2062  0, /* tp_setattro */
2063  0, /* tp_as_buffer */
2064  Py_TPFLAGS_DEFAULT, /* tp_flags */
2065  swigpacked_doc, /* tp_doc */
2066  0, /* tp_traverse */
2067  0, /* tp_clear */
2068  0, /* tp_richcompare */
2069  0, /* tp_weaklistoffset */
2070 #if PY_VERSION_HEX >= 0x02020000
2071  0, /* tp_iter */
2072  0, /* tp_iternext */
2073  0, /* tp_methods */
2074  0, /* tp_members */
2075  0, /* tp_getset */
2076  0, /* tp_base */
2077  0, /* tp_dict */
2078  0, /* tp_descr_get */
2079  0, /* tp_descr_set */
2080  0, /* tp_dictoffset */
2081  0, /* tp_init */
2082  0, /* tp_alloc */
2083  0, /* tp_new */
2084  0, /* tp_free */
2085  0, /* tp_is_gc */
2086  0, /* tp_bases */
2087  0, /* tp_mro */
2088  0, /* tp_cache */
2089  0, /* tp_subclasses */
2090  0, /* tp_weaklist */
2091 #endif
2092 #if PY_VERSION_HEX >= 0x02030000
2093  0, /* tp_del */
2094 #endif
2095 #if PY_VERSION_HEX >= 0x02060000
2096  0, /* tp_version */
2097 #endif
2098 #ifdef COUNT_ALLOCS
2099  0,0,0,0 /* tp_alloc -> tp_next */
2100 #endif
2101  };
2102  swigpypacked_type = tmp;
2103  type_init = 1;
2104 #if PY_VERSION_HEX < 0x02020000
2105  swigpypacked_type.ob_type = &PyType_Type;
2106 #else
2107  if (PyType_Ready(&swigpypacked_type) < 0)
2108  return NULL;
2109 #endif
2110  }
2111  return &swigpypacked_type;
2112 }
2113 
2114 SWIGRUNTIME PyObject *
2115 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2116 {
2117  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2118  if (sobj) {
2119  void *pack = malloc(size);
2120  if (pack) {
2121  memcpy(pack, ptr, size);
2122  sobj->pack = pack;
2123  sobj->ty = ty;
2124  sobj->size = size;
2125  } else {
2126  PyObject_DEL((PyObject *) sobj);
2127  sobj = 0;
2128  }
2129  }
2130  return (PyObject *) sobj;
2131 }
2132 
2134 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2135 {
2136  if (SwigPyPacked_Check(obj)) {
2137  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2138  if (sobj->size != size) return 0;
2139  memcpy(ptr, sobj->pack, size);
2140  return sobj->ty;
2141  } else {
2142  return 0;
2143  }
2144 }
2145 
2146 /* -----------------------------------------------------------------------------
2147  * pointers/data manipulation
2148  * ----------------------------------------------------------------------------- */
2149 
2150 SWIGRUNTIMEINLINE PyObject *
2152 {
2153  return SWIG_Python_str_FromChar("this");
2154 }
2155 
2156 static PyObject *swig_this = NULL;
2157 
2158 SWIGRUNTIME PyObject *
2160 {
2161  if (swig_this == NULL)
2162  swig_this = _SWIG_This();
2163  return swig_this;
2164 }
2165 
2166 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2167 
2168 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2169 #if PY_VERSION_HEX>=0x03000000
2170 #define SWIG_PYTHON_SLOW_GETSET_THIS
2171 #endif
2172 
2174 SWIG_Python_GetSwigThis(PyObject *pyobj)
2175 {
2176  PyObject *obj;
2177 
2178  if (SwigPyObject_Check(pyobj))
2179  return (SwigPyObject *) pyobj;
2180 
2181 #ifdef SWIGPYTHON_BUILTIN
2182  (void)obj;
2183 # ifdef PyWeakref_CheckProxy
2184  if (PyWeakref_CheckProxy(pyobj)) {
2185  pyobj = PyWeakref_GET_OBJECT(pyobj);
2186  if (pyobj && SwigPyObject_Check(pyobj))
2187  return (SwigPyObject*) pyobj;
2188  }
2189 # endif
2190  return NULL;
2191 #else
2192 
2193  obj = 0;
2194 
2195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2196  if (PyInstance_Check(pyobj)) {
2197  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2198  } else {
2199  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2200  if (dictptr != NULL) {
2201  PyObject *dict = *dictptr;
2202  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2203  } else {
2204 #ifdef PyWeakref_CheckProxy
2205  if (PyWeakref_CheckProxy(pyobj)) {
2206  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2207  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2208  }
2209 #endif
2210  obj = PyObject_GetAttr(pyobj,SWIG_This());
2211  if (obj) {
2212  Py_DECREF(obj);
2213  } else {
2214  if (PyErr_Occurred()) PyErr_Clear();
2215  return 0;
2216  }
2217  }
2218  }
2219 #else
2220  obj = PyObject_GetAttr(pyobj,SWIG_This());
2221  if (obj) {
2222  Py_DECREF(obj);
2223  } else {
2224  if (PyErr_Occurred()) PyErr_Clear();
2225  return 0;
2226  }
2227 #endif
2228  if (obj && !SwigPyObject_Check(obj)) {
2229  /* a PyObject is called 'this', try to get the 'real this'
2230  SwigPyObject from it */
2231  return SWIG_Python_GetSwigThis(obj);
2232  }
2233  return (SwigPyObject *)obj;
2234 #endif
2235 }
2236 
2237 /* Acquire a pointer value */
2238 
2239 SWIGRUNTIME int
2240 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2241  if (own == SWIG_POINTER_OWN) {
2243  if (sobj) {
2244  int oldown = sobj->own;
2245  sobj->own = own;
2246  return oldown;
2247  }
2248  }
2249  return 0;
2250 }
2251 
2252 /* Convert a pointer value */
2253 
2254 SWIGRUNTIME int
2255 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2256  int res;
2257  SwigPyObject *sobj;
2258  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2259 
2260  if (!obj)
2261  return SWIG_ERROR;
2262  if (obj == Py_None && !implicit_conv) {
2263  if (ptr)
2264  *ptr = 0;
2265  return SWIG_OK;
2266  }
2267 
2268  res = SWIG_ERROR;
2269 
2270  sobj = SWIG_Python_GetSwigThis(obj);
2271  if (own)
2272  *own = 0;
2273  while (sobj) {
2274  void *vptr = sobj->ptr;
2275  if (ty) {
2276  swig_type_info *to = sobj->ty;
2277  if (to == ty) {
2278  /* no type cast needed */
2279  if (ptr) *ptr = vptr;
2280  break;
2281  } else {
2282  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2283  if (!tc) {
2284  sobj = (SwigPyObject *)sobj->next;
2285  } else {
2286  if (ptr) {
2287  int newmemory = 0;
2288  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2289  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2290  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2291  if (own)
2292  *own = *own | SWIG_CAST_NEW_MEMORY;
2293  }
2294  }
2295  break;
2296  }
2297  }
2298  } else {
2299  if (ptr) *ptr = vptr;
2300  break;
2301  }
2302  }
2303  if (sobj) {
2304  if (own)
2305  *own = *own | sobj->own;
2306  if (flags & SWIG_POINTER_DISOWN) {
2307  sobj->own = 0;
2308  }
2309  res = SWIG_OK;
2310  } else {
2311  if (implicit_conv) {
2312  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2313  if (data && !data->implicitconv) {
2314  PyObject *klass = data->klass;
2315  if (klass) {
2316  PyObject *impconv;
2317  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2318  impconv = SWIG_Python_CallFunctor(klass, obj);
2319  data->implicitconv = 0;
2320  if (PyErr_Occurred()) {
2321  PyErr_Clear();
2322  impconv = 0;
2323  }
2324  if (impconv) {
2325  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2326  if (iobj) {
2327  void *vptr;
2328  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2329  if (SWIG_IsOK(res)) {
2330  if (ptr) {
2331  *ptr = vptr;
2332  /* transfer the ownership to 'ptr' */
2333  iobj->own = 0;
2334  res = SWIG_AddCast(res);
2335  res = SWIG_AddNewMask(res);
2336  } else {
2337  res = SWIG_AddCast(res);
2338  }
2339  }
2340  }
2341  Py_DECREF(impconv);
2342  }
2343  }
2344  }
2345  }
2346  if (!SWIG_IsOK(res) && obj == Py_None) {
2347  if (ptr)
2348  *ptr = 0;
2349  if (PyErr_Occurred())
2350  PyErr_Clear();
2351  res = SWIG_OK;
2352  }
2353  }
2354  return res;
2355 }
2356 
2357 /* Convert a function ptr value */
2358 
2359 SWIGRUNTIME int
2360 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2361  if (!PyCFunction_Check(obj)) {
2362  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2363  } else {
2364  void *vptr = 0;
2365 
2366  /* here we get the method pointer for callbacks */
2367  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2368  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2369  if (desc)
2370  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2371  if (!desc)
2372  return SWIG_ERROR;
2373  if (ty) {
2374  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2375  if (tc) {
2376  int newmemory = 0;
2377  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2378  assert(!newmemory); /* newmemory handling not yet implemented */
2379  } else {
2380  return SWIG_ERROR;
2381  }
2382  } else {
2383  *ptr = vptr;
2384  }
2385  return SWIG_OK;
2386  }
2387 }
2388 
2389 /* Convert a packed value value */
2390 
2391 SWIGRUNTIME int
2392 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2393  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2394  if (!to) return SWIG_ERROR;
2395  if (ty) {
2396  if (to != ty) {
2397  /* check type cast? */
2398  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2399  if (!tc) return SWIG_ERROR;
2400  }
2401  }
2402  return SWIG_OK;
2403 }
2404 
2405 /* -----------------------------------------------------------------------------
2406  * Create a new pointer object
2407  * ----------------------------------------------------------------------------- */
2408 
2409 /*
2410  Create a new instance object, without calling __init__, and set the
2411  'this' attribute.
2412 */
2413 
2414 SWIGRUNTIME PyObject*
2416 {
2417 #if (PY_VERSION_HEX >= 0x02020000)
2418  PyObject *inst = 0;
2419  PyObject *newraw = data->newraw;
2420  if (newraw) {
2421  inst = PyObject_Call(newraw, data->newargs, NULL);
2422  if (inst) {
2423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2424  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2425  if (dictptr != NULL) {
2426  PyObject *dict = *dictptr;
2427  if (dict == NULL) {
2428  dict = PyDict_New();
2429  *dictptr = dict;
2430  PyDict_SetItem(dict, SWIG_This(), swig_this);
2431  }
2432  }
2433 #else
2434  PyObject *key = SWIG_This();
2435  PyObject_SetAttr(inst, key, swig_this);
2436 #endif
2437  }
2438  } else {
2439 #if PY_VERSION_HEX >= 0x03000000
2440  inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2441  if (inst) {
2442  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2443  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2444  }
2445 #else
2446  PyObject *dict = PyDict_New();
2447  if (dict) {
2448  PyDict_SetItem(dict, SWIG_This(), swig_this);
2449  inst = PyInstance_NewRaw(data->newargs, dict);
2450  Py_DECREF(dict);
2451  }
2452 #endif
2453  }
2454  return inst;
2455 #else
2456 #if (PY_VERSION_HEX >= 0x02010000)
2457  PyObject *inst = 0;
2458  PyObject *dict = PyDict_New();
2459  if (dict) {
2460  PyDict_SetItem(dict, SWIG_This(), swig_this);
2461  inst = PyInstance_NewRaw(data->newargs, dict);
2462  Py_DECREF(dict);
2463  }
2464  return (PyObject *) inst;
2465 #else
2466  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2467  if (inst == NULL) {
2468  return NULL;
2469  }
2470  inst->in_class = (PyClassObject *)data->newargs;
2471  Py_INCREF(inst->in_class);
2472  inst->in_dict = PyDict_New();
2473  if (inst->in_dict == NULL) {
2474  Py_DECREF(inst);
2475  return NULL;
2476  }
2477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2478  inst->in_weakreflist = NULL;
2479 #endif
2480 #ifdef Py_TPFLAGS_GC
2481  PyObject_GC_Init(inst);
2482 #endif
2483  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2484  return (PyObject *) inst;
2485 #endif
2486 #endif
2487 }
2488 
2489 SWIGRUNTIME void
2490 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2491 {
2492  PyObject *dict;
2493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495  if (dictptr != NULL) {
2496  dict = *dictptr;
2497  if (dict == NULL) {
2498  dict = PyDict_New();
2499  *dictptr = dict;
2500  }
2501  PyDict_SetItem(dict, SWIG_This(), swig_this);
2502  return;
2503  }
2504 #endif
2505  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2506  PyDict_SetItem(dict, SWIG_This(), swig_this);
2507  Py_DECREF(dict);
2508 }
2509 
2510 
2511 SWIGINTERN PyObject *
2513  PyObject *obj[2];
2514  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2515  return NULL;
2516  } else {
2517  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2518  if (sthis) {
2519  SwigPyObject_append((PyObject*) sthis, obj[1]);
2520  } else {
2521  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2522  }
2523  return SWIG_Py_Void();
2524  }
2525 }
2526 
2527 /* Create a new pointer object */
2528 
2529 SWIGRUNTIME PyObject *
2530 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2531  SwigPyClientData *clientdata;
2532  PyObject * robj;
2533  int own;
2534 
2535  if (!ptr)
2536  return SWIG_Py_Void();
2537 
2538  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2539  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2540  if (clientdata && clientdata->pytype) {
2541  SwigPyObject *newobj;
2542  if (flags & SWIG_BUILTIN_TP_INIT) {
2543  newobj = (SwigPyObject*) self;
2544  if (newobj->ptr) {
2545  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2546  while (newobj->next)
2547  newobj = (SwigPyObject *) newobj->next;
2548  newobj->next = next_self;
2549  newobj = (SwigPyObject *)next_self;
2550  }
2551  } else {
2552  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2553  }
2554  if (newobj) {
2555  newobj->ptr = ptr;
2556  newobj->ty = type;
2557  newobj->own = own;
2558  newobj->next = 0;
2559 #ifdef SWIGPYTHON_BUILTIN
2560  newobj->dict = 0;
2561 #endif
2562  return (PyObject*) newobj;
2563  }
2564  return SWIG_Py_Void();
2565  }
2566 
2567  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2568 
2569  robj = SwigPyObject_New(ptr, type, own);
2570  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2571  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2572  Py_DECREF(robj);
2573  robj = inst;
2574  }
2575  return robj;
2576 }
2577 
2578 /* Create a new packed object */
2579 
2580 SWIGRUNTIMEINLINE PyObject *
2581 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2582  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2583 }
2584 
2585 /* -----------------------------------------------------------------------------*
2586  * Get type list
2587  * -----------------------------------------------------------------------------*/
2588 
2589 #ifdef SWIG_LINK_RUNTIME
2590 void *SWIG_ReturnGlobalTypeList(void *);
2591 #endif
2592 
2595  static void *type_pointer = (void *)0;
2596  /* first check if module already created */
2597  if (!type_pointer) {
2598 #ifdef SWIG_LINK_RUNTIME
2599  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2600 #else
2601 # ifdef SWIGPY_USE_CAPSULE
2602  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2603 # else
2604  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2605  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2606 # endif
2607  if (PyErr_Occurred()) {
2608  PyErr_Clear();
2609  type_pointer = (void *)0;
2610  }
2611 #endif
2612  }
2613  return (swig_module_info *) type_pointer;
2614 }
2615 
2616 #if PY_MAJOR_VERSION < 2
2617 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2618  is copied out of Python/modsupport.c in python version 2.3.4 */
2619 SWIGINTERN int
2620 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2621 {
2622  PyObject *dict;
2623  if (!PyModule_Check(m)) {
2624  PyErr_SetString(PyExc_TypeError,
2625  "PyModule_AddObject() needs module as first arg");
2626  return SWIG_ERROR;
2627  }
2628  if (!o) {
2629  PyErr_SetString(PyExc_TypeError,
2630  "PyModule_AddObject() needs non-NULL value");
2631  return SWIG_ERROR;
2632  }
2633 
2634  dict = PyModule_GetDict(m);
2635  if (dict == NULL) {
2636  /* Internal error -- modules must have a dict! */
2637  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2638  PyModule_GetName(m));
2639  return SWIG_ERROR;
2640  }
2641  if (PyDict_SetItemString(dict, name, o))
2642  return SWIG_ERROR;
2643  Py_DECREF(o);
2644  return SWIG_OK;
2645 }
2646 #endif
2647 
2648 SWIGRUNTIME void
2649 #ifdef SWIGPY_USE_CAPSULE
2650 SWIG_Python_DestroyModule(PyObject *obj)
2651 #else
2653 #endif
2654 {
2655 #ifdef SWIGPY_USE_CAPSULE
2656  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2657 #else
2658  swig_module_info *swig_module = (swig_module_info *) vptr;
2659 #endif
2660  swig_type_info **types = swig_module->types;
2661  size_t i;
2662  for (i =0; i < swig_module->size; ++i) {
2663  swig_type_info *ty = types[i];
2664  if (ty->owndata) {
2666  if (data) SwigPyClientData_Del(data);
2667  }
2668  }
2669  Py_DECREF(SWIG_This());
2670  swig_this = NULL;
2671 }
2672 
2673 SWIGRUNTIME void
2675 #if PY_VERSION_HEX >= 0x03000000
2676  /* Add a dummy module object into sys.modules */
2677  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2678 #else
2679  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2680  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2681 #endif
2682 #ifdef SWIGPY_USE_CAPSULE
2683  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2684  if (pointer && module) {
2685  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2686  } else {
2687  Py_XDECREF(pointer);
2688  }
2689 #else
2690  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2691  if (pointer && module) {
2692  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2693  } else {
2694  Py_XDECREF(pointer);
2695  }
2696 #endif
2697 }
2698 
2699 /* The python cached type query */
2700 SWIGRUNTIME PyObject *
2702  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2703  return cache;
2704 }
2705 
2707 SWIG_Python_TypeQuery(const char *type)
2708 {
2709  PyObject *cache = SWIG_Python_TypeCache();
2710  PyObject *key = SWIG_Python_str_FromChar(type);
2711  PyObject *obj = PyDict_GetItem(cache, key);
2712  swig_type_info *descriptor;
2713  if (obj) {
2714 #ifdef SWIGPY_USE_CAPSULE
2715  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2716 #else
2717  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2718 #endif
2719  } else {
2721  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2722  if (descriptor) {
2723 #ifdef SWIGPY_USE_CAPSULE
2724  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2725 #else
2726  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2727 #endif
2728  PyDict_SetItem(cache, key, obj);
2729  Py_DECREF(obj);
2730  }
2731  }
2732  Py_DECREF(key);
2733  return descriptor;
2734 }
2735 
2736 /*
2737  For backward compatibility only
2738 */
2739 #define SWIG_POINTER_EXCEPTION 0
2740 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2741 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2742 
2743 SWIGRUNTIME int
2744 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2745 {
2746  if (PyErr_Occurred()) {
2747  PyObject *type = 0;
2748  PyObject *value = 0;
2749  PyObject *traceback = 0;
2750  PyErr_Fetch(&type, &value, &traceback);
2751  if (value) {
2752  char *tmp;
2753  PyObject *old_str = PyObject_Str(value);
2754  Py_XINCREF(type);
2755  PyErr_Clear();
2756  if (infront) {
2757  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2758  } else {
2759  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2760  }
2762  Py_DECREF(old_str);
2763  }
2764  return 1;
2765  } else {
2766  return 0;
2767  }
2768 }
2769 
2770 SWIGRUNTIME int
2772 {
2773  if (PyErr_Occurred()) {
2774  /* add information about failing argument */
2775  char mesg[256];
2776  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2777  return SWIG_Python_AddErrMesg(mesg, 1);
2778  } else {
2779  return 0;
2780  }
2781 }
2782 
2783 SWIGRUNTIMEINLINE const char *
2784 SwigPyObject_GetDesc(PyObject *self)
2785 {
2786  SwigPyObject *v = (SwigPyObject *)self;
2787  swig_type_info *ty = v ? v->ty : 0;
2788  return ty ? ty->str : "";
2789 }
2790 
2791 SWIGRUNTIME void
2792 SWIG_Python_TypeError(const char *type, PyObject *obj)
2793 {
2794  if (type) {
2795 #if defined(SWIG_COBJECT_TYPES)
2796  if (obj && SwigPyObject_Check(obj)) {
2797  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2798  if (otype) {
2799  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2800  type, otype);
2801  return;
2802  }
2803  } else
2804 #endif
2805  {
2806  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2807  if (otype) {
2808  PyObject *str = PyObject_Str(obj);
2809  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2810  if (cstr) {
2811  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2812  type, otype, cstr);
2814  } else {
2815  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2816  type, otype);
2817  }
2818  Py_XDECREF(str);
2819  return;
2820  }
2821  }
2822  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2823  } else {
2824  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2825  }
2826 }
2827 
2828 
2829 /* Convert a pointer value, signal an exception on a type mismatch */
2830 SWIGRUNTIME void *
2831 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2832  void *result;
2833  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2834  PyErr_Clear();
2835 #if SWIG_POINTER_EXCEPTION
2836  if (flags) {
2838  SWIG_Python_ArgFail(argnum);
2839  }
2840 #endif
2841  }
2842  return result;
2843 }
2844 
2845 #ifdef SWIGPYTHON_BUILTIN
2846 SWIGRUNTIME int
2847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2848  PyTypeObject *tp = obj->ob_type;
2849  PyObject *descr;
2850  PyObject *encoded_name;
2851  descrsetfunc f;
2852  int res = -1;
2853 
2854 # ifdef Py_USING_UNICODE
2855  if (PyString_Check(name)) {
2856  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2857  if (!name)
2858  return -1;
2859  } else if (!PyUnicode_Check(name))
2860 # else
2861  if (!PyString_Check(name))
2862 # endif
2863  {
2864  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2865  return -1;
2866  } else {
2867  Py_INCREF(name);
2868  }
2869 
2870  if (!tp->tp_dict) {
2871  if (PyType_Ready(tp) < 0)
2872  goto done;
2873  }
2874 
2875  descr = _PyType_Lookup(tp, name);
2876  f = NULL;
2877  if (descr != NULL)
2878  f = descr->ob_type->tp_descr_set;
2879  if (!f) {
2880  if (PyString_Check(name)) {
2881  encoded_name = name;
2882  Py_INCREF(name);
2883  } else {
2884  encoded_name = PyUnicode_AsUTF8String(name);
2885  }
2886  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2887  Py_DECREF(encoded_name);
2888  } else {
2889  res = f(descr, obj, value);
2890  }
2891 
2892  done:
2893  Py_DECREF(name);
2894  return res;
2895 }
2896 #endif
2897 
2898 
2899 #ifdef __cplusplus
2900 }
2901 #endif
2902 
2903 
2904 
2905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2906 
2907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2908 
2909 
2910 
2911 /* -------- TYPES TABLE (BEGIN) -------- */
2912 
2913 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2914 #define SWIGTYPE_p_PLcGrid swig_types[1]
2915 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2916 #define SWIGTYPE_p_char swig_types[3]
2917 #define SWIGTYPE_p_double swig_types[4]
2918 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2919 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2920 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2921 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2922 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2923 #define SWIGTYPE_p_int swig_types[10]
2924 #define SWIGTYPE_p_p_char swig_types[11]
2925 #define SWIGTYPE_p_p_double swig_types[12]
2926 #define SWIGTYPE_p_unsigned_int swig_types[13]
2928 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2929 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2930 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2931 
2932 /* -------- TYPES TABLE (END) -------- */
2933 
2934 #if (PY_VERSION_HEX <= 0x02000000)
2935 # if !defined(SWIG_PYTHON_CLASSIC)
2936 # error "This python version requires swig to be run with the '-classic' option"
2937 # endif
2938 #endif
2939 
2940 /*-----------------------------------------------
2941  @(target):= _plplotc.so
2942  ------------------------------------------------*/
2943 #if PY_VERSION_HEX >= 0x03000000
2944 # define SWIG_init PyInit__plplotc
2945 
2946 #else
2947 # define SWIG_init init_plplotc
2948 
2949 #endif
2950 #define SWIG_name "_plplotc"
2951 
2952 #define SWIGVERSION 0x020012
2953 #define SWIG_VERSION SWIGVERSION
2954 
2955 
2956 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2957 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2958 
2959 
2960 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2961 #include <arrayobject.h>
2962 #include "plplot.h"
2963 #include "plplotP.h"
2964 
2965 #define NPY_PLINT NPY_INT32
2966 
2967 #ifdef PL_DOUBLE
2968 #define NPY_PLFLT NPY_FLOAT64
2969 #else
2970 #define NPY_PLFLT NPY_FLOAT32
2971 #endif
2972 
2973 // python-1.5 compatibility mode?
2974 #if !defined ( PySequence_Fast_GET_ITEM )
2975  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2976 #endif
2977 #define PySequence_Size PySequence_Length
2978 
2979 
2980  static PLINT Alen = 0;
2981  static PLINT Xlen = 0, Ylen = 0;
2982 
2983 
2984 SWIGINTERN int
2985 SWIG_AsVal_double (PyObject *obj, double *val)
2986 {
2987  int res = SWIG_TypeError;
2988  if (PyFloat_Check(obj)) {
2989  if (val) *val = PyFloat_AsDouble(obj);
2990  return SWIG_OK;
2991  } else if (PyInt_Check(obj)) {
2992  if (val) *val = PyInt_AsLong(obj);
2993  return SWIG_OK;
2994  } else if (PyLong_Check(obj)) {
2995  double v = PyLong_AsDouble(obj);
2996  if (!PyErr_Occurred()) {
2997  if (val) *val = v;
2998  return SWIG_OK;
2999  } else {
3000  PyErr_Clear();
3001  }
3002  }
3003 #ifdef SWIG_PYTHON_CAST_MODE
3004  {
3005  int dispatch = 0;
3006  double d = PyFloat_AsDouble(obj);
3007  if (!PyErr_Occurred()) {
3008  if (val) *val = d;
3009  return SWIG_AddCast(SWIG_OK);
3010  } else {
3011  PyErr_Clear();
3012  }
3013  if (!dispatch) {
3014  long v = PyLong_AsLong(obj);
3015  if (!PyErr_Occurred()) {
3016  if (val) *val = v;
3018  } else {
3019  PyErr_Clear();
3020  }
3021  }
3022  }
3023 #endif
3024  return res;
3025 }
3026 
3027 
3028  #define SWIG_From_double PyFloat_FromDouble
3029 
3030 
3031  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3032  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3033  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3034  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3035  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3037  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3038 
3039 
3040 SWIGINTERNINLINE PyObject*
3041  SWIG_From_int (int value)
3042 {
3043  return PyInt_FromLong((long) value);
3044 }
3045 
3046 
3047 #include <limits.h>
3048 #if !defined(SWIG_NO_LLONG_MAX)
3049 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3050 # define LLONG_MAX __LONG_LONG_MAX__
3051 # define LLONG_MIN (-LLONG_MAX - 1LL)
3052 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3053 # endif
3054 #endif
3055 
3056 
3057 #include <float.h>
3058 
3059 
3060 #include <math.h>
3061 
3062 
3063 SWIGINTERNINLINE int
3064 SWIG_CanCastAsInteger(double *d, double min, double max) {
3065  double x = *d;
3066  if ((min <= x && x <= max)) {
3067  double fx = floor(x);
3068  double cx = ceil(x);
3069  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3070  if ((errno == EDOM) || (errno == ERANGE)) {
3071  errno = 0;
3072  } else {
3073  double summ, reps, diff;
3074  if (rd < x) {
3075  diff = x - rd;
3076  } else if (rd > x) {
3077  diff = rd - x;
3078  } else {
3079  return 1;
3080  }
3081  summ = rd + x;
3082  reps = diff/summ;
3083  if (reps < 8*DBL_EPSILON) {
3084  *d = rd;
3085  return 1;
3086  }
3087  }
3088  }
3089  return 0;
3090 }
3091 
3092 
3093 SWIGINTERN int
3094 SWIG_AsVal_long (PyObject *obj, long* val)
3095 {
3096  if (PyInt_Check(obj)) {
3097  if (val) *val = PyInt_AsLong(obj);
3098  return SWIG_OK;
3099  } else if (PyLong_Check(obj)) {
3100  long v = PyLong_AsLong(obj);
3101  if (!PyErr_Occurred()) {
3102  if (val) *val = v;
3103  return SWIG_OK;
3104  } else {
3105  PyErr_Clear();
3106  }
3107  }
3108 #ifdef SWIG_PYTHON_CAST_MODE
3109  {
3110  int dispatch = 0;
3111  long v = PyInt_AsLong(obj);
3112  if (!PyErr_Occurred()) {
3113  if (val) *val = v;
3114  return SWIG_AddCast(SWIG_OK);
3115  } else {
3116  PyErr_Clear();
3117  }
3118  if (!dispatch) {
3119  double d;
3120  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3121  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3122  if (val) *val = (long)(d);
3123  return res;
3124  }
3125  }
3126  }
3127 #endif
3128  return SWIG_TypeError;
3129 }
3130 
3131 
3132 SWIGINTERN int
3133 SWIG_AsVal_int (PyObject * obj, int *val)
3134 {
3135  long v;
3136  int res = SWIG_AsVal_long (obj, &v);
3137  if (SWIG_IsOK(res)) {
3138  if ((v < INT_MIN || v > INT_MAX)) {
3139  return SWIG_OverflowError;
3140  } else {
3141  if (val) *val = (int)(v);
3142  }
3143  }
3144  return res;
3145 }
3146 
3147 
3148 SWIGINTERN int
3149 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3150 {
3151 #if PY_VERSION_HEX < 0x03000000
3152  if (PyInt_Check(obj)) {
3153  long v = PyInt_AsLong(obj);
3154  if (v >= 0) {
3155  if (val) *val = v;
3156  return SWIG_OK;
3157  } else {
3158  return SWIG_OverflowError;
3159  }
3160  } else
3161 #endif
3162  if (PyLong_Check(obj)) {
3163  unsigned long v = PyLong_AsUnsignedLong(obj);
3164  if (!PyErr_Occurred()) {
3165  if (val) *val = v;
3166  return SWIG_OK;
3167  } else {
3168  PyErr_Clear();
3169 #if PY_VERSION_HEX >= 0x03000000
3170  {
3171  long v = PyLong_AsLong(obj);
3172  if (!PyErr_Occurred()) {
3173  if (v < 0) {
3174  return SWIG_OverflowError;
3175  }
3176  } else {
3177  PyErr_Clear();
3178  }
3179  }
3180 #endif
3181  }
3182  }
3183 #ifdef SWIG_PYTHON_CAST_MODE
3184  {
3185  int dispatch = 0;
3186  unsigned long v = PyLong_AsUnsignedLong(obj);
3187  if (!PyErr_Occurred()) {
3188  if (val) *val = v;
3189  return SWIG_AddCast(SWIG_OK);
3190  } else {
3191  PyErr_Clear();
3192  }
3193  if (!dispatch) {
3194  double d;
3195  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3196  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3197  if (val) *val = (unsigned long)(d);
3198  return res;
3199  }
3200  }
3201  }
3202 #endif
3203  return SWIG_TypeError;
3204 }
3205 
3206 
3207 SWIGINTERN int
3208 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3209 {
3210  unsigned long v;
3211  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3212  if (SWIG_IsOK(res)) {
3213  if ((v > UINT_MAX)) {
3214  return SWIG_OverflowError;
3215  } else {
3216  if (val) *val = (unsigned int)(v);
3217  }
3218  }
3219  return res;
3220 }
3221 
3222 
3223 SWIGINTERNINLINE PyObject*
3224  SWIG_From_unsigned_SS_int (unsigned int value)
3225 {
3226  return PyInt_FromSize_t((size_t) value);
3227 }
3228 
3229 
3232 {
3233  static int init = 0;
3234  static swig_type_info* info = 0;
3235  if (!init) {
3236  info = SWIG_TypeQuery("_p_char");
3237  init = 1;
3238  }
3239  return info;
3240 }
3241 
3242 
3243 SWIGINTERN int
3244 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3245 {
3246 #if PY_VERSION_HEX>=0x03000000
3247  if (PyUnicode_Check(obj))
3248 #else
3249  if (PyString_Check(obj))
3250 #endif
3251  {
3252  char *cstr; Py_ssize_t len;
3253 #if PY_VERSION_HEX>=0x03000000
3254  if (!alloc && cptr) {
3255  /* We can't allow converting without allocation, since the internal
3256  representation of string in Python 3 is UCS-2/UCS-4 but we require
3257  a UTF-8 representation.
3258  TODO(bhy) More detailed explanation */
3259  return SWIG_RuntimeError;
3260  }
3261  obj = PyUnicode_AsUTF8String(obj);
3262  PyBytes_AsStringAndSize(obj, &cstr, &len);
3263  if(alloc) *alloc = SWIG_NEWOBJ;
3264 #else
3265  PyString_AsStringAndSize(obj, &cstr, &len);
3266 #endif
3267  if (cptr) {
3268  if (alloc) {
3269  /*
3270  In python the user should not be able to modify the inner
3271  string representation. To warranty that, if you define
3272  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3273  buffer is always returned.
3274 
3275  The default behavior is just to return the pointer value,
3276  so, be careful.
3277  */
3278 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3279  if (*alloc != SWIG_OLDOBJ)
3280 #else
3281  if (*alloc == SWIG_NEWOBJ)
3282 #endif
3283  {
3284  *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3285  *alloc = SWIG_NEWOBJ;
3286  }
3287  else {
3288  *cptr = cstr;
3289  *alloc = SWIG_OLDOBJ;
3290  }
3291  } else {
3292  #if PY_VERSION_HEX>=0x03000000
3293  assert(0); /* Should never reach here in Python 3 */
3294  #endif
3295  *cptr = SWIG_Python_str_AsChar(obj);
3296  }
3297  }
3298  if (psize) *psize = len + 1;
3299 #if PY_VERSION_HEX>=0x03000000
3300  Py_XDECREF(obj);
3301 #endif
3302  return SWIG_OK;
3303  } else {
3304  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3305  if (pchar_descriptor) {
3306  void* vptr = 0;
3307  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3308  if (cptr) *cptr = (char *) vptr;
3309  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3310  if (alloc) *alloc = SWIG_OLDOBJ;
3311  return SWIG_OK;
3312  }
3313  }
3314  }
3315  return SWIG_TypeError;
3316 }
3317 
3318 
3319 SWIGINTERN int
3320 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3321 {
3322  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3323  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3324  if (SWIG_IsOK(res)) {
3325  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3326  if (csize <= size) {
3327  if (val) {
3328  if (csize) memcpy(val, cptr, csize*sizeof(char));
3329  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3330  }
3331  if (alloc == SWIG_NEWOBJ) {
3332  free((char*)cptr);
3333  res = SWIG_DelNewMask(res);
3334  }
3335  return res;
3336  }
3337  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3338  }
3339  return SWIG_TypeError;
3340 }
3341 
3342 
3343 SWIGINTERNINLINE PyObject *
3344 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3345 {
3346  if (carray) {
3347  if (size > INT_MAX) {
3348  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3349  return pchar_descriptor ?
3350  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3351  } else {
3352 #if PY_VERSION_HEX >= 0x03000000
3353  return PyUnicode_FromStringAndSize(carray, (int)(size));
3354 #else
3355  return PyString_FromStringAndSize(carray, (int)(size));
3356 #endif
3357  }
3358  } else {
3359  return SWIG_Py_Void();
3360  }
3361 }
3362 
3363 
3364 
3365 
3366 
3367 #define t_output_helper SWIG_Python_AppendOutput
3368 
3369 
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373  int res = SWIG_AsCharArray(obj, val, 1);
3374  if (!SWIG_IsOK(res)) {
3375  long v;
3376  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377  if (SWIG_IsOK(res)) {
3378  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379  if (val) *val = (char)(v);
3380  } else {
3381  res = SWIG_OverflowError;
3382  }
3383  }
3384  }
3385  return res;
3386 }
3387 
3388 #ifdef __cplusplus
3389 extern "C" {
3390 #endif
3391 
3392  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3393 
3394 // some really twisted stuff to allow calling a single precision library from python
3395  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3396  {
3397  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3398  mindims, maxdims );
3399  if ( !tmp )
3400  {
3401  // could be an incoming long array which can't be "safely" converted, do it anyway
3402  if ( PyArray_Check( in ) )
3403  {
3404  PyErr_Clear();
3405  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3406  }
3407  }
3408  return tmp;
3409  }
3410 
3411 
3412 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3413 
3414 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3415  PyObject *resultobj = 0;
3416  PLFLT arg1 ;
3417  PLFLT arg2 ;
3418  PLFLT *arg3 = (PLFLT *) 0 ;
3419  PLFLT *arg4 = (PLFLT *) 0 ;
3420  PLPointer arg5 = (PLPointer) 0 ;
3421  double val1 ;
3422  int ecode1 = 0 ;
3423  double val2 ;
3424  int ecode2 = 0 ;
3425  PLFLT temp3 ;
3426  int res3 = SWIG_TMPOBJ ;
3427  PLFLT temp4 ;
3428  int res4 = SWIG_TMPOBJ ;
3429  PyObject * obj0 = 0 ;
3430  PyObject * obj1 = 0 ;
3431 
3432  arg3 = &temp3;
3433  arg4 = &temp4;
3434  {
3435  arg5 = NULL;
3436  }
3437  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3438  ecode1 = SWIG_AsVal_double(obj0, &val1);
3439  if (!SWIG_IsOK(ecode1)) {
3440  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3441  }
3442  arg1 = (PLFLT)(val1);
3443  ecode2 = SWIG_AsVal_double(obj1, &val2);
3444  if (!SWIG_IsOK(ecode2)) {
3445  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3446  }
3447  arg2 = (PLFLT)(val2);
3448  pltr0(arg1,arg2,arg3,arg4,arg5);
3449  resultobj = SWIG_Py_Void();
3450  if (SWIG_IsTmpObj(res3)) {
3451  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3452  } else {
3453  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3454  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3455  }
3456  if (SWIG_IsTmpObj(res4)) {
3457  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3458  } else {
3459  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3460  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3461  }
3462  return resultobj;
3463 fail:
3464  return NULL;
3465 }
3466 
3467 
3468 
3469  PyArrayObject *pltr_xg, *pltr_yg;
3472 
3473  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3474  void cleanup_PLcGrid1( void );
3475  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3476  void cleanup_PLcGrid2( void );
3477 
3478  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3479  {
3480  // fprintf(stderr, "marshal PLcGrid1\n");
3481  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3482  {
3483  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3484  return NULL;
3485  }
3486  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3487  NPY_PLFLT, 1, 1 );
3488  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3489  NPY_PLFLT, 1, 1 );
3490  if ( pltr_xg == 0 || pltr_yg == 0 )
3491  {
3492  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3493  return NULL;
3494  }
3495  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3496  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3497  if ( isimg == 0 )
3498  {
3499  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3500  {
3501  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3502  return NULL;
3503  }
3504  }
3505  else
3506  {
3507  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3508  {
3509  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3510  return NULL;
3511  }
3512  }
3513  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3514  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3515  return &tmpGrid1;
3516  }
3517 
3518  void cleanup_PLcGrid1( void )
3519  {
3520  // fprintf(stderr, "cleanup PLcGrid1\n");
3521  Py_CLEAR( pltr_xg );
3522  Py_CLEAR( pltr_yg );
3523  }
3524 
3525  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3526  {
3527  int i, size;
3528  // fprintf(stderr, "marshal PLcGrid2\n");
3529  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3530  {
3531  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3532  return NULL;
3533  }
3534  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3535  NPY_PLFLT, 2, 2 );
3536  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3537  NPY_PLFLT, 2, 2 );
3538  if ( pltr_xg == 0 || pltr_yg == 0 )
3539  {
3540  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3541  return NULL;
3542  }
3543  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3544  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3545  {
3546  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3547  return NULL;
3548  }
3549  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3550  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3551  if ( isimg == 0 )
3552  {
3553  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3554  {
3555  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3556  return NULL;
3557  }
3558  }
3559  else
3560  {
3561  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3562  {
3563  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3564  return NULL;
3565  }
3566  }
3567  size = tmpGrid2.ny;
3568  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3569  for ( i = 0; i < tmpGrid2.nx; i++ )
3570  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3571  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3572  for ( i = 0; i < tmpGrid2.nx; i++ )
3573  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3574  return &tmpGrid2;
3575  }
3576 
3577  void cleanup_PLcGrid2( void )
3578  {
3579  // fprintf(stderr, "cleanup PLcGrid2\n");
3580  free( tmpGrid2.xg );
3581  free( tmpGrid2.yg );
3582  Py_CLEAR( pltr_xg );
3583  Py_CLEAR( pltr_yg );
3584  }
3585 
3586 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3587  PyObject *resultobj = 0;
3588  PLFLT arg1 ;
3589  PLFLT arg2 ;
3590  PLFLT *arg3 = (PLFLT *) 0 ;
3591  PLFLT *arg4 = (PLFLT *) 0 ;
3592  PLcGrid *arg5 = (PLcGrid *) 0 ;
3593  double val1 ;
3594  int ecode1 = 0 ;
3595  double val2 ;
3596  int ecode2 = 0 ;
3597  PLFLT temp3 ;
3598  int res3 = SWIG_TMPOBJ ;
3599  PLFLT temp4 ;
3600  int res4 = SWIG_TMPOBJ ;
3601  PyObject * obj0 = 0 ;
3602  PyObject * obj1 = 0 ;
3603  PyObject * obj2 = 0 ;
3604 
3605  arg3 = &temp3;
3606  arg4 = &temp4;
3607  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3608  ecode1 = SWIG_AsVal_double(obj0, &val1);
3609  if (!SWIG_IsOK(ecode1)) {
3610  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3611  }
3612  arg1 = (PLFLT)(val1);
3613  ecode2 = SWIG_AsVal_double(obj1, &val2);
3614  if (!SWIG_IsOK(ecode2)) {
3615  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3616  }
3617  arg2 = (PLFLT)(val2);
3618  {
3619  arg5 = marshal_PLcGrid1( obj2, 0 );
3620  if ( !arg5 )
3621  return NULL;
3622  }
3623  pltr1(arg1,arg2,arg3,arg4,arg5);
3624  resultobj = SWIG_Py_Void();
3625  if (SWIG_IsTmpObj(res3)) {
3626  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3627  } else {
3628  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3629  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3630  }
3631  if (SWIG_IsTmpObj(res4)) {
3632  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3633  } else {
3634  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3635  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3636  }
3637  {
3638  cleanup_PLcGrid1();
3639  }
3640  return resultobj;
3641 fail:
3642  {
3643  cleanup_PLcGrid1();
3644  }
3645  return NULL;
3646 }
3647 
3648 
3649 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3650  PyObject *resultobj = 0;
3651  PLFLT arg1 ;
3652  PLFLT arg2 ;
3653  PLFLT *arg3 = (PLFLT *) 0 ;
3654  PLFLT *arg4 = (PLFLT *) 0 ;
3655  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3656  double val1 ;
3657  int ecode1 = 0 ;
3658  double val2 ;
3659  int ecode2 = 0 ;
3660  PLFLT temp3 ;
3661  int res3 = SWIG_TMPOBJ ;
3662  PLFLT temp4 ;
3663  int res4 = SWIG_TMPOBJ ;
3664  PyObject * obj0 = 0 ;
3665  PyObject * obj1 = 0 ;
3666  PyObject * obj2 = 0 ;
3667 
3668  arg3 = &temp3;
3669  arg4 = &temp4;
3670  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3671  ecode1 = SWIG_AsVal_double(obj0, &val1);
3672  if (!SWIG_IsOK(ecode1)) {
3673  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3674  }
3675  arg1 = (PLFLT)(val1);
3676  ecode2 = SWIG_AsVal_double(obj1, &val2);
3677  if (!SWIG_IsOK(ecode2)) {
3678  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3679  }
3680  arg2 = (PLFLT)(val2);
3681  {
3682  arg5 = marshal_PLcGrid2( obj2, 0 );
3683  if ( !arg5 )
3684  return NULL;
3685  }
3686  pltr2(arg1,arg2,arg3,arg4,arg5);
3687  resultobj = SWIG_Py_Void();
3688  if (SWIG_IsTmpObj(res3)) {
3689  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3690  } else {
3691  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3692  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3693  }
3694  if (SWIG_IsTmpObj(res4)) {
3695  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3696  } else {
3697  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3698  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3699  }
3700  {
3701  cleanup_PLcGrid2();
3702  }
3703  return resultobj;
3704 fail:
3705  {
3706  cleanup_PLcGrid2();
3707  }
3708  return NULL;
3709 }
3710 
3711 
3712 
3713  // helper code for handling the callback
3714 #if 0
3715  static PyInterpreterState *save_interp = NULL;
3716 #endif
3718  PyObject* python_pltr = NULL;
3719  PyObject* python_f2eval = NULL;
3720  PyObject* python_ct = NULL;
3721  PyObject* python_mapform = NULL;
3722  PyObject* python_label = NULL;
3723 
3724 #if 0
3725 #define MY_BLOCK_THREADS { \
3726  PyThreadState *prev_state, *new_state; \
3727  /* need to have started a thread at some stage */ \
3728  /* for the following to work */ \
3729  PyEval_AcquireLock(); \
3730  new_state = PyThreadState_New( save_interp ); \
3731  prev_state = PyThreadState_Swap( new_state );
3732 #define MY_UNBLOCK_THREADS \
3733  new_state = PyThreadState_Swap( prev_state ); \
3734  PyThreadState_Clear( new_state ); \
3735  PyEval_ReleaseLock(); \
3736  PyThreadState_Delete( new_state ); \
3737  }
3738 #else
3739 #define MY_BLOCK_THREADS
3740 #define MY_UNBLOCK_THREADS
3741 #endif
3742 
3743 // Function prototypes
3744  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3745  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data );
3746  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3747  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3748  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3749  pltr_func marshal_pltr( PyObject* input );
3750  void cleanup_pltr( void );
3751  ct_func marshal_ct( PyObject* input );
3752  void cleanup_ct( void );
3753  mapform_func marshal_mapform( PyObject* input );
3754  void cleanup_mapform( void );
3755  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3756  void cleanup_PLPointer( void );
3757 
3758 
3759 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3760 
3761  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3762  {
3763  PyObject *pdata, *arglist, *result;
3764  PyArrayObject *tmp;
3765 
3766  // the data argument is acutally a pointer to a python object
3767  pdata = (PyObject *) data;
3768  if ( data == NULL )
3769  {
3770  pdata = Py_None;
3771  }
3772  if ( python_pltr ) // if not something is terribly wrong
3773  { // hold a reference to the data object
3774  Py_XINCREF( pdata );
3775  // grab the Global Interpreter Lock to be sure threads don't mess us up
3777  // build the argument list
3778 #ifdef PL_DOUBLE
3779  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3780 #else
3781  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3782 #endif
3783  if ( arglist == NULL )
3784  {
3785  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3786  *tx = *ty = 0;
3787  return;
3788  }
3789  // call the python function
3790  result = PyEval_CallObject( python_pltr, arglist );
3791  // release the argument list
3792  Py_CLEAR( arglist );
3793  // check and unpack the result
3794  if ( result == NULL )
3795  {
3796  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3797  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
3798  *tx = *ty = 0;
3799  }
3800  else
3801  {
3802  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3803  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3804  {
3805  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3806  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3807  *tx = *ty = 0;
3808  }
3809  else
3810  {
3811  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3812  *tx = t[0];
3813  *ty = t[1];
3814  Py_CLEAR( tmp );
3815  }
3816  }
3817  // release the result
3818  Py_CLEAR( result );
3819  // release the global interpreter lock
3821  }
3822  }
3823 
3824  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3825  {
3826  PyObject *pdata, *arglist, *result;
3827  PLFLT fresult = 0.0;
3828 
3829  // the data argument is acutally a pointer to a python object
3830  pdata = (PyObject *) data;
3831  if ( python_f2eval ) // if not something is terribly wrong
3832  { // hold a reference to the data object
3833  Py_XINCREF( pdata );
3834  // grab the Global Interpreter Lock to be sure threads don't mess us up
3836  // build the argument list
3837  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3838  // call the python function
3839  result = PyEval_CallObject( python_f2eval, arglist );
3840  // release the argument list
3841  Py_CLEAR( arglist );
3842  // check and unpack the result
3843  if ( !PyFloat_Check( result ) )
3844  {
3845  fprintf( stderr, "f2eval callback must return a float\n" );
3846  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3847  }
3848  else
3849  {
3850  // should I test the type here?
3851  fresult = (PLFLT) PyFloat_AsDouble( result );
3852  }
3853  // release the result
3854  Py_CLEAR( result );
3855  // release the global interpreter lock
3857  }
3858  return fresult;
3859  }
3860 
3861  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3862  {
3863  PyObject *pdata, *arglist, *result;
3864  char *pystring;
3865 
3866  // the data argument is acutally a pointer to a python object
3867  if ( data )
3868  pdata = (PyObject *) data;
3869  else
3870  pdata = Py_None;
3871  if ( python_label ) // if not something is terribly wrong
3872  { // hold a reference to the data object
3873  Py_XINCREF( pdata );
3874  // grab the Global Interpreter Lock to be sure threads don't mess us up
3876  // build the argument list
3877 #ifdef PL_DOUBLE
3878  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3879 #else
3880  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3881 #endif
3882  // call the python function
3883  result = PyEval_CallObject( python_label, arglist );
3884  // release the argument list
3885  //Py_CLEAR(arglist);
3886  // check and unpack the result
3887  if ( result == NULL )
3888  {
3889  fprintf( stderr, "label callback failed with 3 arguments\n" );
3890  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3891  }
3892  else if ( !PyString_Check( result ) )
3893  {
3894  fprintf( stderr, "label callback must return a string\n" );
3895  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3896  }
3897  else
3898  {
3899  // should I test the type here?
3900  pystring = PyString_AsString( result );
3901  strncpy( string, pystring, len );
3902  }
3903  // release the result
3904  Py_CLEAR( result );
3905  // release the global interpreter lock
3907  }
3908  }
3909 
3910  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3911  {
3912  PyObject *px, *py, *pdata, *arglist, *result;
3913  npy_intp n;
3914  n = 1;
3915 
3916  // the data argument is acutally a pointer to a python object
3917  pdata = (PyObject *) data;
3918  if ( data == NULL )
3919  {
3920  pdata = Py_None;
3921  }
3922  if ( python_ct ) // if not something is terribly wrong
3923  { // hold a reference to the data object
3924  Py_XINCREF( pdata );
3925  // grab the Global Interpreter Lock to be sure threads don't mess us up
3927  // build the argument list
3928  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3929  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3930  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3931  // call the python function
3932  result = PyEval_CallObject( python_ct, arglist );
3933  // release the argument list
3934  Py_CLEAR( arglist );
3935  Py_CLEAR( px );
3936  Py_CLEAR( py );
3937  Py_CLEAR( pdata );
3938  // check and unpack the result
3939  if ( result == NULL )
3940  {
3941  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3942  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3943  }
3944  // release the result
3945  Py_CLEAR( result );
3946  // release the global interpreter lock
3948  }
3949  }
3950 
3951  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
3952  {
3953  PyObject *px, *py, *arglist, *result;
3954  // PyArrayObject *tmpx, *tmpy;
3955 // PLFLT *xx, *yy;
3956 // PLINT i;
3957  npy_intp nn;
3958  nn = n;
3959 
3960  if ( python_mapform ) // if not something is terribly wrong
3961  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3963  // build the argument list
3964 #ifdef PL_HAVE_PTHREAD
3965  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3966  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3967 #else
3968  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3969  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3970 #endif
3971  arglist = Py_BuildValue( "(iOO)", n, px, py );
3972  // call the python function
3973  result = PyEval_CallObject( python_mapform, arglist );
3974  // release the argument list
3975  Py_CLEAR( arglist );
3976  Py_CLEAR( px );
3977  Py_CLEAR( py );
3978  // check and unpack the result
3979  if ( result == NULL )
3980  {
3981  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3982  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3983  }
3984  // release the result
3985  Py_CLEAR( result );
3986  // release the global interpreter lock
3988  }
3989  }
3990 
3991 // marshal the pltr function pointer argument
3992  pltr_func marshal_pltr( PyObject* input )
3993  {
3994  pltr_func result = do_pltr_callback;
3995  PyObject * rep = PyObject_Repr( input );
3996  if ( rep )
3997  {
3998  char* str = PyString_AsString( rep );
3999  if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
4000  {
4001  result = pltr0;
4002  pltr_type = CB_0;
4003  python_pltr = NULL;
4004  }
4005  else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
4006  {
4007  result = pltr1;
4008  pltr_type = CB_1;
4009  python_pltr = NULL;
4010  }
4011  else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
4012  {
4013  result = pltr2;
4014  pltr_type = CB_2;
4015  python_pltr = NULL;
4016  }
4017  else
4018  {
4019  python_pltr = input;
4020  pltr_type = CB_Python;
4021  Py_XINCREF( input );
4022  }
4023  Py_CLEAR( rep );
4024  }
4025  else
4026  {
4027  python_pltr = input;
4028  pltr_type = CB_Python;
4029  Py_XINCREF( input );
4030  }
4031  return result;
4032  }
4033 
4034  void cleanup_pltr( void )
4035  {
4036  Py_CLEAR( python_pltr );
4037  python_pltr = 0;
4038  }
4039 
4040 // marshal the ct function pointer argument
4041  ct_func marshal_ct( PyObject* input )
4042  {
4043  ct_func result = do_ct_callback;
4044  python_ct = input;
4045  Py_XINCREF( input );
4046  return result;
4047  }
4048 
4049  void cleanup_ct( void )
4050  {
4051  Py_CLEAR( python_ct );
4052  python_ct = 0;
4053  }
4054 
4055 // marshal the mapform function pointer argument
4056  mapform_func marshal_mapform( PyObject* input )
4057  {
4059  python_mapform = input;
4060  Py_XINCREF( input );
4061  return result;
4062  }
4063 
4064  void cleanup_mapform( void )
4065  {
4066  Py_CLEAR( python_mapform );
4067  python_mapform = 0;
4068  }
4069 
4070  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4071  {
4072  PLPointer result = NULL;
4073  switch ( pltr_type )
4074  {
4075  case CB_0:
4076  break;
4077  case CB_1:
4078  if ( input != Py_None )
4079  result = marshal_PLcGrid1( input, isimg );
4080  break;
4081  case CB_2:
4082  if ( input != Py_None )
4083  result = marshal_PLcGrid2( input, isimg );
4084  break;
4085  case CB_Python:
4086  Py_XINCREF( input );
4087  result = (PLPointer *) input;
4088  break;
4089  default:
4090  fprintf( stderr, "pltr_type is invalid\n" );
4091  }
4092  return result;
4093  }
4094 
4095  void cleanup_PLPointer( void )
4096  {
4097  switch ( pltr_type )
4098  {
4099  case CB_0:
4100  break;
4101  case CB_1:
4102  cleanup_PLcGrid1();
4103  break;
4104  case CB_2:
4105  cleanup_PLcGrid2();
4106  break;
4107  case CB_Python:
4108  Py_CLEAR( python_pltr );
4109  break;
4110  default:
4111  fprintf( stderr, "pltr_type is invalid\n" );
4112  }
4113  python_pltr = 0;
4114  pltr_type = CB_0;
4115  }
4116 
4117 
4118 
4119 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4120  PyObject *resultobj = 0;
4121  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4122  int arg2 ;
4123  void *argp1 = 0 ;
4124  int res1 = 0 ;
4125  int val2 ;
4126  int ecode2 = 0 ;
4127  PyObject * obj0 = 0 ;
4128  PyObject * obj1 = 0 ;
4129 
4130  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4131  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4132  if (!SWIG_IsOK(res1)) {
4133  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4134  }
4135  arg1 = (PLGraphicsIn *)(argp1);
4136  ecode2 = SWIG_AsVal_int(obj1, &val2);
4137  if (!SWIG_IsOK(ecode2)) {
4138  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4139  }
4140  arg2 = (int)(val2);
4141  if (arg1) (arg1)->type = arg2;
4142  resultobj = SWIG_Py_Void();
4143  return resultobj;
4144 fail:
4145  return NULL;
4146 }
4147 
4148 
4149 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4150  PyObject *resultobj = 0;
4151  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4152  void *argp1 = 0 ;
4153  int res1 = 0 ;
4154  PyObject * obj0 = 0 ;
4155  int result;
4156 
4157  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4158  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4159  if (!SWIG_IsOK(res1)) {
4160  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4161  }
4162  arg1 = (PLGraphicsIn *)(argp1);
4163  result = (int) ((arg1)->type);
4164  resultobj = SWIG_From_int((int)(result));
4165  return resultobj;
4166 fail:
4167  return NULL;
4168 }
4169 
4170 
4171 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4172  PyObject *resultobj = 0;
4173  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4174  unsigned int arg2 ;
4175  void *argp1 = 0 ;
4176  int res1 = 0 ;
4177  unsigned int val2 ;
4178  int ecode2 = 0 ;
4179  PyObject * obj0 = 0 ;
4180  PyObject * obj1 = 0 ;
4181 
4182  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4183  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4184  if (!SWIG_IsOK(res1)) {
4185  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4186  }
4187  arg1 = (PLGraphicsIn *)(argp1);
4188  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4189  if (!SWIG_IsOK(ecode2)) {
4190  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4191  }
4192  arg2 = (unsigned int)(val2);
4193  if (arg1) (arg1)->state = arg2;
4194  resultobj = SWIG_Py_Void();
4195  return resultobj;
4196 fail:
4197  return NULL;
4198 }
4199 
4200 
4201 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4202  PyObject *resultobj = 0;
4203  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4204  void *argp1 = 0 ;
4205  int res1 = 0 ;
4206  PyObject * obj0 = 0 ;
4207  unsigned int result;
4208 
4209  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4210  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4211  if (!SWIG_IsOK(res1)) {
4212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4213  }
4214  arg1 = (PLGraphicsIn *)(argp1);
4215  result = (unsigned int) ((arg1)->state);
4216  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4217  return resultobj;
4218 fail:
4219  return NULL;
4220 }
4221 
4222 
4223 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4224  PyObject *resultobj = 0;
4225  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4226  unsigned int arg2 ;
4227  void *argp1 = 0 ;
4228  int res1 = 0 ;
4229  unsigned int val2 ;
4230  int ecode2 = 0 ;
4231  PyObject * obj0 = 0 ;
4232  PyObject * obj1 = 0 ;
4233 
4234  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4235  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4236  if (!SWIG_IsOK(res1)) {
4237  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4238  }
4239  arg1 = (PLGraphicsIn *)(argp1);
4240  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4241  if (!SWIG_IsOK(ecode2)) {
4242  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4243  }
4244  arg2 = (unsigned int)(val2);
4245  if (arg1) (arg1)->keysym = arg2;
4246  resultobj = SWIG_Py_Void();
4247  return resultobj;
4248 fail:
4249  return NULL;
4250 }
4251 
4252 
4253 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254  PyObject *resultobj = 0;
4255  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4256  void *argp1 = 0 ;
4257  int res1 = 0 ;
4258  PyObject * obj0 = 0 ;
4259  unsigned int result;
4260 
4261  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4262  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4263  if (!SWIG_IsOK(res1)) {
4264  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4265  }
4266  arg1 = (PLGraphicsIn *)(argp1);
4267  result = (unsigned int) ((arg1)->keysym);
4268  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4269  return resultobj;
4270 fail:
4271  return NULL;
4272 }
4273 
4274 
4275 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276  PyObject *resultobj = 0;
4277  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4278  unsigned int arg2 ;
4279  void *argp1 = 0 ;
4280  int res1 = 0 ;
4281  unsigned int val2 ;
4282  int ecode2 = 0 ;
4283  PyObject * obj0 = 0 ;
4284  PyObject * obj1 = 0 ;
4285 
4286  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4287  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4288  if (!SWIG_IsOK(res1)) {
4289  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4290  }
4291  arg1 = (PLGraphicsIn *)(argp1);
4292  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4293  if (!SWIG_IsOK(ecode2)) {
4294  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4295  }
4296  arg2 = (unsigned int)(val2);
4297  if (arg1) (arg1)->button = arg2;
4298  resultobj = SWIG_Py_Void();
4299  return resultobj;
4300 fail:
4301  return NULL;
4302 }
4303 
4304 
4305 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4306  PyObject *resultobj = 0;
4307  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4308  void *argp1 = 0 ;
4309  int res1 = 0 ;
4310  PyObject * obj0 = 0 ;
4311  unsigned int result;
4312 
4313  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4314  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4315  if (!SWIG_IsOK(res1)) {
4316  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4317  }
4318  arg1 = (PLGraphicsIn *)(argp1);
4319  result = (unsigned int) ((arg1)->button);
4320  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4321  return resultobj;
4322 fail:
4323  return NULL;
4324 }
4325 
4326 
4327 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4328  PyObject *resultobj = 0;
4329  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4330  PLINT arg2 ;
4331  void *argp1 = 0 ;
4332  int res1 = 0 ;
4333  int val2 ;
4334  int ecode2 = 0 ;
4335  PyObject * obj0 = 0 ;
4336  PyObject * obj1 = 0 ;
4337 
4338  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4340  if (!SWIG_IsOK(res1)) {
4341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4342  }
4343  arg1 = (PLGraphicsIn *)(argp1);
4344  ecode2 = SWIG_AsVal_int(obj1, &val2);
4345  if (!SWIG_IsOK(ecode2)) {
4346  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4347  }
4348  arg2 = (PLINT)(val2);
4349  if (arg1) (arg1)->subwindow = arg2;
4350  resultobj = SWIG_Py_Void();
4351  return resultobj;
4352 fail:
4353  return NULL;
4354 }
4355 
4356 
4357 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4358  PyObject *resultobj = 0;
4359  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4360  void *argp1 = 0 ;
4361  int res1 = 0 ;
4362  PyObject * obj0 = 0 ;
4363  PLINT result;
4364 
4365  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4366  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4367  if (!SWIG_IsOK(res1)) {
4368  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4369  }
4370  arg1 = (PLGraphicsIn *)(argp1);
4371  result = (PLINT) ((arg1)->subwindow);
4372  resultobj = SWIG_From_int((int)(result));
4373  return resultobj;
4374 fail:
4375  return NULL;
4376 }
4377 
4378 
4379 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4380  PyObject *resultobj = 0;
4381  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4382  char *arg2 ;
4383  void *argp1 = 0 ;
4384  int res1 = 0 ;
4385  char temp2[16] ;
4386  int res2 ;
4387  PyObject * obj0 = 0 ;
4388  PyObject * obj1 = 0 ;
4389 
4390  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4391  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4392  if (!SWIG_IsOK(res1)) {
4393  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4394  }
4395  arg1 = (PLGraphicsIn *)(argp1);
4396  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4397  if (!SWIG_IsOK(res2)) {
4398  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4399  }
4400  arg2 = (char *)(temp2);
4401  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4402  else memset(arg1->string,0,16*sizeof(char));
4403  resultobj = SWIG_Py_Void();
4404  return resultobj;
4405 fail:
4406  return NULL;
4407 }
4408 
4409 
4410 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4411  PyObject *resultobj = 0;
4412  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4413  void *argp1 = 0 ;
4414  int res1 = 0 ;
4415  PyObject * obj0 = 0 ;
4416  char *result = 0 ;
4417 
4418  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4419  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4420  if (!SWIG_IsOK(res1)) {
4421  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4422  }
4423  arg1 = (PLGraphicsIn *)(argp1);
4424  result = (char *)(char *) ((arg1)->string);
4425  {
4426  size_t size = 16;
4427 
4428  while (size && (result[size - 1] == '\0')) --size;
4429 
4430  resultobj = SWIG_FromCharPtrAndSize(result, size);
4431  }
4432  return resultobj;
4433 fail:
4434  return NULL;
4435 }
4436 
4437 
4438 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4439  PyObject *resultobj = 0;
4440  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4441  int arg2 ;
4442  void *argp1 = 0 ;
4443  int res1 = 0 ;
4444  int val2 ;
4445  int ecode2 = 0 ;
4446  PyObject * obj0 = 0 ;
4447  PyObject * obj1 = 0 ;
4448 
4449  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4450  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4451  if (!SWIG_IsOK(res1)) {
4452  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4453  }
4454  arg1 = (PLGraphicsIn *)(argp1);
4455  ecode2 = SWIG_AsVal_int(obj1, &val2);
4456  if (!SWIG_IsOK(ecode2)) {
4457  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4458  }
4459  arg2 = (int)(val2);
4460  if (arg1) (arg1)->pX = arg2;
4461  resultobj = SWIG_Py_Void();
4462  return resultobj;
4463 fail:
4464  return NULL;
4465 }
4466 
4467 
4468 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4469  PyObject *resultobj = 0;
4470  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4471  void *argp1 = 0 ;
4472  int res1 = 0 ;
4473  PyObject * obj0 = 0 ;
4474  int result;
4475 
4476  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4477  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4478  if (!SWIG_IsOK(res1)) {
4479  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4480  }
4481  arg1 = (PLGraphicsIn *)(argp1);
4482  result = (int) ((arg1)->pX);
4483  resultobj = SWIG_From_int((int)(result));
4484  return resultobj;
4485 fail:
4486  return NULL;
4487 }
4488 
4489 
4490 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491  PyObject *resultobj = 0;
4492  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4493  int arg2 ;
4494  void *argp1 = 0 ;
4495  int res1 = 0 ;
4496  int val2 ;
4497  int ecode2 = 0 ;
4498  PyObject * obj0 = 0 ;
4499  PyObject * obj1 = 0 ;
4500 
4501  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4502  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4503  if (!SWIG_IsOK(res1)) {
4504  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4505  }
4506  arg1 = (PLGraphicsIn *)(argp1);
4507  ecode2 = SWIG_AsVal_int(obj1, &val2);
4508  if (!SWIG_IsOK(ecode2)) {
4509  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4510  }
4511  arg2 = (int)(val2);
4512  if (arg1) (arg1)->pY = arg2;
4513  resultobj = SWIG_Py_Void();
4514  return resultobj;
4515 fail:
4516  return NULL;
4517 }
4518 
4519 
4520 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521  PyObject *resultobj = 0;
4522  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4523  void *argp1 = 0 ;
4524  int res1 = 0 ;
4525  PyObject * obj0 = 0 ;
4526  int result;
4527 
4528  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4529  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4530  if (!SWIG_IsOK(res1)) {
4531  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4532  }
4533  arg1 = (PLGraphicsIn *)(argp1);
4534  result = (int) ((arg1)->pY);
4535  resultobj = SWIG_From_int((int)(result));
4536  return resultobj;
4537 fail:
4538  return NULL;
4539 }
4540 
4541 
4542 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4543  PyObject *resultobj = 0;
4544  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4545  PLFLT arg2 ;
4546  void *argp1 = 0 ;
4547  int res1 = 0 ;
4548  double val2 ;
4549  int ecode2 = 0 ;
4550  PyObject * obj0 = 0 ;
4551  PyObject * obj1 = 0 ;
4552 
4553  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4554  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4555  if (!SWIG_IsOK(res1)) {
4556  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4557  }
4558  arg1 = (PLGraphicsIn *)(argp1);
4559  ecode2 = SWIG_AsVal_double(obj1, &val2);
4560  if (!SWIG_IsOK(ecode2)) {
4561  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4562  }
4563  arg2 = (PLFLT)(val2);
4564  if (arg1) (arg1)->dX = arg2;
4565  resultobj = SWIG_Py_Void();
4566  return resultobj;
4567 fail:
4568  return NULL;
4569 }
4570 
4571 
4572 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573  PyObject *resultobj = 0;
4574  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4575  void *argp1 = 0 ;
4576  int res1 = 0 ;
4577  PyObject * obj0 = 0 ;
4578  PLFLT result;
4579 
4580  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4581  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4582  if (!SWIG_IsOK(res1)) {
4583  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4584  }
4585  arg1 = (PLGraphicsIn *)(argp1);
4586  result = (PLFLT) ((arg1)->dX);
4587  resultobj = SWIG_From_double((double)(result));
4588  return resultobj;
4589 fail:
4590  return NULL;
4591 }
4592 
4593 
4594 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595  PyObject *resultobj = 0;
4596  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4597  PLFLT arg2 ;
4598  void *argp1 = 0 ;
4599  int res1 = 0 ;
4600  double val2 ;
4601  int ecode2 = 0 ;
4602  PyObject * obj0 = 0 ;
4603  PyObject * obj1 = 0 ;
4604 
4605  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4606  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4607  if (!SWIG_IsOK(res1)) {
4608  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4609  }
4610  arg1 = (PLGraphicsIn *)(argp1);
4611  ecode2 = SWIG_AsVal_double(obj1, &val2);
4612  if (!SWIG_IsOK(ecode2)) {
4613  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4614  }
4615  arg2 = (PLFLT)(val2);
4616  if (arg1) (arg1)->dY = arg2;
4617  resultobj = SWIG_Py_Void();
4618  return resultobj;
4619 fail:
4620  return NULL;
4621 }
4622 
4623 
4624 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4625  PyObject *resultobj = 0;
4626  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4627  void *argp1 = 0 ;
4628  int res1 = 0 ;
4629  PyObject * obj0 = 0 ;
4630  PLFLT result;
4631 
4632  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4633  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4634  if (!SWIG_IsOK(res1)) {
4635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4636  }
4637  arg1 = (PLGraphicsIn *)(argp1);
4638  result = (PLFLT) ((arg1)->dY);
4639  resultobj = SWIG_From_double((double)(result));
4640  return resultobj;
4641 fail:
4642  return NULL;
4643 }
4644 
4645 
4646 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4647  PyObject *resultobj = 0;
4648  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4649  PLFLT arg2 ;
4650  void *argp1 = 0 ;
4651  int res1 = 0 ;
4652  double val2 ;
4653  int ecode2 = 0 ;
4654  PyObject * obj0 = 0 ;
4655  PyObject * obj1 = 0 ;
4656 
4657  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4658  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4659  if (!SWIG_IsOK(res1)) {
4660  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4661  }
4662  arg1 = (PLGraphicsIn *)(argp1);
4663  ecode2 = SWIG_AsVal_double(obj1, &val2);
4664  if (!SWIG_IsOK(ecode2)) {
4665  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4666  }
4667  arg2 = (PLFLT)(val2);
4668  if (arg1) (arg1)->wX = arg2;
4669  resultobj = SWIG_Py_Void();
4670  return resultobj;
4671 fail:
4672  return NULL;
4673 }
4674 
4675 
4676 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4677  PyObject *resultobj = 0;
4678  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4679  void *argp1 = 0 ;
4680  int res1 = 0 ;
4681  PyObject * obj0 = 0 ;
4682  PLFLT result;
4683 
4684  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4685  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4686  if (!SWIG_IsOK(res1)) {
4687  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4688  }
4689  arg1 = (PLGraphicsIn *)(argp1);
4690  result = (PLFLT) ((arg1)->wX);
4691  resultobj = SWIG_From_double((double)(result));
4692  return resultobj;
4693 fail:
4694  return NULL;
4695 }
4696 
4697 
4698 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4699  PyObject *resultobj = 0;
4700  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4701  PLFLT arg2 ;
4702  void *argp1 = 0 ;
4703  int res1 = 0 ;
4704  double val2 ;
4705  int ecode2 = 0 ;
4706  PyObject * obj0 = 0 ;
4707  PyObject * obj1 = 0 ;
4708 
4709  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4710  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4711  if (!SWIG_IsOK(res1)) {
4712  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4713  }
4714  arg1 = (PLGraphicsIn *)(argp1);
4715  ecode2 = SWIG_AsVal_double(obj1, &val2);
4716  if (!SWIG_IsOK(ecode2)) {
4717  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4718  }
4719  arg2 = (PLFLT)(val2);
4720  if (arg1) (arg1)->wY = arg2;
4721  resultobj = SWIG_Py_Void();
4722  return resultobj;
4723 fail:
4724  return NULL;
4725 }
4726 
4727 
4728 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4729  PyObject *resultobj = 0;
4730  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4731  void *argp1 = 0 ;
4732  int res1 = 0 ;
4733  PyObject * obj0 = 0 ;
4734  PLFLT result;
4735 
4736  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4737  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4738  if (!SWIG_IsOK(res1)) {
4739  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4740  }
4741  arg1 = (PLGraphicsIn *)(argp1);
4742  result = (PLFLT) ((arg1)->wY);
4743  resultobj = SWIG_From_double((double)(result));
4744  return resultobj;
4745 fail:
4746  return NULL;
4747 }
4748 
4749 
4750 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4751  PyObject *resultobj = 0;
4752  PLGraphicsIn *result = 0 ;
4753 
4754  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4755  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4757  return resultobj;
4758 fail:
4759  return NULL;
4760 }
4761 
4762 
4763 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4764  PyObject *resultobj = 0;
4765  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4766  void *argp1 = 0 ;
4767  int res1 = 0 ;
4768  PyObject * obj0 = 0 ;
4769 
4770  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4771  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4772  if (!SWIG_IsOK(res1)) {
4773  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4774  }
4775  arg1 = (PLGraphicsIn *)(argp1);
4776  free((char *) arg1);
4777  resultobj = SWIG_Py_Void();
4778  return resultobj;
4779 fail:
4780  return NULL;
4781 }
4782 
4783 
4784 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4785  PyObject *obj;
4786  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4788  return SWIG_Py_Void();
4789 }
4790 
4791 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4792  PyObject *resultobj = 0;
4793  PLINT arg1 ;
4794  int val1 ;
4795  int ecode1 = 0 ;
4796  PyObject * obj0 = 0 ;
4797 
4798  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4799  ecode1 = SWIG_AsVal_int(obj0, &val1);
4800  if (!SWIG_IsOK(ecode1)) {
4801  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4802  }
4803  arg1 = (PLINT)(val1);
4804  plsxwin(arg1);
4805  resultobj = SWIG_Py_Void();
4806  return resultobj;
4807 fail:
4808  return NULL;
4809 }
4810 
4811 
4812 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4813  PyObject *resultobj = 0;
4814  PLINT arg1 ;
4815  PLINT arg2 ;
4816  int val1 ;
4817  int ecode1 = 0 ;
4818  int val2 ;
4819  int ecode2 = 0 ;
4820  PyObject * obj0 = 0 ;
4821  PyObject * obj1 = 0 ;
4822 
4823  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4824  ecode1 = SWIG_AsVal_int(obj0, &val1);
4825  if (!SWIG_IsOK(ecode1)) {
4826  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4827  }
4828  arg1 = (PLINT)(val1);
4829  ecode2 = SWIG_AsVal_int(obj1, &val2);
4830  if (!SWIG_IsOK(ecode2)) {
4831  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4832  }
4833  arg2 = (PLINT)(val2);
4834  pl_setcontlabelformat(arg1,arg2);
4835  resultobj = SWIG_Py_Void();
4836  return resultobj;
4837 fail:
4838  return NULL;
4839 }
4840 
4841 
4842 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4843  PyObject *resultobj = 0;
4844  PLFLT arg1 ;
4845  PLFLT arg2 ;
4846  PLFLT arg3 ;
4847  PLINT arg4 ;
4848  double val1 ;
4849  int ecode1 = 0 ;
4850  double val2 ;
4851  int ecode2 = 0 ;
4852  double val3 ;
4853  int ecode3 = 0 ;
4854  int val4 ;
4855  int ecode4 = 0 ;
4856  PyObject * obj0 = 0 ;
4857  PyObject * obj1 = 0 ;
4858  PyObject * obj2 = 0 ;
4859  PyObject * obj3 = 0 ;
4860 
4861  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4862  ecode1 = SWIG_AsVal_double(obj0, &val1);
4863  if (!SWIG_IsOK(ecode1)) {
4864  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4865  }
4866  arg1 = (PLFLT)(val1);
4867  ecode2 = SWIG_AsVal_double(obj1, &val2);
4868  if (!SWIG_IsOK(ecode2)) {
4869  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4870  }
4871  arg2 = (PLFLT)(val2);
4872  ecode3 = SWIG_AsVal_double(obj2, &val3);
4873  if (!SWIG_IsOK(ecode3)) {
4874  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4875  }
4876  arg3 = (PLFLT)(val3);
4877  ecode4 = SWIG_AsVal_int(obj3, &val4);
4878  if (!SWIG_IsOK(ecode4)) {
4879  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4880  }
4881  arg4 = (PLINT)(val4);
4882  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4883  resultobj = SWIG_Py_Void();
4884  return resultobj;
4885 fail:
4886  return NULL;
4887 }
4888 
4889 
4890 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4891  PyObject *resultobj = 0;
4892  PLINT arg1 ;
4893  int val1 ;
4894  int ecode1 = 0 ;
4895  PyObject * obj0 = 0 ;
4896 
4897  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
4898  ecode1 = SWIG_AsVal_int(obj0, &val1);
4899  if (!SWIG_IsOK(ecode1)) {
4900  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4901  }
4902  arg1 = (PLINT)(val1);
4903  pladv(arg1);
4904  resultobj = SWIG_Py_Void();
4905  return resultobj;
4906 fail:
4907  return NULL;
4908 }
4909 
4910 
4911 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4912  PyObject *resultobj = 0;
4913  PLFLT arg1 ;
4914  PLFLT arg2 ;
4915  PLFLT arg3 ;
4916  PLFLT arg4 ;
4917  PLFLT arg5 ;
4918  PLFLT arg6 ;
4919  PLFLT arg7 ;
4920  PLBOOL arg8 ;
4921  double val1 ;
4922  int ecode1 = 0 ;
4923  double val2 ;
4924  int ecode2 = 0 ;
4925  double val3 ;
4926  int ecode3 = 0 ;
4927  double val4 ;
4928  int ecode4 = 0 ;
4929  double val5 ;
4930  int ecode5 = 0 ;
4931  double val6 ;
4932  int ecode6 = 0 ;
4933  double val7 ;
4934  int ecode7 = 0 ;
4935  int val8 ;
4936  int ecode8 = 0 ;
4937  PyObject * obj0 = 0 ;
4938  PyObject * obj1 = 0 ;
4939  PyObject * obj2 = 0 ;
4940  PyObject * obj3 = 0 ;
4941  PyObject * obj4 = 0 ;
4942  PyObject * obj5 = 0 ;
4943  PyObject * obj6 = 0 ;
4944  PyObject * obj7 = 0 ;
4945 
4946  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4947  ecode1 = SWIG_AsVal_double(obj0, &val1);
4948  if (!SWIG_IsOK(ecode1)) {
4949  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4950  }
4951  arg1 = (PLFLT)(val1);
4952  ecode2 = SWIG_AsVal_double(obj1, &val2);
4953  if (!SWIG_IsOK(ecode2)) {
4954  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4955  }
4956  arg2 = (PLFLT)(val2);
4957  ecode3 = SWIG_AsVal_double(obj2, &val3);
4958  if (!SWIG_IsOK(ecode3)) {
4959  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4960  }
4961  arg3 = (PLFLT)(val3);
4962  ecode4 = SWIG_AsVal_double(obj3, &val4);
4963  if (!SWIG_IsOK(ecode4)) {
4964  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4965  }
4966  arg4 = (PLFLT)(val4);
4967  ecode5 = SWIG_AsVal_double(obj4, &val5);
4968  if (!SWIG_IsOK(ecode5)) {
4969  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4970  }
4971  arg5 = (PLFLT)(val5);
4972  ecode6 = SWIG_AsVal_double(obj5, &val6);
4973  if (!SWIG_IsOK(ecode6)) {
4974  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4975  }
4976  arg6 = (PLFLT)(val6);
4977  ecode7 = SWIG_AsVal_double(obj6, &val7);
4978  if (!SWIG_IsOK(ecode7)) {
4979  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4980  }
4981  arg7 = (PLFLT)(val7);
4982  ecode8 = SWIG_AsVal_int(obj7, &val8);
4983  if (!SWIG_IsOK(ecode8)) {
4984  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4985  }
4986  arg8 = (PLBOOL)(val8);
4987  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4988  resultobj = SWIG_Py_Void();
4989  return resultobj;
4990 fail:
4991  return NULL;
4992 }
4993 
4994 
4995 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996  PyObject *resultobj = 0;
4997  PLFLT arg1 ;
4998  PLFLT arg2 ;
4999  char *arg3 = (char *) 0 ;
5000  PLFLT arg4 ;
5001  PLINT arg5 ;
5002  char *arg6 = (char *) 0 ;
5003  PLFLT arg7 ;
5004  PLINT arg8 ;
5005  double val1 ;
5006  int ecode1 = 0 ;
5007  double val2 ;
5008  int ecode2 = 0 ;
5009  int res3 ;
5010  char *buf3 = 0 ;
5011  int alloc3 = 0 ;
5012  double val4 ;
5013  int ecode4 = 0 ;
5014  int val5 ;
5015  int ecode5 = 0 ;
5016  int res6 ;
5017  char *buf6 = 0 ;
5018  int alloc6 = 0 ;
5019  double val7 ;
5020  int ecode7 = 0 ;
5021  int val8 ;
5022  int ecode8 = 0 ;
5023  PyObject * obj0 = 0 ;
5024  PyObject * obj1 = 0 ;
5025  PyObject * obj2 = 0 ;
5026  PyObject * obj3 = 0 ;
5027  PyObject * obj4 = 0 ;
5028  PyObject * obj5 = 0 ;
5029  PyObject * obj6 = 0 ;
5030  PyObject * obj7 = 0 ;
5031 
5032  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5033  ecode1 = SWIG_AsVal_double(obj0, &val1);
5034  if (!SWIG_IsOK(ecode1)) {
5035  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5036  }
5037  arg1 = (PLFLT)(val1);
5038  ecode2 = SWIG_AsVal_double(obj1, &val2);
5039  if (!SWIG_IsOK(ecode2)) {
5040  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5041  }
5042  arg2 = (PLFLT)(val2);
5043  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5044  if (!SWIG_IsOK(res3)) {
5045  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5046  }
5047  arg3 = (char *)(buf3);
5048  ecode4 = SWIG_AsVal_double(obj3, &val4);
5049  if (!SWIG_IsOK(ecode4)) {
5050  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5051  }
5052  arg4 = (PLFLT)(val4);
5053  ecode5 = SWIG_AsVal_int(obj4, &val5);
5054  if (!SWIG_IsOK(ecode5)) {
5055  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5056  }
5057  arg5 = (PLINT)(val5);
5058  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5059  if (!SWIG_IsOK(res6)) {
5060  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5061  }
5062  arg6 = (char *)(buf6);
5063  ecode7 = SWIG_AsVal_double(obj6, &val7);
5064  if (!SWIG_IsOK(ecode7)) {
5065  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5066  }
5067  arg7 = (PLFLT)(val7);
5068  ecode8 = SWIG_AsVal_int(obj7, &val8);
5069  if (!SWIG_IsOK(ecode8)) {
5070  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5071  }
5072  arg8 = (PLINT)(val8);
5073  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5074  resultobj = SWIG_Py_Void();
5075  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5076  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5077  return resultobj;
5078 fail:
5079  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5080  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5081  return NULL;
5082 }
5083 
5084 
5085 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086  PyObject *resultobj = 0;
5087  PLINT arg1 ;
5088  PLFLT *arg2 = (PLFLT *) 0 ;
5089  PLFLT *arg3 = (PLFLT *) 0 ;
5090  PLINT arg4 ;
5091  PyArrayObject *tmp1 = NULL ;
5092  PyArrayObject *tmp3 = NULL ;
5093  int val4 ;
5094  int ecode4 = 0 ;
5095  PyObject * obj0 = 0 ;
5096  PyObject * obj1 = 0 ;
5097  PyObject * obj2 = 0 ;
5098 
5099  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5100  {
5101  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5102  if ( tmp1 == NULL )
5103  return NULL;
5104  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5105  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5106  }
5107  {
5108  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5109  if ( tmp3 == NULL )
5110  return NULL;
5111  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5112  {
5113  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5114  return NULL;
5115  }
5116  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5117  }
5118  ecode4 = SWIG_AsVal_int(obj2, &val4);
5119  if (!SWIG_IsOK(ecode4)) {
5120  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5121  }
5122  arg4 = (PLINT)(val4);
5123  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5124  resultobj = SWIG_Py_Void();
5125  {
5126  Py_CLEAR( tmp1 );
5127  }
5128  {
5129  Py_CLEAR( tmp3 );
5130  }
5131  return resultobj;
5132 fail:
5133  {
5134  Py_CLEAR( tmp1 );
5135  }
5136  {
5137  Py_CLEAR( tmp3 );
5138  }
5139  return NULL;
5140 }
5141 
5142 
5143 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5144  PyObject *resultobj = 0;
5145  PLINT *arg1 = (PLINT *) 0 ;
5146  PLINT *arg2 = (PLINT *) 0 ;
5147  PLINT *arg3 = (PLINT *) 0 ;
5148  PLINT *arg4 = (PLINT *) 0 ;
5149  PLINT *arg5 = (PLINT *) 0 ;
5150  PLFLT *arg6 = (PLFLT *) 0 ;
5151  PLFLT arg7 ;
5152  PLINT temp1 ;
5153  int res1 = SWIG_TMPOBJ ;
5154  PLINT temp2 ;
5155  int res2 = SWIG_TMPOBJ ;
5156  PLINT temp3 ;
5157  int res3 = SWIG_TMPOBJ ;
5158  PLINT temp4 ;
5159  int res4 = SWIG_TMPOBJ ;
5160  PLINT temp5 ;
5161  int res5 = SWIG_TMPOBJ ;
5162  PLFLT temp6 ;
5163  int res6 = SWIG_TMPOBJ ;
5164  double val7 ;
5165  int ecode7 = 0 ;
5166  PyObject * obj0 = 0 ;
5167 
5168  arg1 = &temp1;
5169  arg2 = &temp2;
5170  arg3 = &temp3;
5171  arg4 = &temp4;
5172  arg5 = &temp5;
5173  arg6 = &temp6;
5174  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5175  ecode7 = SWIG_AsVal_double(obj0, &val7);
5176  if (!SWIG_IsOK(ecode7)) {
5177  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5178  }
5179  arg7 = (PLFLT)(val7);
5180  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5181  resultobj = SWIG_Py_Void();
5182  if (SWIG_IsTmpObj(res1)) {
5183  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5184  } else {
5185  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5186  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5187  }
5188  if (SWIG_IsTmpObj(res2)) {
5189  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5190  } else {
5191  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5192  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5193  }
5194  if (SWIG_IsTmpObj(res3)) {
5195  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5196  } else {
5197  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5198  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5199  }
5200  if (SWIG_IsTmpObj(res4)) {
5201  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5202  } else {
5203  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5204  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5205  }
5206  if (SWIG_IsTmpObj(res5)) {
5207  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5208  } else {
5209  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5210  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5211  }
5212  if (SWIG_IsTmpObj(res6)) {
5213  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5214  } else {
5215  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5216  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5217  }
5218  return resultobj;
5219 fail:
5220  return NULL;
5221 }
5222 
5223 
5224 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5225  PyObject *resultobj = 0;
5226 
5227  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5228  plbop();
5229  resultobj = SWIG_Py_Void();
5230  return resultobj;
5231 fail:
5232  return NULL;
5233 }
5234 
5235 
5236 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5237  PyObject *resultobj = 0;
5238  char *arg1 = (char *) 0 ;
5239  PLFLT arg2 ;
5240  PLINT arg3 ;
5241  char *arg4 = (char *) 0 ;
5242  PLFLT arg5 ;
5243  PLINT arg6 ;
5244  int res1 ;
5245  char *buf1 = 0 ;
5246  int alloc1 = 0 ;
5247  double val2 ;
5248  int ecode2 = 0 ;
5249  int val3 ;
5250  int ecode3 = 0 ;
5251  int res4 ;
5252  char *buf4 = 0 ;
5253  int alloc4 = 0 ;
5254  double val5 ;
5255  int ecode5 = 0 ;
5256  int val6 ;
5257  int ecode6 = 0 ;
5258  PyObject * obj0 = 0 ;
5259  PyObject * obj1 = 0 ;
5260  PyObject * obj2 = 0 ;
5261  PyObject * obj3 = 0 ;
5262  PyObject * obj4 = 0 ;
5263  PyObject * obj5 = 0 ;
5264 
5265  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5266  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5267  if (!SWIG_IsOK(res1)) {
5268  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5269  }
5270  arg1 = (char *)(buf1);
5271  ecode2 = SWIG_AsVal_double(obj1, &val2);
5272  if (!SWIG_IsOK(ecode2)) {
5273  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5274  }
5275  arg2 = (PLFLT)(val2);
5276  ecode3 = SWIG_AsVal_int(obj2, &val3);
5277  if (!SWIG_IsOK(ecode3)) {
5278  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5279  }
5280  arg3 = (PLINT)(val3);
5281  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5282  if (!SWIG_IsOK(res4)) {
5283  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5284  }
5285  arg4 = (char *)(buf4);
5286  ecode5 = SWIG_AsVal_double(obj4, &val5);
5287  if (!SWIG_IsOK(ecode5)) {
5288  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5289  }
5290  arg5 = (PLFLT)(val5);
5291  ecode6 = SWIG_AsVal_int(obj5, &val6);
5292  if (!SWIG_IsOK(ecode6)) {
5293  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5294  }
5295  arg6 = (PLINT)(val6);
5296  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5297  resultobj = SWIG_Py_Void();
5298  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5299  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5300  return resultobj;
5301 fail:
5302  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5303  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5304  return NULL;
5305 }
5306 
5307 
5308 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5309  PyObject *resultobj = 0;
5310  char *arg1 = (char *) 0 ;
5311  char *arg2 = (char *) 0 ;
5312  PLFLT arg3 ;
5313  PLINT arg4 ;
5314  char *arg5 = (char *) 0 ;
5315  char *arg6 = (char *) 0 ;
5316  PLFLT arg7 ;
5317  PLINT arg8 ;
5318  char *arg9 = (char *) 0 ;
5319  char *arg10 = (char *) 0 ;
5320  PLFLT arg11 ;
5321  PLINT arg12 ;
5322  int res1 ;
5323  char *buf1 = 0 ;
5324  int alloc1 = 0 ;
5325  int res2 ;
5326  char *buf2 = 0 ;
5327  int alloc2 = 0 ;
5328  double val3 ;
5329  int ecode3 = 0 ;
5330  int val4 ;
5331  int ecode4 = 0 ;
5332  int res5 ;
5333  char *buf5 = 0 ;
5334  int alloc5 = 0 ;
5335  int res6 ;
5336  char *buf6 = 0 ;
5337  int alloc6 = 0 ;
5338  double val7 ;
5339  int ecode7 = 0 ;
5340  int val8 ;
5341  int ecode8 = 0 ;
5342  int res9 ;
5343  char *buf9 = 0 ;
5344  int alloc9 = 0 ;
5345  int res10 ;
5346  char *buf10 = 0 ;
5347  int alloc10 = 0 ;
5348  double val11 ;
5349  int ecode11 = 0 ;
5350  int val12 ;
5351  int ecode12 = 0 ;
5352  PyObject * obj0 = 0 ;
5353  PyObject * obj1 = 0 ;
5354  PyObject * obj2 = 0 ;
5355  PyObject * obj3 = 0 ;
5356  PyObject * obj4 = 0 ;
5357  PyObject * obj5 = 0 ;
5358  PyObject * obj6 = 0 ;
5359  PyObject * obj7 = 0 ;
5360  PyObject * obj8 = 0 ;
5361  PyObject * obj9 = 0 ;
5362  PyObject * obj10 = 0 ;
5363  PyObject * obj11 = 0 ;
5364 
5365  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5366  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5367  if (!SWIG_IsOK(res1)) {
5368  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5369  }
5370  arg1 = (char *)(buf1);
5371  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5372  if (!SWIG_IsOK(res2)) {
5373  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5374  }
5375  arg2 = (char *)(buf2);
5376  ecode3 = SWIG_AsVal_double(obj2, &val3);
5377  if (!SWIG_IsOK(ecode3)) {
5378  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5379  }
5380  arg3 = (PLFLT)(val3);
5381  ecode4 = SWIG_AsVal_int(obj3, &val4);
5382  if (!SWIG_IsOK(ecode4)) {
5383  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5384  }
5385  arg4 = (PLINT)(val4);
5386  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5387  if (!SWIG_IsOK(res5)) {
5388  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5389  }
5390  arg5 = (char *)(buf5);
5391  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5392  if (!SWIG_IsOK(res6)) {
5393  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5394  }
5395  arg6 = (char *)(buf6);
5396  ecode7 = SWIG_AsVal_double(obj6, &val7);
5397  if (!SWIG_IsOK(ecode7)) {
5398  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5399  }
5400  arg7 = (PLFLT)(val7);
5401  ecode8 = SWIG_AsVal_int(obj7, &val8);
5402  if (!SWIG_IsOK(ecode8)) {
5403  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5404  }
5405  arg8 = (PLINT)(val8);
5406  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5407  if (!SWIG_IsOK(res9)) {
5408  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5409  }
5410  arg9 = (char *)(buf9);
5411  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5412  if (!SWIG_IsOK(res10)) {
5413  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5414  }
5415  arg10 = (char *)(buf10);
5416  ecode11 = SWIG_AsVal_double(obj10, &val11);
5417  if (!SWIG_IsOK(ecode11)) {
5418  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5419  }
5420  arg11 = (PLFLT)(val11);
5421  ecode12 = SWIG_AsVal_int(obj11, &val12);
5422  if (!SWIG_IsOK(ecode12)) {
5423  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5424  }
5425  arg12 = (PLINT)(val12);
5426  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);
5427  resultobj = SWIG_Py_Void();
5428  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5429  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5430  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5431  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5432  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5433  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5434  return resultobj;
5435 fail:
5436  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5437  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5438  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5439  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5440  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5441  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5442  return NULL;
5443 }
5444 
5445 
5446 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447  PyObject *resultobj = 0;
5448  PLFLT arg1 ;
5449  PLFLT arg2 ;
5450  PLFLT *arg3 = (PLFLT *) 0 ;
5451  PLFLT *arg4 = (PLFLT *) 0 ;
5452  PLINT *arg5 = (PLINT *) 0 ;
5453  double val1 ;
5454  int ecode1 = 0 ;
5455  double val2 ;
5456  int ecode2 = 0 ;
5457  PLFLT temp3 ;
5458  int res3 = SWIG_TMPOBJ ;
5459  PLFLT temp4 ;
5460  int res4 = SWIG_TMPOBJ ;
5461  PLINT temp5 ;
5462  int res5 = SWIG_TMPOBJ ;
5463  PyObject * obj0 = 0 ;
5464  PyObject * obj1 = 0 ;
5465 
5466  arg3 = &temp3;
5467  arg4 = &temp4;
5468  arg5 = &temp5;
5469  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5470  ecode1 = SWIG_AsVal_double(obj0, &val1);
5471  if (!SWIG_IsOK(ecode1)) {
5472  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5473  }
5474  arg1 = (PLFLT)(val1);
5475  ecode2 = SWIG_AsVal_double(obj1, &val2);
5476  if (!SWIG_IsOK(ecode2)) {
5477  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5478  }
5479  arg2 = (PLFLT)(val2);
5480  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5481  resultobj = SWIG_Py_Void();
5482  if (SWIG_IsTmpObj(res3)) {
5483  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5484  } else {
5485  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5486  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5487  }
5488  if (SWIG_IsTmpObj(res4)) {
5489  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5490  } else {
5491  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5492  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5493  }
5494  if (SWIG_IsTmpObj(res5)) {
5495  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5496  } else {
5497  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5498  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5499  }
5500  return resultobj;
5501 fail:
5502  return NULL;
5503 }
5504 
5505 
5506 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507  PyObject *resultobj = 0;
5508 
5509  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5510  plclear();
5511  resultobj = SWIG_Py_Void();
5512  return resultobj;
5513 fail:
5514  return NULL;
5515 }
5516 
5517 
5518 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5519  PyObject *resultobj = 0;
5520  PLINT arg1 ;
5521  int val1 ;
5522  int ecode1 = 0 ;
5523  PyObject * obj0 = 0 ;
5524 
5525  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5526  ecode1 = SWIG_AsVal_int(obj0, &val1);
5527  if (!SWIG_IsOK(ecode1)) {
5528  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5529  }
5530  arg1 = (PLINT)(val1);
5531  plcol0(arg1);
5532  resultobj = SWIG_Py_Void();
5533  return resultobj;
5534 fail:
5535  return NULL;
5536 }
5537 
5538 
5539 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5540  PyObject *resultobj = 0;
5541  PLFLT arg1 ;
5542  double val1 ;
5543  int ecode1 = 0 ;
5544  PyObject * obj0 = 0 ;
5545 
5546  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5547  ecode1 = SWIG_AsVal_double(obj0, &val1);
5548  if (!SWIG_IsOK(ecode1)) {
5549  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5550  }
5551  arg1 = (PLFLT)(val1);
5552  plcol1(arg1);
5553  resultobj = SWIG_Py_Void();
5554  return resultobj;
5555 fail:
5556  return NULL;
5557 }
5558 
5559 
5560 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5561  PyObject *resultobj = 0;
5562  PLFLT arg1 ;
5563  PLFLT arg2 ;
5564  PLFLT arg3 ;
5565  PLINT arg4 ;
5566  PLBOOL arg5 ;
5567  PLINT arg6 ;
5568  PLINT arg7 ;
5569  PLINT arg8 ;
5570  PLINT arg9 ;
5571  PLINT arg10 ;
5572  PLFLT arg11 ;
5573  double val1 ;
5574  int ecode1 = 0 ;
5575  double val2 ;
5576  int ecode2 = 0 ;
5577  double val3 ;
5578  int ecode3 = 0 ;
5579  int val4 ;
5580  int ecode4 = 0 ;
5581  int val5 ;
5582  int ecode5 = 0 ;
5583  int val6 ;
5584  int ecode6 = 0 ;
5585  int val7 ;
5586  int ecode7 = 0 ;
5587  int val8 ;
5588  int ecode8 = 0 ;
5589  int val9 ;
5590  int ecode9 = 0 ;
5591  int val10 ;
5592  int ecode10 = 0 ;
5593  double val11 ;
5594  int ecode11 = 0 ;
5595  PyObject * obj0 = 0 ;
5596  PyObject * obj1 = 0 ;
5597  PyObject * obj2 = 0 ;
5598  PyObject * obj3 = 0 ;
5599  PyObject * obj4 = 0 ;
5600  PyObject * obj5 = 0 ;
5601  PyObject * obj6 = 0 ;
5602  PyObject * obj7 = 0 ;
5603  PyObject * obj8 = 0 ;
5604  PyObject * obj9 = 0 ;
5605  PyObject * obj10 = 0 ;
5606 
5607  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5608  ecode1 = SWIG_AsVal_double(obj0, &val1);
5609  if (!SWIG_IsOK(ecode1)) {
5610  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5611  }
5612  arg1 = (PLFLT)(val1);
5613  ecode2 = SWIG_AsVal_double(obj1, &val2);
5614  if (!SWIG_IsOK(ecode2)) {
5615  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5616  }
5617  arg2 = (PLFLT)(val2);
5618  ecode3 = SWIG_AsVal_double(obj2, &val3);
5619  if (!SWIG_IsOK(ecode3)) {
5620  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5621  }
5622  arg3 = (PLFLT)(val3);
5623  ecode4 = SWIG_AsVal_int(obj3, &val4);
5624  if (!SWIG_IsOK(ecode4)) {
5625  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5626  }
5627  arg4 = (PLINT)(val4);
5628  ecode5 = SWIG_AsVal_int(obj4, &val5);
5629  if (!SWIG_IsOK(ecode5)) {
5630  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5631  }
5632  arg5 = (PLBOOL)(val5);
5633  ecode6 = SWIG_AsVal_int(obj5, &val6);
5634  if (!SWIG_IsOK(ecode6)) {
5635  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5636  }
5637  arg6 = (PLINT)(val6);
5638  ecode7 = SWIG_AsVal_int(obj6, &val7);
5639  if (!SWIG_IsOK(ecode7)) {
5640  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5641  }
5642  arg7 = (PLINT)(val7);
5643  ecode8 = SWIG_AsVal_int(obj7, &val8);
5644  if (!SWIG_IsOK(ecode8)) {
5645  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5646  }
5647  arg8 = (PLINT)(val8);
5648  ecode9 = SWIG_AsVal_int(obj8, &val9);
5649  if (!SWIG_IsOK(ecode9)) {
5650  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5651  }
5652  arg9 = (PLINT)(val9);
5653  ecode10 = SWIG_AsVal_int(obj9, &val10);
5654  if (!SWIG_IsOK(ecode10)) {
5655  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5656  }
5657  arg10 = (PLINT)(val10);
5658  ecode11 = SWIG_AsVal_double(obj10, &val11);
5659  if (!SWIG_IsOK(ecode11)) {
5660  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5661  }
5662  arg11 = (PLFLT)(val11);
5663  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5664  resultobj = SWIG_Py_Void();
5665  return resultobj;
5666 fail:
5667  return NULL;
5668 }
5669 
5670 
5671 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672  PyObject *resultobj = 0;
5673  PLFLT **arg1 = (PLFLT **) 0 ;
5674  PLINT arg2 ;
5675  PLINT arg3 ;
5676  PLINT arg4 ;
5677  PLINT arg5 ;
5678  PLINT arg6 ;
5679  PLINT arg7 ;
5680  PLFLT *arg8 = (PLFLT *) 0 ;
5681  PLINT arg9 ;
5682  pltr_func arg10 = (pltr_func) 0 ;
5683  PLPointer arg11 = (PLPointer) 0 ;
5684  PyArrayObject *tmp1 = NULL ;
5685  int val4 ;
5686  int ecode4 = 0 ;
5687  int val5 ;
5688  int ecode5 = 0 ;
5689  int val6 ;
5690  int ecode6 = 0 ;
5691  int val7 ;
5692  int ecode7 = 0 ;
5693  PyArrayObject *tmp8 = NULL ;
5694  PyObject * obj0 = 0 ;
5695  PyObject * obj1 = 0 ;
5696  PyObject * obj2 = 0 ;
5697  PyObject * obj3 = 0 ;
5698  PyObject * obj4 = 0 ;
5699  PyObject * obj5 = 0 ;
5700  PyObject * obj6 = 0 ;
5701  PyObject * obj7 = 0 ;
5702 
5703  {
5704  python_pltr = 0;
5705  arg10 = NULL;
5706  }
5707  {
5708  arg11 = NULL;
5709  }
5710  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5711  {
5712  int i, size;
5713  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5714  if ( tmp1 == NULL )
5715  return NULL;
5716  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5717  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5718  size = arg3;
5719  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5720  for ( i = 0; i < arg2; i++ )
5721  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5722  }
5723  ecode4 = SWIG_AsVal_int(obj1, &val4);
5724  if (!SWIG_IsOK(ecode4)) {
5725  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5726  }
5727  arg4 = (PLINT)(val4);
5728  ecode5 = SWIG_AsVal_int(obj2, &val5);
5729  if (!SWIG_IsOK(ecode5)) {
5730  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5731  }
5732  arg5 = (PLINT)(val5);
5733  ecode6 = SWIG_AsVal_int(obj3, &val6);
5734  if (!SWIG_IsOK(ecode6)) {
5735  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5736  }
5737  arg6 = (PLINT)(val6);
5738  ecode7 = SWIG_AsVal_int(obj4, &val7);
5739  if (!SWIG_IsOK(ecode7)) {
5740  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5741  }
5742  arg7 = (PLINT)(val7);
5743  {
5744  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5745  if ( tmp8 == NULL )
5746  return NULL;
5747  arg9 = PyArray_DIMS( tmp8 )[0];
5748  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5749  }
5750  if (obj6) {
5751  {
5752  // it must be a callable or None
5753  if ( obj6 == Py_None )
5754  {
5755  arg10 = NULL;
5756  }
5757  else
5758  {
5759  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5760  {
5761  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5762  return NULL;
5763  }
5764  arg10 = marshal_pltr( obj6 );
5765  }
5766  }
5767  }
5768  if (obj7) {
5769  {
5770  if ( obj7 == Py_None )
5771  arg11 = NULL;
5772  else
5773  {
5774  arg11 = marshal_PLPointer( obj7, 0 );
5775  }
5776  }
5777  }
5778  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5779  resultobj = SWIG_Py_Void();
5780  {
5781  Py_CLEAR( tmp1 );
5782  free( arg1 );
5783  }
5784  {
5785  Py_CLEAR( tmp8 );
5786  }
5787  {
5788  cleanup_pltr();
5789  }
5790  {
5792  }
5793  return resultobj;
5794 fail:
5795  {
5796  Py_CLEAR( tmp1 );
5797  free( arg1 );
5798  }
5799  {
5800  Py_CLEAR( tmp8 );
5801  }
5802  {
5803  cleanup_pltr();
5804  }
5805  {
5807  }
5808  return NULL;
5809 }
5810 
5811 
5812 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5813  PyObject *resultobj = 0;
5814  PLINT arg1 ;
5815  PLINT arg2 ;
5816  PLINT arg3 ;
5817  PLINT arg4 ;
5818  PLINT arg5 ;
5819  PLFLT arg6 ;
5820  PLFLT *arg7 = (PLFLT *) 0 ;
5821  int val1 ;
5822  int ecode1 = 0 ;
5823  int val2 ;
5824  int ecode2 = 0 ;
5825  int val3 ;
5826  int ecode3 = 0 ;
5827  int val4 ;
5828  int ecode4 = 0 ;
5829  int val5 ;
5830  int ecode5 = 0 ;
5831  double val6 ;
5832  int ecode6 = 0 ;
5833  PLFLT temp7 ;
5834  int res7 = SWIG_TMPOBJ ;
5835  PyObject * obj0 = 0 ;
5836  PyObject * obj1 = 0 ;
5837  PyObject * obj2 = 0 ;
5838  PyObject * obj3 = 0 ;
5839  PyObject * obj4 = 0 ;
5840  PyObject * obj5 = 0 ;
5841 
5842  arg7 = &temp7;
5843  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5844  ecode1 = SWIG_AsVal_int(obj0, &val1);
5845  if (!SWIG_IsOK(ecode1)) {
5846  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5847  }
5848  arg1 = (PLINT)(val1);
5849  ecode2 = SWIG_AsVal_int(obj1, &val2);
5850  if (!SWIG_IsOK(ecode2)) {
5851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5852  }
5853  arg2 = (PLINT)(val2);
5854  ecode3 = SWIG_AsVal_int(obj2, &val3);
5855  if (!SWIG_IsOK(ecode3)) {
5856  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5857  }
5858  arg3 = (PLINT)(val3);
5859  ecode4 = SWIG_AsVal_int(obj3, &val4);
5860  if (!SWIG_IsOK(ecode4)) {
5861  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5862  }
5863  arg4 = (PLINT)(val4);
5864  ecode5 = SWIG_AsVal_int(obj4, &val5);
5865  if (!SWIG_IsOK(ecode5)) {
5866  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5867  }
5868  arg5 = (PLINT)(val5);
5869  ecode6 = SWIG_AsVal_double(obj5, &val6);
5870  if (!SWIG_IsOK(ecode6)) {
5871  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5872  }
5873  arg6 = (PLFLT)(val6);
5874  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5875  resultobj = SWIG_Py_Void();
5876  if (SWIG_IsTmpObj(res7)) {
5877  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5878  } else {
5879  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5880  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5881  }
5882  return resultobj;
5883 fail:
5884  return NULL;
5885 }
5886 
5887 
5888 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889  PyObject *resultobj = 0;
5890  PLINT arg1 ;
5891  PLBOOL arg2 ;
5892  int val1 ;
5893  int ecode1 = 0 ;
5894  int val2 ;
5895  int ecode2 = 0 ;
5896  PyObject * obj0 = 0 ;
5897  PyObject * obj1 = 0 ;
5898 
5899  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
5900  ecode1 = SWIG_AsVal_int(obj0, &val1);
5901  if (!SWIG_IsOK(ecode1)) {
5902  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5903  }
5904  arg1 = (PLINT)(val1);
5905  ecode2 = SWIG_AsVal_int(obj1, &val2);
5906  if (!SWIG_IsOK(ecode2)) {
5907  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5908  }
5909  arg2 = (PLBOOL)(val2);
5910  plcpstrm(arg1,arg2);
5911  resultobj = SWIG_Py_Void();
5912  return resultobj;
5913 fail:
5914  return NULL;
5915 }
5916 
5917 
5918 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5919  PyObject *resultobj = 0;
5920 
5921  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
5922  plend();
5923  resultobj = SWIG_Py_Void();
5924  return resultobj;
5925 fail:
5926  return NULL;
5927 }
5928 
5929 
5930 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5931  PyObject *resultobj = 0;
5932 
5933  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
5934  plend1();
5935  resultobj = SWIG_Py_Void();
5936  return resultobj;
5937 fail:
5938  return NULL;
5939 }
5940 
5941 
5942 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5943  PyObject *resultobj = 0;
5944  PLFLT arg1 ;
5945  PLFLT arg2 ;
5946  PLFLT arg3 ;
5947  PLFLT arg4 ;
5948  PLINT arg5 ;
5949  PLINT arg6 ;
5950  double val1 ;
5951  int ecode1 = 0 ;
5952  double val2 ;
5953  int ecode2 = 0 ;
5954  double val3 ;
5955  int ecode3 = 0 ;
5956  double val4 ;
5957  int ecode4 = 0 ;
5958  int val5 ;
5959  int ecode5 = 0 ;
5960  int val6 ;
5961  int ecode6 = 0 ;
5962  PyObject * obj0 = 0 ;
5963  PyObject * obj1 = 0 ;
5964  PyObject * obj2 = 0 ;
5965  PyObject * obj3 = 0 ;
5966  PyObject * obj4 = 0 ;
5967  PyObject * obj5 = 0 ;
5968 
5969  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5970  ecode1 = SWIG_AsVal_double(obj0, &val1);
5971  if (!SWIG_IsOK(ecode1)) {
5972  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5973  }
5974  arg1 = (PLFLT)(val1);
5975  ecode2 = SWIG_AsVal_double(obj1, &val2);
5976  if (!SWIG_IsOK(ecode2)) {
5977  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5978  }
5979  arg2 = (PLFLT)(val2);
5980  ecode3 = SWIG_AsVal_double(obj2, &val3);
5981  if (!SWIG_IsOK(ecode3)) {
5982  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5983  }
5984  arg3 = (PLFLT)(val3);
5985  ecode4 = SWIG_AsVal_double(obj3, &val4);
5986  if (!SWIG_IsOK(ecode4)) {
5987  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5988  }
5989  arg4 = (PLFLT)(val4);
5990  ecode5 = SWIG_AsVal_int(obj4, &val5);
5991  if (!SWIG_IsOK(ecode5)) {
5992  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5993  }
5994  arg5 = (PLINT)(val5);
5995  ecode6 = SWIG_AsVal_int(obj5, &val6);
5996  if (!SWIG_IsOK(ecode6)) {
5997  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5998  }
5999  arg6 = (PLINT)(val6);
6000  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6001  resultobj = SWIG_Py_Void();
6002  return resultobj;
6003 fail:
6004  return NULL;
6005 }
6006 
6007 
6008 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6009  PyObject *resultobj = 0;
6010  PLFLT arg1 ;
6011  PLFLT arg2 ;
6012  PLFLT arg3 ;
6013  PLFLT arg4 ;
6014  PLINT arg5 ;
6015  PLINT arg6 ;
6016  double val1 ;
6017  int ecode1 = 0 ;
6018  double val2 ;
6019  int ecode2 = 0 ;
6020  double val3 ;
6021  int ecode3 = 0 ;
6022  double val4 ;
6023  int ecode4 = 0 ;
6024  int val5 ;
6025  int ecode5 = 0 ;
6026  int val6 ;
6027  int ecode6 = 0 ;
6028  PyObject * obj0 = 0 ;
6029  PyObject * obj1 = 0 ;
6030  PyObject * obj2 = 0 ;
6031  PyObject * obj3 = 0 ;
6032  PyObject * obj4 = 0 ;
6033  PyObject * obj5 = 0 ;
6034 
6035  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6036  ecode1 = SWIG_AsVal_double(obj0, &val1);
6037  if (!SWIG_IsOK(ecode1)) {
6038  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6039  }
6040  arg1 = (PLFLT)(val1);
6041  ecode2 = SWIG_AsVal_double(obj1, &val2);
6042  if (!SWIG_IsOK(ecode2)) {
6043  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6044  }
6045  arg2 = (PLFLT)(val2);
6046  ecode3 = SWIG_AsVal_double(obj2, &val3);
6047  if (!SWIG_IsOK(ecode3)) {
6048  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6049  }
6050  arg3 = (PLFLT)(val3);
6051  ecode4 = SWIG_AsVal_double(obj3, &val4);
6052  if (!SWIG_IsOK(ecode4)) {
6053  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6054  }
6055  arg4 = (PLFLT)(val4);
6056  ecode5 = SWIG_AsVal_int(obj4, &val5);
6057  if (!SWIG_IsOK(ecode5)) {
6058  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6059  }
6060  arg5 = (PLINT)(val5);
6061  ecode6 = SWIG_AsVal_int(obj5, &val6);
6062  if (!SWIG_IsOK(ecode6)) {
6063  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6064  }
6065  arg6 = (PLINT)(val6);
6066  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6067  resultobj = SWIG_Py_Void();
6068  return resultobj;
6069 fail:
6070  return NULL;
6071 }
6072 
6073 
6074 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6075  PyObject *resultobj = 0;
6076 
6077  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6078  pleop();
6079  resultobj = SWIG_Py_Void();
6080  return resultobj;
6081 fail:
6082  return NULL;
6083 }
6084 
6085 
6086 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6087  PyObject *resultobj = 0;
6088  PLINT arg1 ;
6089  PLFLT *arg2 = (PLFLT *) 0 ;
6090  PLFLT *arg3 = (PLFLT *) 0 ;
6091  PLFLT *arg4 = (PLFLT *) 0 ;
6092  PyArrayObject *tmp1 = NULL ;
6093  PyArrayObject *tmp3 = NULL ;
6094  PyArrayObject *tmp4 = NULL ;
6095  PyObject * obj0 = 0 ;
6096  PyObject * obj1 = 0 ;
6097  PyObject * obj2 = 0 ;
6098 
6099  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6100  {
6101  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6102  if ( tmp1 == NULL )
6103  return NULL;
6104  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6105  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6106  }
6107  {
6108  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6109  if ( tmp3 == NULL )
6110  return NULL;
6111  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6112  {
6113  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6114  return NULL;
6115  }
6116  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6117  }
6118  {
6119  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6120  if ( tmp4 == NULL )
6121  return NULL;
6122  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6123  {
6124  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6125  return NULL;
6126  }
6127  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6128  }
6129  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6130  resultobj = SWIG_Py_Void();
6131  {
6132  Py_CLEAR( tmp1 );
6133  }
6134  {
6135  Py_CLEAR( tmp3 );
6136  }
6137  {
6138  Py_CLEAR( tmp4 );
6139  }
6140  return resultobj;
6141 fail:
6142  {
6143  Py_CLEAR( tmp1 );
6144  }
6145  {
6146  Py_CLEAR( tmp3 );
6147  }
6148  {
6149  Py_CLEAR( tmp4 );
6150  }
6151  return NULL;
6152 }
6153 
6154 
6155 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156  PyObject *resultobj = 0;
6157  PLINT arg1 ;
6158  PLFLT *arg2 = (PLFLT *) 0 ;
6159  PLFLT *arg3 = (PLFLT *) 0 ;
6160  PLFLT *arg4 = (PLFLT *) 0 ;
6161  PyArrayObject *tmp1 = NULL ;
6162  PyArrayObject *tmp3 = NULL ;
6163  PyArrayObject *tmp4 = NULL ;
6164  PyObject * obj0 = 0 ;
6165  PyObject * obj1 = 0 ;
6166  PyObject * obj2 = 0 ;
6167 
6168  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6169  {
6170  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6171  if ( tmp1 == NULL )
6172  return NULL;
6173  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6174  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6175  }
6176  {
6177  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6178  if ( tmp3 == NULL )
6179  return NULL;
6180  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6181  {
6182  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6183  return NULL;
6184  }
6185  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6186  }
6187  {
6188  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6189  if ( tmp4 == NULL )
6190  return NULL;
6191  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6192  {
6193  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6194  return NULL;
6195  }
6196  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6197  }
6198  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6199  resultobj = SWIG_Py_Void();
6200  {
6201  Py_CLEAR( tmp1 );
6202  }
6203  {
6204  Py_CLEAR( tmp3 );
6205  }
6206  {
6207  Py_CLEAR( tmp4 );
6208  }
6209  return resultobj;
6210 fail:
6211  {
6212  Py_CLEAR( tmp1 );
6213  }
6214  {
6215  Py_CLEAR( tmp3 );
6216  }
6217  {
6218  Py_CLEAR( tmp4 );
6219  }
6220  return NULL;
6221 }
6222 
6223 
6224 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6225  PyObject *resultobj = 0;
6226 
6227  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6228  plfamadv();
6229  resultobj = SWIG_Py_Void();
6230  return resultobj;
6231 fail:
6232  return NULL;
6233 }
6234 
6235 
6236 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6237  PyObject *resultobj = 0;
6238  PLINT arg1 ;
6239  PLFLT *arg2 = (PLFLT *) 0 ;
6240  PLFLT *arg3 = (PLFLT *) 0 ;
6241  PyArrayObject *tmp1 = NULL ;
6242  PyArrayObject *tmp3 = NULL ;
6243  PyObject * obj0 = 0 ;
6244  PyObject * obj1 = 0 ;
6245 
6246  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6247  {
6248  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6249  if ( tmp1 == NULL )
6250  return NULL;
6251  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6252  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6253  }
6254  {
6255  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6256  if ( tmp3 == NULL )
6257  return NULL;
6258  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6259  {
6260  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6261  return NULL;
6262  }
6263  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6264  }
6265  plfill(arg1,(double const *)arg2,(double const *)arg3);
6266  resultobj = SWIG_Py_Void();
6267  {
6268  Py_CLEAR( tmp1 );
6269  }
6270  {
6271  Py_CLEAR( tmp3 );
6272  }
6273  return resultobj;
6274 fail:
6275  {
6276  Py_CLEAR( tmp1 );
6277  }
6278  {
6279  Py_CLEAR( tmp3 );
6280  }
6281  return NULL;
6282 }
6283 
6284 
6285 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6286  PyObject *resultobj = 0;
6287  PLINT arg1 ;
6288  PLFLT *arg2 = (PLFLT *) 0 ;
6289  PLFLT *arg3 = (PLFLT *) 0 ;
6290  PLFLT *arg4 = (PLFLT *) 0 ;
6291  PyArrayObject *tmp1 = NULL ;
6292  PyArrayObject *tmp3 = NULL ;
6293  PyArrayObject *tmp4 = NULL ;
6294  PyObject * obj0 = 0 ;
6295  PyObject * obj1 = 0 ;
6296  PyObject * obj2 = 0 ;
6297 
6298  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6299  {
6300  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6301  if ( tmp1 == NULL )
6302  return NULL;
6303  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6304  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6305  }
6306  {
6307  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6308  if ( tmp3 == NULL )
6309  return NULL;
6310  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6311  {
6312  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6313  return NULL;
6314  }
6315  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6316  }
6317  {
6318  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6319  if ( tmp4 == NULL )
6320  return NULL;
6321  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6322  {
6323  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6324  return NULL;
6325  }
6326  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6327  }
6328  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6329  resultobj = SWIG_Py_Void();
6330  {
6331  Py_CLEAR( tmp1 );
6332  }
6333  {
6334  Py_CLEAR( tmp3 );
6335  }
6336  {
6337  Py_CLEAR( tmp4 );
6338  }
6339  return resultobj;
6340 fail:
6341  {
6342  Py_CLEAR( tmp1 );
6343  }
6344  {
6345  Py_CLEAR( tmp3 );
6346  }
6347  {
6348  Py_CLEAR( tmp4 );
6349  }
6350  return NULL;
6351 }
6352 
6353 
6354 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6355  PyObject *resultobj = 0;
6356  PLINT arg1 ;
6357  PLFLT *arg2 = (PLFLT *) 0 ;
6358  PLFLT *arg3 = (PLFLT *) 0 ;
6359  PLFLT arg4 ;
6360  PyArrayObject *tmp1 = NULL ;
6361  PyArrayObject *tmp3 = NULL ;
6362  double val4 ;
6363  int ecode4 = 0 ;
6364  PyObject * obj0 = 0 ;
6365  PyObject * obj1 = 0 ;
6366  PyObject * obj2 = 0 ;
6367 
6368  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6369  {
6370  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6371  if ( tmp1 == NULL )
6372  return NULL;
6373  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6374  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6375  }
6376  {
6377  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6378  if ( tmp3 == NULL )
6379  return NULL;
6380  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6381  {
6382  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6383  return NULL;
6384  }
6385  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6386  }
6387  ecode4 = SWIG_AsVal_double(obj2, &val4);
6388  if (!SWIG_IsOK(ecode4)) {
6389  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6390  }
6391  arg4 = (PLFLT)(val4);
6392  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6393  resultobj = SWIG_Py_Void();
6394  {
6395  Py_CLEAR( tmp1 );
6396  }
6397  {
6398  Py_CLEAR( tmp3 );
6399  }
6400  return resultobj;
6401 fail:
6402  {
6403  Py_CLEAR( tmp1 );
6404  }
6405  {
6406  Py_CLEAR( tmp3 );
6407  }
6408  return NULL;
6409 }
6410 
6411 
6412 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6413  PyObject *resultobj = 0;
6414 
6415  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6416  plflush();
6417  resultobj = SWIG_Py_Void();
6418  return resultobj;
6419 fail:
6420  return NULL;
6421 }
6422 
6423 
6424 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425  PyObject *resultobj = 0;
6426  PLINT arg1 ;
6427  int val1 ;
6428  int ecode1 = 0 ;
6429  PyObject * obj0 = 0 ;
6430 
6431  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6432  ecode1 = SWIG_AsVal_int(obj0, &val1);
6433  if (!SWIG_IsOK(ecode1)) {
6434  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6435  }
6436  arg1 = (PLINT)(val1);
6437  plfont(arg1);
6438  resultobj = SWIG_Py_Void();
6439  return resultobj;
6440 fail:
6441  return NULL;
6442 }
6443 
6444 
6445 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6446  PyObject *resultobj = 0;
6447  PLINT arg1 ;
6448  int val1 ;
6449  int ecode1 = 0 ;
6450  PyObject * obj0 = 0 ;
6451 
6452  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6453  ecode1 = SWIG_AsVal_int(obj0, &val1);
6454  if (!SWIG_IsOK(ecode1)) {
6455  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6456  }
6457  arg1 = (PLINT)(val1);
6458  plfontld(arg1);
6459  resultobj = SWIG_Py_Void();
6460  return resultobj;
6461 fail:
6462  return NULL;
6463 }
6464 
6465 
6466 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6467  PyObject *resultobj = 0;
6468  PLFLT *arg1 = (PLFLT *) 0 ;
6469  PLFLT *arg2 = (PLFLT *) 0 ;
6470  PLFLT temp1 ;
6471  int res1 = SWIG_TMPOBJ ;
6472  PLFLT temp2 ;
6473  int res2 = SWIG_TMPOBJ ;
6474 
6475  arg1 = &temp1;
6476  arg2 = &temp2;
6477  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6478  plgchr(arg1,arg2);
6479  resultobj = SWIG_Py_Void();
6480  if (SWIG_IsTmpObj(res1)) {
6481  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6482  } else {
6483  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6484  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6485  }
6486  if (SWIG_IsTmpObj(res2)) {
6487  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6488  } else {
6489  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6490  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6491  }
6492  return resultobj;
6493 fail:
6494  return NULL;
6495 }
6496 
6497 
6498 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6499  PyObject *resultobj = 0;
6500  PLINT arg1 ;
6501  PLINT *arg2 = (PLINT *) 0 ;
6502  PLINT *arg3 = (PLINT *) 0 ;
6503  PLINT *arg4 = (PLINT *) 0 ;
6504  int val1 ;
6505  int ecode1 = 0 ;
6506  PLINT temp2 ;
6507  int res2 = SWIG_TMPOBJ ;
6508  PLINT temp3 ;
6509  int res3 = SWIG_TMPOBJ ;
6510  PLINT temp4 ;
6511  int res4 = SWIG_TMPOBJ ;
6512  PyObject * obj0 = 0 ;
6513 
6514  arg2 = &temp2;
6515  arg3 = &temp3;
6516  arg4 = &temp4;
6517  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6518  ecode1 = SWIG_AsVal_int(obj0, &val1);
6519  if (!SWIG_IsOK(ecode1)) {
6520  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6521  }
6522  arg1 = (PLINT)(val1);
6523  plgcol0(arg1,arg2,arg3,arg4);
6524  resultobj = SWIG_Py_Void();
6525  if (SWIG_IsTmpObj(res2)) {
6526  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6527  } else {
6528  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6529  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6530  }
6531  if (SWIG_IsTmpObj(res3)) {
6532  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6533  } else {
6534  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6535  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6536  }
6537  if (SWIG_IsTmpObj(res4)) {
6538  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6539  } else {
6540  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6541  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6542  }
6543  return resultobj;
6544 fail:
6545  return NULL;
6546 }
6547 
6548 
6549 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6550  PyObject *resultobj = 0;
6551  PLINT arg1 ;
6552  PLINT *arg2 = (PLINT *) 0 ;
6553  PLINT *arg3 = (PLINT *) 0 ;
6554  PLINT *arg4 = (PLINT *) 0 ;
6555  PLFLT *arg5 = (PLFLT *) 0 ;
6556  int val1 ;
6557  int ecode1 = 0 ;
6558  PLINT temp2 ;
6559  int res2 = SWIG_TMPOBJ ;
6560  PLINT temp3 ;
6561  int res3 = SWIG_TMPOBJ ;
6562  PLINT temp4 ;
6563  int res4 = SWIG_TMPOBJ ;
6564  PLFLT temp5 ;
6565  int res5 = SWIG_TMPOBJ ;
6566  PyObject * obj0 = 0 ;
6567 
6568  arg2 = &temp2;
6569  arg3 = &temp3;
6570  arg4 = &temp4;
6571  arg5 = &temp5;
6572  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6573  ecode1 = SWIG_AsVal_int(obj0, &val1);
6574  if (!SWIG_IsOK(ecode1)) {
6575  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6576  }
6577  arg1 = (PLINT)(val1);
6578  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6579  resultobj = SWIG_Py_Void();
6580  if (SWIG_IsTmpObj(res2)) {
6581  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6582  } else {
6583  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6584  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6585  }
6586  if (SWIG_IsTmpObj(res3)) {
6587  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6588  } else {
6589  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6590  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6591  }
6592  if (SWIG_IsTmpObj(res4)) {
6593  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6594  } else {
6595  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6596  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6597  }
6598  if (SWIG_IsTmpObj(res5)) {
6599  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6600  } else {
6601  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6602  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6603  }
6604  return resultobj;
6605 fail:
6606  return NULL;
6607 }
6608 
6609 
6610 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6611  PyObject *resultobj = 0;
6612  PLINT *arg1 = (PLINT *) 0 ;
6613  PLINT *arg2 = (PLINT *) 0 ;
6614  PLINT *arg3 = (PLINT *) 0 ;
6615  PLINT temp1 ;
6616  int res1 = SWIG_TMPOBJ ;
6617  PLINT temp2 ;
6618  int res2 = SWIG_TMPOBJ ;
6619  PLINT temp3 ;
6620  int res3 = SWIG_TMPOBJ ;
6621 
6622  arg1 = &temp1;
6623  arg2 = &temp2;
6624  arg3 = &temp3;
6625  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6626  plgcolbg(arg1,arg2,arg3);
6627  resultobj = SWIG_Py_Void();
6628  if (SWIG_IsTmpObj(res1)) {
6629  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6630  } else {
6631  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6632  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6633  }
6634  if (SWIG_IsTmpObj(res2)) {
6635  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6636  } else {
6637  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6638  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6639  }
6640  if (SWIG_IsTmpObj(res3)) {
6641  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6642  } else {
6643  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6644  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6645  }
6646  return resultobj;
6647 fail:
6648  return NULL;
6649 }
6650 
6651 
6652 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6653  PyObject *resultobj = 0;
6654  PLINT *arg1 = (PLINT *) 0 ;
6655  PLINT *arg2 = (PLINT *) 0 ;
6656  PLINT *arg3 = (PLINT *) 0 ;
6657  PLFLT *arg4 = (PLFLT *) 0 ;
6658  PLINT temp1 ;
6659  int res1 = SWIG_TMPOBJ ;
6660  PLINT temp2 ;
6661  int res2 = SWIG_TMPOBJ ;
6662  PLINT temp3 ;
6663  int res3 = SWIG_TMPOBJ ;
6664  PLFLT temp4 ;
6665  int res4 = SWIG_TMPOBJ ;
6666 
6667  arg1 = &temp1;
6668  arg2 = &temp2;
6669  arg3 = &temp3;
6670  arg4 = &temp4;
6671  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6672  plgcolbga(arg1,arg2,arg3,arg4);
6673  resultobj = SWIG_Py_Void();
6674  if (SWIG_IsTmpObj(res1)) {
6675  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6676  } else {
6677  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6678  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6679  }
6680  if (SWIG_IsTmpObj(res2)) {
6681  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6682  } else {
6683  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6684  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6685  }
6686  if (SWIG_IsTmpObj(res3)) {
6687  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6688  } else {
6689  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6690  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6691  }
6692  if (SWIG_IsTmpObj(res4)) {
6693  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6694  } else {
6695  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6696  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6697  }
6698  return resultobj;
6699 fail:
6700  return NULL;
6701 }
6702 
6703 
6704 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6705  PyObject *resultobj = 0;
6706  PLINT *arg1 = (PLINT *) 0 ;
6707  PLINT temp1 ;
6708  int res1 = SWIG_TMPOBJ ;
6709 
6710  arg1 = &temp1;
6711  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6712  plgcompression(arg1);
6713  resultobj = SWIG_Py_Void();
6714  if (SWIG_IsTmpObj(res1)) {
6715  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6716  } else {
6717  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6718  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6719  }
6720  return resultobj;
6721 fail:
6722  return NULL;
6723 }
6724 
6725 
6726 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6727  PyObject *resultobj = 0;
6728  char *arg1 = (char *) 0 ;
6729  char buff1[1000] ;
6730 
6731  {
6732  arg1 = buff1;
6733  }
6734  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6735  plgdev(arg1);
6736  resultobj = SWIG_Py_Void();
6737  {
6738  PyObject *o = PyString_FromString( arg1 );
6739  resultobj = t_output_helper( resultobj, o );
6740  }
6741  return resultobj;
6742 fail:
6743  return NULL;
6744 }
6745 
6746 
6747 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6748  PyObject *resultobj = 0;
6749  PLFLT *arg1 = (PLFLT *) 0 ;
6750  PLFLT *arg2 = (PLFLT *) 0 ;
6751  PLFLT *arg3 = (PLFLT *) 0 ;
6752  PLFLT *arg4 = (PLFLT *) 0 ;
6753  PLFLT temp1 ;
6754  int res1 = SWIG_TMPOBJ ;
6755  PLFLT temp2 ;
6756  int res2 = SWIG_TMPOBJ ;
6757  PLFLT temp3 ;
6758  int res3 = SWIG_TMPOBJ ;
6759  PLFLT temp4 ;
6760  int res4 = SWIG_TMPOBJ ;
6761 
6762  arg1 = &temp1;
6763  arg2 = &temp2;
6764  arg3 = &temp3;
6765  arg4 = &temp4;
6766  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6767  plgdidev(arg1,arg2,arg3,arg4);
6768  resultobj = SWIG_Py_Void();
6769  if (SWIG_IsTmpObj(res1)) {
6770  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6771  } else {
6772  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6773  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6774  }
6775  if (SWIG_IsTmpObj(res2)) {
6776  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6777  } else {
6778  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6779  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6780  }
6781  if (SWIG_IsTmpObj(res3)) {
6782  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6783  } else {
6784  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6785  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6786  }
6787  if (SWIG_IsTmpObj(res4)) {
6788  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6789  } else {
6790  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6792  }
6793  return resultobj;
6794 fail:
6795  return NULL;
6796 }
6797 
6798 
6799 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6800  PyObject *resultobj = 0;
6801  PLFLT *arg1 = (PLFLT *) 0 ;
6802  PLFLT temp1 ;
6803  int res1 = SWIG_TMPOBJ ;
6804 
6805  arg1 = &temp1;
6806  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6807  plgdiori(arg1);
6808  resultobj = SWIG_Py_Void();
6809  if (SWIG_IsTmpObj(res1)) {
6810  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6811  } else {
6812  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6813  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6814  }
6815  return resultobj;
6816 fail:
6817  return NULL;
6818 }
6819 
6820 
6821 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822  PyObject *resultobj = 0;
6823  PLFLT *arg1 = (PLFLT *) 0 ;
6824  PLFLT *arg2 = (PLFLT *) 0 ;
6825  PLFLT *arg3 = (PLFLT *) 0 ;
6826  PLFLT *arg4 = (PLFLT *) 0 ;
6827  PLFLT temp1 ;
6828  int res1 = SWIG_TMPOBJ ;
6829  PLFLT temp2 ;
6830  int res2 = SWIG_TMPOBJ ;
6831  PLFLT temp3 ;
6832  int res3 = SWIG_TMPOBJ ;
6833  PLFLT temp4 ;
6834  int res4 = SWIG_TMPOBJ ;
6835 
6836  arg1 = &temp1;
6837  arg2 = &temp2;
6838  arg3 = &temp3;
6839  arg4 = &temp4;
6840  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6841  plgdiplt(arg1,arg2,arg3,arg4);
6842  resultobj = SWIG_Py_Void();
6843  if (SWIG_IsTmpObj(res1)) {
6844  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6845  } else {
6846  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6847  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6848  }
6849  if (SWIG_IsTmpObj(res2)) {
6850  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6851  } else {
6852  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6854  }
6855  if (SWIG_IsTmpObj(res3)) {
6856  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6857  } else {
6858  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6859  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6860  }
6861  if (SWIG_IsTmpObj(res4)) {
6862  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6863  } else {
6864  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6865  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6866  }
6867  return resultobj;
6868 fail:
6869  return NULL;
6870 }
6871 
6872 
6873 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6874  PyObject *resultobj = 0;
6875  PLINT *arg1 = (PLINT *) 0 ;
6876  PLINT *arg2 = (PLINT *) 0 ;
6877  PLINT *arg3 = (PLINT *) 0 ;
6878  PLINT temp1 ;
6879  int res1 = SWIG_TMPOBJ ;
6880  PLINT temp2 ;
6881  int res2 = SWIG_TMPOBJ ;
6882  PLINT temp3 ;
6883  int res3 = SWIG_TMPOBJ ;
6884 
6885  arg1 = &temp1;
6886  arg2 = &temp2;
6887  arg3 = &temp3;
6888  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
6889  plgfam(arg1,arg2,arg3);
6890  resultobj = SWIG_Py_Void();
6891  if (SWIG_IsTmpObj(res1)) {
6892  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6893  } else {
6894  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6895  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6896  }
6897  if (SWIG_IsTmpObj(res2)) {
6898  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6899  } else {
6900  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6901  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6902  }
6903  if (SWIG_IsTmpObj(res3)) {
6904  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6905  } else {
6906  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6907  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6908  }
6909  return resultobj;
6910 fail:
6911  return NULL;
6912 }
6913 
6914 
6915 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6916  PyObject *resultobj = 0;
6917  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6918  PLUNICODE temp1 ;
6919  int res1 = SWIG_TMPOBJ ;
6920 
6921  arg1 = &temp1;
6922  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
6923  plgfci(arg1);
6924  resultobj = SWIG_Py_Void();
6925  if (SWIG_IsTmpObj(res1)) {
6926  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6927  } else {
6928  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6929  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6930  }
6931  return resultobj;
6932 fail:
6933  return NULL;
6934 }
6935 
6936 
6937 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6938  PyObject *resultobj = 0;
6939  char *arg1 = (char *) 0 ;
6940  char buff1[1000] ;
6941 
6942  {
6943  arg1 = buff1;
6944  }
6945  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
6946  plgfnam(arg1);
6947  resultobj = SWIG_Py_Void();
6948  {
6949  PyObject *o = PyString_FromString( arg1 );
6950  resultobj = t_output_helper( resultobj, o );
6951  }
6952  return resultobj;
6953 fail:
6954  return NULL;
6955 }
6956 
6957 
6958 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6959  PyObject *resultobj = 0;
6960  PLINT *arg1 = (PLINT *) 0 ;
6961  PLINT *arg2 = (PLINT *) 0 ;
6962  PLINT *arg3 = (PLINT *) 0 ;
6963  PLINT temp1 ;
6964  int res1 = SWIG_TMPOBJ ;
6965  PLINT temp2 ;
6966  int res2 = SWIG_TMPOBJ ;
6967  PLINT temp3 ;
6968  int res3 = SWIG_TMPOBJ ;
6969 
6970  arg1 = &temp1;
6971  arg2 = &temp2;
6972  arg3 = &temp3;
6973  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
6974  plgfont(arg1,arg2,arg3);
6975  resultobj = SWIG_Py_Void();
6976  if (SWIG_IsTmpObj(res1)) {
6977  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6978  } else {
6979  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6980  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6981  }
6982  if (SWIG_IsTmpObj(res2)) {
6983  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6984  } else {
6985  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6986  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6987  }
6988  if (SWIG_IsTmpObj(res3)) {
6989  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6990  } else {
6991  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6992  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6993  }
6994  return resultobj;
6995 fail:
6996  return NULL;
6997 }
6998 
6999 
7000 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7001  PyObject *resultobj = 0;
7002  PLINT *arg1 = (PLINT *) 0 ;
7003  PLINT temp1 ;
7004  int res1 = SWIG_TMPOBJ ;
7005 
7006  arg1 = &temp1;
7007  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7008  plglevel(arg1);
7009  resultobj = SWIG_Py_Void();
7010  if (SWIG_IsTmpObj(res1)) {
7011  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7012  } else {
7013  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7015  }
7016  return resultobj;
7017 fail:
7018  return NULL;
7019 }
7020 
7021 
7022 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7023  PyObject *resultobj = 0;
7024  PLFLT *arg1 = (PLFLT *) 0 ;
7025  PLFLT *arg2 = (PLFLT *) 0 ;
7026  PLINT *arg3 = (PLINT *) 0 ;
7027  PLINT *arg4 = (PLINT *) 0 ;
7028  PLINT *arg5 = (PLINT *) 0 ;
7029  PLINT *arg6 = (PLINT *) 0 ;
7030  PLFLT temp1 ;
7031  int res1 = SWIG_TMPOBJ ;
7032  PLFLT temp2 ;
7033  int res2 = SWIG_TMPOBJ ;
7034  PLINT temp3 ;
7035  int res3 = SWIG_TMPOBJ ;
7036  PLINT temp4 ;
7037  int res4 = SWIG_TMPOBJ ;
7038  PLINT temp5 ;
7039  int res5 = SWIG_TMPOBJ ;
7040  PLINT temp6 ;
7041  int res6 = SWIG_TMPOBJ ;
7042 
7043  arg1 = &temp1;
7044  arg2 = &temp2;
7045  arg3 = &temp3;
7046  arg4 = &temp4;
7047  arg5 = &temp5;
7048  arg6 = &temp6;
7049  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7050  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7051  resultobj = SWIG_Py_Void();
7052  if (SWIG_IsTmpObj(res1)) {
7053  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7054  } else {
7055  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7056  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7057  }
7058  if (SWIG_IsTmpObj(res2)) {
7059  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7060  } else {
7061  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7062  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7063  }
7064  if (SWIG_IsTmpObj(res3)) {
7065  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7066  } else {
7067  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7068  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7069  }
7070  if (SWIG_IsTmpObj(res4)) {
7071  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7072  } else {
7073  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7074  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7075  }
7076  if (SWIG_IsTmpObj(res5)) {
7077  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7078  } else {
7079  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7080  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7081  }
7082  if (SWIG_IsTmpObj(res6)) {
7083  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7084  } else {
7085  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7086  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7087  }
7088  return resultobj;
7089 fail:
7090  return NULL;
7091 }
7092 
7093 
7094 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7095  PyObject *resultobj = 0;
7096 
7097  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7098  plgra();
7099  resultobj = SWIG_Py_Void();
7100  return resultobj;
7101 fail:
7102  return NULL;
7103 }
7104 
7105 
7106 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107  PyObject *resultobj = 0;
7108  PLFLT *arg1 = (PLFLT *) 0 ;
7109  PLFLT *arg2 = (PLFLT *) 0 ;
7110  PLFLT *arg3 = (PLFLT *) 0 ;
7111  PLINT arg4 ;
7112  PLFLT *arg5 = (PLFLT *) 0 ;
7113  PLINT arg6 ;
7114  PLFLT *arg7 = (PLFLT *) 0 ;
7115  PLINT arg8 ;
7116  PLFLT **arg9 = (PLFLT **) 0 ;
7117  PLINT arg10 ;
7118  PLFLT arg11 ;
7119  PyArrayObject *tmp1 = NULL ;
7120  PyArrayObject *tmp2 = NULL ;
7121  PyArrayObject *tmp3 = NULL ;
7122  PyArrayObject *tmp5 = NULL ;
7123  PyArrayObject *tmp7 = NULL ;
7124  PyObject *array7 = NULL ;
7125  int val10 ;
7126  int ecode10 = 0 ;
7127  double val11 ;
7128  int ecode11 = 0 ;
7129  PyObject * obj0 = 0 ;
7130  PyObject * obj1 = 0 ;
7131  PyObject * obj2 = 0 ;
7132  PyObject * obj3 = 0 ;
7133  PyObject * obj4 = 0 ;
7134  PyObject * obj5 = 0 ;
7135  PyObject * obj6 = 0 ;
7136 
7137  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7138  {
7139  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7140  if ( tmp1 == NULL )
7141  return NULL;
7142  Alen = PyArray_DIMS( tmp1 )[0];
7143  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7144  }
7145  {
7146  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7147  if ( tmp2 == NULL )
7148  return NULL;
7149  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7150  {
7151  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7152  return NULL;
7153  }
7154  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7155  }
7156  {
7157  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7158  if ( tmp3 == NULL )
7159  return NULL;
7160  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7161  {
7162  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7163  return NULL;
7164  }
7165  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7166  arg4 = PyArray_DIMS( tmp3 )[0];
7167  }
7168  {
7169  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7170  if ( tmp5 == NULL )
7171  return NULL;
7172  Xlen = PyArray_DIMS( tmp5 )[0];
7173  arg6 = Xlen;
7174  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7175  }
7176  {
7177  int i, size;
7178  npy_intp dims[2];
7179  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7180  if ( tmp7 == NULL )
7181  return NULL;
7182  Ylen = PyArray_DIMS( tmp7 )[0];
7183  arg8 = Ylen;
7184  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7185  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7186  // list and this ArrayY.
7187  dims[0] = Xlen;
7188  dims[1] = Ylen;
7189  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7190  if ( !array7 )
7191  return NULL;
7192  size = Ylen;
7193  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7194  for ( i = 0; i < Xlen; i++ )
7195  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7196  }
7197  ecode10 = SWIG_AsVal_int(obj5, &val10);
7198  if (!SWIG_IsOK(ecode10)) {
7199  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7200  }
7201  arg10 = (PLINT)(val10);
7202  ecode11 = SWIG_AsVal_double(obj6, &val11);
7203  if (!SWIG_IsOK(ecode11)) {
7204  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7205  }
7206  arg11 = (PLFLT)(val11);
7207  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7208  resultobj = SWIG_Py_Void();
7209  {
7210  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7211  }
7212  {
7213  Py_CLEAR( tmp1 );
7214  }
7215  {
7216  Py_CLEAR( tmp2 );
7217  }
7218  {
7219  Py_CLEAR( tmp3 );
7220  }
7221  {
7222  Py_CLEAR( tmp5 );
7223  }
7224  {
7225  Py_CLEAR( tmp7 );
7226  free( arg9 );
7227  }
7228  return resultobj;
7229 fail:
7230  {
7231  Py_CLEAR( tmp1 );
7232  }
7233  {
7234  Py_CLEAR( tmp2 );
7235  }
7236  {
7237  Py_CLEAR( tmp3 );
7238  }
7239  {
7240  Py_CLEAR( tmp5 );
7241  }
7242  {
7243  Py_CLEAR( tmp7 );
7244  free( arg9 );
7245  }
7246  return NULL;
7247 }
7248 
7249 
7250 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251  PyObject *resultobj = 0;
7252  PLFLT *arg1 = (PLFLT *) 0 ;
7253  PLFLT *arg2 = (PLFLT *) 0 ;
7254  PLFLT *arg3 = (PLFLT *) 0 ;
7255  PLFLT *arg4 = (PLFLT *) 0 ;
7256  PLFLT temp1 ;
7257  int res1 = SWIG_TMPOBJ ;
7258  PLFLT temp2 ;
7259  int res2 = SWIG_TMPOBJ ;
7260  PLFLT temp3 ;
7261  int res3 = SWIG_TMPOBJ ;
7262  PLFLT temp4 ;
7263  int res4 = SWIG_TMPOBJ ;
7264 
7265  arg1 = &temp1;
7266  arg2 = &temp2;
7267  arg3 = &temp3;
7268  arg4 = &temp4;
7269  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7270  plgspa(arg1,arg2,arg3,arg4);
7271  resultobj = SWIG_Py_Void();
7272  if (SWIG_IsTmpObj(res1)) {
7273  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7274  } else {
7275  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7276  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7277  }
7278  if (SWIG_IsTmpObj(res2)) {
7279  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7280  } else {
7281  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7282  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7283  }
7284  if (SWIG_IsTmpObj(res3)) {
7285  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7286  } else {
7287  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7288  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7289  }
7290  if (SWIG_IsTmpObj(res4)) {
7291  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7292  } else {
7293  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7294  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7295  }
7296  return resultobj;
7297 fail:
7298  return NULL;
7299 }
7300 
7301 
7302 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7303  PyObject *resultobj = 0;
7304  PLINT *arg1 = (PLINT *) 0 ;
7305  PLINT temp1 ;
7306  int res1 = SWIG_TMPOBJ ;
7307 
7308  arg1 = &temp1;
7309  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7310  plgstrm(arg1);
7311  resultobj = SWIG_Py_Void();
7312  if (SWIG_IsTmpObj(res1)) {
7313  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7314  } else {
7315  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7316  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7317  }
7318  return resultobj;
7319 fail:
7320  return NULL;
7321 }
7322 
7323 
7324 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7325  PyObject *resultobj = 0;
7326  char *arg1 = (char *) 0 ;
7327  char buff1[1000] ;
7328 
7329  {
7330  arg1 = buff1;
7331  }
7332  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7333  plgver(arg1);
7334  resultobj = SWIG_Py_Void();
7335  {
7336  PyObject *o = PyString_FromString( arg1 );
7337  resultobj = t_output_helper( resultobj, o );
7338  }
7339  return resultobj;
7340 fail:
7341  return NULL;
7342 }
7343 
7344 
7345 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7346  PyObject *resultobj = 0;
7347  PLFLT *arg1 = (PLFLT *) 0 ;
7348  PLFLT *arg2 = (PLFLT *) 0 ;
7349  PLFLT *arg3 = (PLFLT *) 0 ;
7350  PLFLT *arg4 = (PLFLT *) 0 ;
7351  PLFLT temp1 ;
7352  int res1 = SWIG_TMPOBJ ;
7353  PLFLT temp2 ;
7354  int res2 = SWIG_TMPOBJ ;
7355  PLFLT temp3 ;
7356  int res3 = SWIG_TMPOBJ ;
7357  PLFLT temp4 ;
7358  int res4 = SWIG_TMPOBJ ;
7359 
7360  arg1 = &temp1;
7361  arg2 = &temp2;
7362  arg3 = &temp3;
7363  arg4 = &temp4;
7364  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7365  plgvpd(arg1,arg2,arg3,arg4);
7366  resultobj = SWIG_Py_Void();
7367  if (SWIG_IsTmpObj(res1)) {
7368  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7369  } else {
7370  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7371  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7372  }
7373  if (SWIG_IsTmpObj(res2)) {
7374  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7375  } else {
7376  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7377  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7378  }
7379  if (SWIG_IsTmpObj(res3)) {
7380  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7381  } else {
7382  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7383  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7384  }
7385  if (SWIG_IsTmpObj(res4)) {
7386  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7387  } else {
7388  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7390  }
7391  return resultobj;
7392 fail:
7393  return NULL;
7394 }
7395 
7396 
7397 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7398  PyObject *resultobj = 0;
7399  PLFLT *arg1 = (PLFLT *) 0 ;
7400  PLFLT *arg2 = (PLFLT *) 0 ;
7401  PLFLT *arg3 = (PLFLT *) 0 ;
7402  PLFLT *arg4 = (PLFLT *) 0 ;
7403  PLFLT temp1 ;
7404  int res1 = SWIG_TMPOBJ ;
7405  PLFLT temp2 ;
7406  int res2 = SWIG_TMPOBJ ;
7407  PLFLT temp3 ;
7408  int res3 = SWIG_TMPOBJ ;
7409  PLFLT temp4 ;
7410  int res4 = SWIG_TMPOBJ ;
7411 
7412  arg1 = &temp1;
7413  arg2 = &temp2;
7414  arg3 = &temp3;
7415  arg4 = &temp4;
7416  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7417  plgvpw(arg1,arg2,arg3,arg4);
7418  resultobj = SWIG_Py_Void();
7419  if (SWIG_IsTmpObj(res1)) {
7420  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7421  } else {
7422  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7423  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7424  }
7425  if (SWIG_IsTmpObj(res2)) {
7426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7427  } else {
7428  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7430  }
7431  if (SWIG_IsTmpObj(res3)) {
7432  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7433  } else {
7434  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7435  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7436  }
7437  if (SWIG_IsTmpObj(res4)) {
7438  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7439  } else {
7440  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7441  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7442  }
7443  return resultobj;
7444 fail:
7445  return NULL;
7446 }
7447 
7448 
7449 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7450  PyObject *resultobj = 0;
7451  PLINT *arg1 = (PLINT *) 0 ;
7452  PLINT *arg2 = (PLINT *) 0 ;
7453  PLINT temp1 ;
7454  int res1 = SWIG_TMPOBJ ;
7455  PLINT temp2 ;
7456  int res2 = SWIG_TMPOBJ ;
7457 
7458  arg1 = &temp1;
7459  arg2 = &temp2;
7460  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7461  plgxax(arg1,arg2);
7462  resultobj = SWIG_Py_Void();
7463  if (SWIG_IsTmpObj(res1)) {
7464  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7465  } else {
7466  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7467  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7468  }
7469  if (SWIG_IsTmpObj(res2)) {
7470  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7471  } else {
7472  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7473  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7474  }
7475  return resultobj;
7476 fail:
7477  return NULL;
7478 }
7479 
7480 
7481 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7482  PyObject *resultobj = 0;
7483  PLINT *arg1 = (PLINT *) 0 ;
7484  PLINT *arg2 = (PLINT *) 0 ;
7485  PLINT temp1 ;
7486  int res1 = SWIG_TMPOBJ ;
7487  PLINT temp2 ;
7488  int res2 = SWIG_TMPOBJ ;
7489 
7490  arg1 = &temp1;
7491  arg2 = &temp2;
7492  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7493  plgyax(arg1,arg2);
7494  resultobj = SWIG_Py_Void();
7495  if (SWIG_IsTmpObj(res1)) {
7496  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7497  } else {
7498  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7499  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7500  }
7501  if (SWIG_IsTmpObj(res2)) {
7502  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7503  } else {
7504  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7505  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7506  }
7507  return resultobj;
7508 fail:
7509  return NULL;
7510 }
7511 
7512 
7513 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7514  PyObject *resultobj = 0;
7515  PLINT *arg1 = (PLINT *) 0 ;
7516  PLINT *arg2 = (PLINT *) 0 ;
7517  PLINT temp1 ;
7518  int res1 = SWIG_TMPOBJ ;
7519  PLINT temp2 ;
7520  int res2 = SWIG_TMPOBJ ;
7521 
7522  arg1 = &temp1;
7523  arg2 = &temp2;
7524  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7525  plgzax(arg1,arg2);
7526  resultobj = SWIG_Py_Void();
7527  if (SWIG_IsTmpObj(res1)) {
7528  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7529  } else {
7530  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7531  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7532  }
7533  if (SWIG_IsTmpObj(res2)) {
7534  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7535  } else {
7536  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7537  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7538  }
7539  return resultobj;
7540 fail:
7541  return NULL;
7542 }
7543 
7544 
7545 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7546  PyObject *resultobj = 0;
7547  PLINT arg1 ;
7548  PLFLT *arg2 = (PLFLT *) 0 ;
7549  PLFLT arg3 ;
7550  PLFLT arg4 ;
7551  PLINT arg5 ;
7552  PLINT arg6 ;
7553  PyArrayObject *tmp1 = NULL ;
7554  double val3 ;
7555  int ecode3 = 0 ;
7556  double val4 ;
7557  int ecode4 = 0 ;
7558  int val5 ;
7559  int ecode5 = 0 ;
7560  int val6 ;
7561  int ecode6 = 0 ;
7562  PyObject * obj0 = 0 ;
7563  PyObject * obj1 = 0 ;
7564  PyObject * obj2 = 0 ;
7565  PyObject * obj3 = 0 ;
7566  PyObject * obj4 = 0 ;
7567 
7568  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7569  {
7570  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7571  if ( tmp1 == NULL )
7572  return NULL;
7573  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7574  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7575  }
7576  ecode3 = SWIG_AsVal_double(obj1, &val3);
7577  if (!SWIG_IsOK(ecode3)) {
7578  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7579  }
7580  arg3 = (PLFLT)(val3);
7581  ecode4 = SWIG_AsVal_double(obj2, &val4);
7582  if (!SWIG_IsOK(ecode4)) {
7583  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7584  }
7585  arg4 = (PLFLT)(val4);
7586  ecode5 = SWIG_AsVal_int(obj3, &val5);
7587  if (!SWIG_IsOK(ecode5)) {
7588  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7589  }
7590  arg5 = (PLINT)(val5);
7591  ecode6 = SWIG_AsVal_int(obj4, &val6);
7592  if (!SWIG_IsOK(ecode6)) {
7593  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7594  }
7595  arg6 = (PLINT)(val6);
7596  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7597  resultobj = SWIG_Py_Void();
7598  {
7599  Py_CLEAR( tmp1 );
7600  }
7601  return resultobj;
7602 fail:
7603  {
7604  Py_CLEAR( tmp1 );
7605  }
7606  return NULL;
7607 }
7608 
7609 
7610 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611  PyObject *resultobj = 0;
7612  PLFLT arg1 ;
7613  PLFLT arg2 ;
7614  PLFLT arg3 ;
7615  PLFLT *arg4 = (PLFLT *) 0 ;
7616  PLFLT *arg5 = (PLFLT *) 0 ;
7617  PLFLT *arg6 = (PLFLT *) 0 ;
7618  double val1 ;
7619  int ecode1 = 0 ;
7620  double val2 ;
7621  int ecode2 = 0 ;
7622  double val3 ;
7623  int ecode3 = 0 ;
7624  PLFLT temp4 ;
7625  int res4 = SWIG_TMPOBJ ;
7626  PLFLT temp5 ;
7627  int res5 = SWIG_TMPOBJ ;
7628  PLFLT temp6 ;
7629  int res6 = SWIG_TMPOBJ ;
7630  PyObject * obj0 = 0 ;
7631  PyObject * obj1 = 0 ;
7632  PyObject * obj2 = 0 ;
7633 
7634  arg4 = &temp4;
7635  arg5 = &temp5;
7636  arg6 = &temp6;
7637  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7638  ecode1 = SWIG_AsVal_double(obj0, &val1);
7639  if (!SWIG_IsOK(ecode1)) {
7640  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7641  }
7642  arg1 = (PLFLT)(val1);
7643  ecode2 = SWIG_AsVal_double(obj1, &val2);
7644  if (!SWIG_IsOK(ecode2)) {
7645  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7646  }
7647  arg2 = (PLFLT)(val2);
7648  ecode3 = SWIG_AsVal_double(obj2, &val3);
7649  if (!SWIG_IsOK(ecode3)) {
7650  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7651  }
7652  arg3 = (PLFLT)(val3);
7653  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7654  resultobj = SWIG_Py_Void();
7655  if (SWIG_IsTmpObj(res4)) {
7656  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7657  } else {
7658  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7659  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7660  }
7661  if (SWIG_IsTmpObj(res5)) {
7662  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7663  } else {
7664  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7665  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7666  }
7667  if (SWIG_IsTmpObj(res6)) {
7668  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7669  } else {
7670  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7671  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7672  }
7673  return resultobj;
7674 fail:
7675  return NULL;
7676 }
7677 
7678 
7679 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7680  PyObject *resultobj = 0;
7681 
7682  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7683  plinit();
7684  resultobj = SWIG_Py_Void();
7685  return resultobj;
7686 fail:
7687  return NULL;
7688 }
7689 
7690 
7691 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7692  PyObject *resultobj = 0;
7693  PLFLT arg1 ;
7694  PLFLT arg2 ;
7695  PLFLT arg3 ;
7696  PLFLT arg4 ;
7697  double val1 ;
7698  int ecode1 = 0 ;
7699  double val2 ;
7700  int ecode2 = 0 ;
7701  double val3 ;
7702  int ecode3 = 0 ;
7703  double val4 ;
7704  int ecode4 = 0 ;
7705  PyObject * obj0 = 0 ;
7706  PyObject * obj1 = 0 ;
7707  PyObject * obj2 = 0 ;
7708  PyObject * obj3 = 0 ;
7709 
7710  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7711  ecode1 = SWIG_AsVal_double(obj0, &val1);
7712  if (!SWIG_IsOK(ecode1)) {
7713  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7714  }
7715  arg1 = (PLFLT)(val1);
7716  ecode2 = SWIG_AsVal_double(obj1, &val2);
7717  if (!SWIG_IsOK(ecode2)) {
7718  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7719  }
7720  arg2 = (PLFLT)(val2);
7721  ecode3 = SWIG_AsVal_double(obj2, &val3);
7722  if (!SWIG_IsOK(ecode3)) {
7723  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7724  }
7725  arg3 = (PLFLT)(val3);
7726  ecode4 = SWIG_AsVal_double(obj3, &val4);
7727  if (!SWIG_IsOK(ecode4)) {
7728  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7729  }
7730  arg4 = (PLFLT)(val4);
7731  pljoin(arg1,arg2,arg3,arg4);
7732  resultobj = SWIG_Py_Void();
7733  return resultobj;
7734 fail:
7735  return NULL;
7736 }
7737 
7738 
7739 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740  PyObject *resultobj = 0;
7741  char *arg1 = (char *) 0 ;
7742  char *arg2 = (char *) 0 ;
7743  char *arg3 = (char *) 0 ;
7744  int res1 ;
7745  char *buf1 = 0 ;
7746  int alloc1 = 0 ;
7747  int res2 ;
7748  char *buf2 = 0 ;
7749  int alloc2 = 0 ;
7750  int res3 ;
7751  char *buf3 = 0 ;
7752  int alloc3 = 0 ;
7753  PyObject * obj0 = 0 ;
7754  PyObject * obj1 = 0 ;
7755  PyObject * obj2 = 0 ;
7756 
7757  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7758  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7759  if (!SWIG_IsOK(res1)) {
7760  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7761  }
7762  arg1 = (char *)(buf1);
7763  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7764  if (!SWIG_IsOK(res2)) {
7765  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7766  }
7767  arg2 = (char *)(buf2);
7768  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7769  if (!SWIG_IsOK(res3)) {
7770  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7771  }
7772  arg3 = (char *)(buf3);
7773  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7774  resultobj = SWIG_Py_Void();
7775  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7776  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7777  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7778  return resultobj;
7779 fail:
7780  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7781  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7782  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7783  return NULL;
7784 }
7785 
7786 
7787 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788  PyObject *resultobj = 0;
7789  PLFLT *arg1 = (PLFLT *) 0 ;
7790  PLFLT *arg2 = (PLFLT *) 0 ;
7791  PLINT arg3 ;
7792  PLINT arg4 ;
7793  PLFLT arg5 ;
7794  PLFLT arg6 ;
7795  PLFLT arg7 ;
7796  PLINT arg8 ;
7797  PLINT arg9 ;
7798  PLINT arg10 ;
7799  PLINT arg11 ;
7800  PLINT arg12 ;
7801  PLINT arg13 ;
7802  PLINT *arg14 = (PLINT *) 0 ;
7803  PLFLT arg15 ;
7804  PLFLT arg16 ;
7805  PLFLT arg17 ;
7806  PLFLT arg18 ;
7807  PLINT *arg19 = (PLINT *) 0 ;
7808  char **arg20 = (char **) 0 ;
7809  PLINT *arg21 = (PLINT *) 0 ;
7810  PLINT *arg22 = (PLINT *) 0 ;
7811  PLFLT *arg23 = (PLFLT *) 0 ;
7812  PLFLT *arg24 = (PLFLT *) 0 ;
7813  PLINT *arg25 = (PLINT *) 0 ;
7814  PLINT *arg26 = (PLINT *) 0 ;
7815  PLFLT *arg27 = (PLFLT *) 0 ;
7816  PLINT *arg28 = (PLINT *) 0 ;
7817  PLFLT *arg29 = (PLFLT *) 0 ;
7818  PLINT *arg30 = (PLINT *) 0 ;
7819  char **arg31 = (char **) 0 ;
7820  PLFLT temp1 ;
7821  int res1 = SWIG_TMPOBJ ;
7822  PLFLT temp2 ;
7823  int res2 = SWIG_TMPOBJ ;
7824  int val3 ;
7825  int ecode3 = 0 ;
7826  int val4 ;
7827  int ecode4 = 0 ;
7828  double val5 ;
7829  int ecode5 = 0 ;
7830  double val6 ;
7831  int ecode6 = 0 ;
7832  double val7 ;
7833  int ecode7 = 0 ;
7834  int val8 ;
7835  int ecode8 = 0 ;
7836  int val9 ;
7837  int ecode9 = 0 ;
7838  int val10 ;
7839  int ecode10 = 0 ;
7840  int val11 ;
7841  int ecode11 = 0 ;
7842  int val12 ;
7843  int ecode12 = 0 ;
7844  PyArrayObject *tmp13 = NULL ;
7845  double val15 ;
7846  int ecode15 = 0 ;
7847  double val16 ;
7848  int ecode16 = 0 ;
7849  double val17 ;
7850  int ecode17 = 0 ;
7851  double val18 ;
7852  int ecode18 = 0 ;
7853  PyArrayObject *tmp19 = NULL ;
7854  PyArrayObject *tmp20 = NULL ;
7855  PyArrayObject *tmp21 = NULL ;
7856  PyArrayObject *tmp22 = NULL ;
7857  PyArrayObject *tmp23 = NULL ;
7858  PyArrayObject *tmp24 = NULL ;
7859  PyArrayObject *tmp25 = NULL ;
7860  PyArrayObject *tmp26 = NULL ;
7861  PyArrayObject *tmp27 = NULL ;
7862  PyArrayObject *tmp28 = NULL ;
7863  PyArrayObject *tmp29 = NULL ;
7864  PyArrayObject *tmp30 = NULL ;
7865  PyArrayObject *tmp31 = NULL ;
7866  PyObject * obj0 = 0 ;
7867  PyObject * obj1 = 0 ;
7868  PyObject * obj2 = 0 ;
7869  PyObject * obj3 = 0 ;
7870  PyObject * obj4 = 0 ;
7871  PyObject * obj5 = 0 ;
7872  PyObject * obj6 = 0 ;
7873  PyObject * obj7 = 0 ;
7874  PyObject * obj8 = 0 ;
7875  PyObject * obj9 = 0 ;
7876  PyObject * obj10 = 0 ;
7877  PyObject * obj11 = 0 ;
7878  PyObject * obj12 = 0 ;
7879  PyObject * obj13 = 0 ;
7880  PyObject * obj14 = 0 ;
7881  PyObject * obj15 = 0 ;
7882  PyObject * obj16 = 0 ;
7883  PyObject * obj17 = 0 ;
7884  PyObject * obj18 = 0 ;
7885  PyObject * obj19 = 0 ;
7886  PyObject * obj20 = 0 ;
7887  PyObject * obj21 = 0 ;
7888  PyObject * obj22 = 0 ;
7889  PyObject * obj23 = 0 ;
7890  PyObject * obj24 = 0 ;
7891  PyObject * obj25 = 0 ;
7892  PyObject * obj26 = 0 ;
7893  PyObject * obj27 = 0 ;
7894 
7895  arg1 = &temp1;
7896  arg2 = &temp2;
7897  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;
7898  ecode3 = SWIG_AsVal_int(obj0, &val3);
7899  if (!SWIG_IsOK(ecode3)) {
7900  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7901  }
7902  arg3 = (PLINT)(val3);
7903  ecode4 = SWIG_AsVal_int(obj1, &val4);
7904  if (!SWIG_IsOK(ecode4)) {
7905  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7906  }
7907  arg4 = (PLINT)(val4);
7908  ecode5 = SWIG_AsVal_double(obj2, &val5);
7909  if (!SWIG_IsOK(ecode5)) {
7910  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7911  }
7912  arg5 = (PLFLT)(val5);
7913  ecode6 = SWIG_AsVal_double(obj3, &val6);
7914  if (!SWIG_IsOK(ecode6)) {
7915  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7916  }
7917  arg6 = (PLFLT)(val6);
7918  ecode7 = SWIG_AsVal_double(obj4, &val7);
7919  if (!SWIG_IsOK(ecode7)) {
7920  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7921  }
7922  arg7 = (PLFLT)(val7);
7923  ecode8 = SWIG_AsVal_int(obj5, &val8);
7924  if (!SWIG_IsOK(ecode8)) {
7925  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7926  }
7927  arg8 = (PLINT)(val8);
7928  ecode9 = SWIG_AsVal_int(obj6, &val9);
7929  if (!SWIG_IsOK(ecode9)) {
7930  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7931  }
7932  arg9 = (PLINT)(val9);
7933  ecode10 = SWIG_AsVal_int(obj7, &val10);
7934  if (!SWIG_IsOK(ecode10)) {
7935  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7936  }
7937  arg10 = (PLINT)(val10);
7938  ecode11 = SWIG_AsVal_int(obj8, &val11);
7939  if (!SWIG_IsOK(ecode11)) {
7940  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7941  }
7942  arg11 = (PLINT)(val11);
7943  ecode12 = SWIG_AsVal_int(obj9, &val12);
7944  if (!SWIG_IsOK(ecode12)) {
7945  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7946  }
7947  arg12 = (PLINT)(val12);
7948  {
7949  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
7950  if ( tmp13 == NULL )
7951  return NULL;
7952  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7953  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7954  }
7955  ecode15 = SWIG_AsVal_double(obj11, &val15);
7956  if (!SWIG_IsOK(ecode15)) {
7957  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7958  }
7959  arg15 = (PLFLT)(val15);
7960  ecode16 = SWIG_AsVal_double(obj12, &val16);
7961  if (!SWIG_IsOK(ecode16)) {
7962  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7963  }
7964  arg16 = (PLFLT)(val16);
7965  ecode17 = SWIG_AsVal_double(obj13, &val17);
7966  if (!SWIG_IsOK(ecode17)) {
7967  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7968  }
7969  arg17 = (PLFLT)(val17);
7970  ecode18 = SWIG_AsVal_double(obj14, &val18);
7971  if (!SWIG_IsOK(ecode18)) {
7972  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7973  }
7974  arg18 = (PLFLT)(val18);
7975  {
7976  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
7977  if ( tmp19 == NULL )
7978  return NULL;
7979  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7980  {
7981  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7982  return NULL;
7983  }
7984  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7985  }
7986  {
7987  int i;
7988  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7989  if ( tmp20 == NULL )
7990  return NULL;
7991  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7992  {
7993  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7994  return NULL;
7995  }
7996  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7997  for ( i = 0; i < Alen; i++ )
7998  {
7999  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8000  if ( arg20[i] == NULL )
8001  {
8002  free( arg20 );
8003  return NULL;
8004  }
8005  }
8006  }
8007  {
8008  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8009  if ( tmp21 == NULL )
8010  return NULL;
8011  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8012  {
8013  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8014  return NULL;
8015  }
8016  arg21 = (PLINT *) PyArray_DATA( tmp21 );
8017  }
8018  {
8019  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8020  if ( tmp22 == NULL )
8021  return NULL;
8022  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8023  {
8024  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8025  return NULL;
8026  }
8027  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8028  }
8029  {
8030  if ( obj19 != Py_None )
8031  {
8032  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8033  if ( tmp23 == NULL )
8034  return NULL;
8035  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8036  {
8037  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8038  return NULL;
8039  }
8040  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8041  }
8042  else
8043  {
8044  arg23 = NULL;
8045  }
8046  }
8047  {
8048  if ( obj20 != Py_None )
8049  {
8050  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8051  if ( tmp24 == NULL )
8052  return NULL;
8053  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8054  {
8055  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8056  return NULL;
8057  }
8058  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8059  }
8060  else
8061  {
8062  arg24 = NULL;
8063  }
8064  }
8065  {
8066  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8067  if ( tmp25 == NULL )
8068  return NULL;
8069  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8070  {
8071  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8072  return NULL;
8073  }
8074  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8075  }
8076  {
8077  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8078  if ( tmp26 == NULL )
8079  return NULL;
8080  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8081  {
8082  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8083  return NULL;
8084  }
8085  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8086  }
8087  {
8088  if ( obj23 != Py_None )
8089  {
8090  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8091  if ( tmp27 == NULL )
8092  return NULL;
8093  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8094  {
8095  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8096  return NULL;
8097  }
8098  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8099  }
8100  else
8101  {
8102  arg27 = NULL;
8103  }
8104  }
8105  {
8106  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8107  if ( tmp28 == NULL )
8108  return NULL;
8109  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8110  {
8111  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8112  return NULL;
8113  }
8114  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8115  }
8116  {
8117  if ( obj25 != Py_None )
8118  {
8119  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8120  if ( tmp29 == NULL )
8121  return NULL;
8122  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8123  {
8124  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8125  return NULL;
8126  }
8127  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8128  }
8129  else
8130  {
8131  arg29 = NULL;
8132  }
8133  }
8134  {
8135  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8136  if ( tmp30 == NULL )
8137  return NULL;
8138  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8139  {
8140  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8141  return NULL;
8142  }
8143  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8144  }
8145  {
8146  int i;
8147  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8148  if ( tmp31 == NULL )
8149  return NULL;
8150  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8151  {
8152  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8153  return NULL;
8154  }
8155  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8156  for ( i = 0; i < Alen; i++ )
8157  {
8158  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8159  if ( arg31[i] == NULL )
8160  {
8161  free( arg31 );
8162  return NULL;
8163  }
8164  }
8165  }
8166  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);
8167  resultobj = SWIG_Py_Void();
8168  if (SWIG_IsTmpObj(res1)) {
8169  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8170  } else {
8171  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8172  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8173  }
8174  if (SWIG_IsTmpObj(res2)) {
8175  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8176  } else {
8177  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8178  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8179  }
8180  {
8181  Py_CLEAR( tmp13 );
8182  }
8183  {
8184  Py_CLEAR( tmp19 );
8185  }
8186  {
8187  Py_CLEAR( tmp20 ); free( arg20 );
8188  }
8189  {
8190  Py_CLEAR( tmp21 );
8191  }
8192  {
8193  Py_CLEAR( tmp22 );
8194  }
8195  {
8196  Py_CLEAR( tmp23 );
8197  }
8198  {
8199  Py_CLEAR( tmp24 );
8200  }
8201  {
8202  Py_CLEAR( tmp25 );
8203  }
8204  {
8205  Py_CLEAR( tmp26 );
8206  }
8207  {
8208  Py_CLEAR( tmp27 );
8209  }
8210  {
8211  Py_CLEAR( tmp28 );
8212  }
8213  {
8214  Py_CLEAR( tmp29 );
8215  }
8216  {
8217  Py_CLEAR( tmp30 );
8218  }
8219  {
8220  Py_CLEAR( tmp31 ); free( arg31 );
8221  }
8222  return resultobj;
8223 fail:
8224  {
8225  Py_CLEAR( tmp13 );
8226  }
8227  {
8228  Py_CLEAR( tmp19 );
8229  }
8230  {
8231  Py_CLEAR( tmp20 ); free( arg20 );
8232  }
8233  {
8234  Py_CLEAR( tmp21 );
8235  }
8236  {
8237  Py_CLEAR( tmp22 );
8238  }
8239  {
8240  Py_CLEAR( tmp23 );
8241  }
8242  {
8243  Py_CLEAR( tmp24 );
8244  }
8245  {
8246  Py_CLEAR( tmp25 );
8247  }
8248  {
8249  Py_CLEAR( tmp26 );
8250  }
8251  {
8252  Py_CLEAR( tmp27 );
8253  }
8254  {
8255  Py_CLEAR( tmp28 );
8256  }
8257  {
8258  Py_CLEAR( tmp29 );
8259  }
8260  {
8261  Py_CLEAR( tmp30 );
8262  }
8263  {
8264  Py_CLEAR( tmp31 ); free( arg31 );
8265  }
8266  return NULL;
8267 }
8268 
8269 
8270 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8271  PyObject *resultobj = 0;
8272  PLFLT *arg1 = (PLFLT *) 0 ;
8273  PLFLT *arg2 = (PLFLT *) 0 ;
8274  PLINT arg3 ;
8275  PLINT arg4 ;
8276  PLFLT arg5 ;
8277  PLFLT arg6 ;
8278  PLFLT arg7 ;
8279  PLFLT arg8 ;
8280  PLINT arg9 ;
8281  PLINT arg10 ;
8282  PLINT arg11 ;
8283  PLFLT arg12 ;
8284  PLFLT arg13 ;
8285  PLINT arg14 ;
8286  PLFLT arg15 ;
8287  PLINT arg16 ;
8288  PLINT *arg17 = (PLINT *) 0 ;
8289  char **arg18 = (char **) 0 ;
8290  PLINT arg19 ;
8291  char **arg20 = (char **) 0 ;
8292  PLFLT *arg21 = (PLFLT *) 0 ;
8293  PLINT *arg22 = (PLINT *) 0 ;
8294  PLINT *arg23 = (PLINT *) 0 ;
8295  PLFLT **arg24 = (PLFLT **) 0 ;
8296  PLFLT temp1 ;
8297  int res1 = SWIG_TMPOBJ ;
8298  PLFLT temp2 ;
8299  int res2 = SWIG_TMPOBJ ;
8300  int val3 ;
8301  int ecode3 = 0 ;
8302  int val4 ;
8303  int ecode4 = 0 ;
8304  double val5 ;
8305  int ecode5 = 0 ;
8306  double val6 ;
8307  int ecode6 = 0 ;
8308  double val7 ;
8309  int ecode7 = 0 ;
8310  double val8 ;
8311  int ecode8 = 0 ;
8312  int val9 ;
8313  int ecode9 = 0 ;
8314  int val10 ;
8315  int ecode10 = 0 ;
8316  int val11 ;
8317  int ecode11 = 0 ;
8318  double val12 ;
8319  int ecode12 = 0 ;
8320  double val13 ;
8321  int ecode13 = 0 ;
8322  int val14 ;
8323  int ecode14 = 0 ;
8324  double val15 ;
8325  int ecode15 = 0 ;
8326  PyArrayObject *tmp16 = NULL ;
8327  PyArrayObject *tmp18 = NULL ;
8328  PyArrayObject *tmp19 = NULL ;
8329  PyArrayObject *tmp21 = NULL ;
8330  PyArrayObject *tmp22 = NULL ;
8331  PyArrayObject *tmp23 = NULL ;
8332  PyArrayObject *tmp24 = NULL ;
8333  PyObject * obj0 = 0 ;
8334  PyObject * obj1 = 0 ;
8335  PyObject * obj2 = 0 ;
8336  PyObject * obj3 = 0 ;
8337  PyObject * obj4 = 0 ;
8338  PyObject * obj5 = 0 ;
8339  PyObject * obj6 = 0 ;
8340  PyObject * obj7 = 0 ;
8341  PyObject * obj8 = 0 ;
8342  PyObject * obj9 = 0 ;
8343  PyObject * obj10 = 0 ;
8344  PyObject * obj11 = 0 ;
8345  PyObject * obj12 = 0 ;
8346  PyObject * obj13 = 0 ;
8347  PyObject * obj14 = 0 ;
8348  PyObject * obj15 = 0 ;
8349  PyObject * obj16 = 0 ;
8350  PyObject * obj17 = 0 ;
8351  PyObject * obj18 = 0 ;
8352  PyObject * obj19 = 0 ;
8353 
8354  arg1 = &temp1;
8355  arg2 = &temp2;
8356  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;
8357  ecode3 = SWIG_AsVal_int(obj0, &val3);
8358  if (!SWIG_IsOK(ecode3)) {
8359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8360  }
8361  arg3 = (PLINT)(val3);
8362  ecode4 = SWIG_AsVal_int(obj1, &val4);
8363  if (!SWIG_IsOK(ecode4)) {
8364  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8365  }
8366  arg4 = (PLINT)(val4);
8367  ecode5 = SWIG_AsVal_double(obj2, &val5);
8368  if (!SWIG_IsOK(ecode5)) {
8369  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8370  }
8371  arg5 = (PLFLT)(val5);
8372  ecode6 = SWIG_AsVal_double(obj3, &val6);
8373  if (!SWIG_IsOK(ecode6)) {
8374  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8375  }
8376  arg6 = (PLFLT)(val6);
8377  ecode7 = SWIG_AsVal_double(obj4, &val7);
8378  if (!SWIG_IsOK(ecode7)) {
8379  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8380  }
8381  arg7 = (PLFLT)(val7);
8382  ecode8 = SWIG_AsVal_double(obj5, &val8);
8383  if (!SWIG_IsOK(ecode8)) {
8384  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8385  }
8386  arg8 = (PLFLT)(val8);
8387  ecode9 = SWIG_AsVal_int(obj6, &val9);
8388  if (!SWIG_IsOK(ecode9)) {
8389  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8390  }
8391  arg9 = (PLINT)(val9);
8392  ecode10 = SWIG_AsVal_int(obj7, &val10);
8393  if (!SWIG_IsOK(ecode10)) {
8394  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8395  }
8396  arg10 = (PLINT)(val10);
8397  ecode11 = SWIG_AsVal_int(obj8, &val11);
8398  if (!SWIG_IsOK(ecode11)) {
8399  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8400  }
8401  arg11 = (PLINT)(val11);
8402  ecode12 = SWIG_AsVal_double(obj9, &val12);
8403  if (!SWIG_IsOK(ecode12)) {
8404  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8405  }
8406  arg12 = (PLFLT)(val12);
8407  ecode13 = SWIG_AsVal_double(obj10, &val13);
8408  if (!SWIG_IsOK(ecode13)) {
8409  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8410  }
8411  arg13 = (PLFLT)(val13);
8412  ecode14 = SWIG_AsVal_int(obj11, &val14);
8413  if (!SWIG_IsOK(ecode14)) {
8414  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8415  }
8416  arg14 = (PLINT)(val14);
8417  ecode15 = SWIG_AsVal_double(obj12, &val15);
8418  if (!SWIG_IsOK(ecode15)) {
8419  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8420  }
8421  arg15 = (PLFLT)(val15);
8422  {
8423  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8424  if ( tmp16 == NULL )
8425  return NULL;
8426  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8427  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8428  }
8429  {
8430  int i;
8431  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8432  if ( tmp18 == NULL )
8433  return NULL;
8434  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8435  {
8436  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8437  return NULL;
8438  }
8439  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8440  for ( i = 0; i < Alen; i++ )
8441  {
8442  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8443  if ( arg18[i] == NULL )
8444  {
8445  free( arg18 );
8446  return NULL;
8447  }
8448  }
8449  }
8450  {
8451  int i;
8452  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8453  if ( tmp19 == NULL )
8454  return NULL;
8455  Alen = PyArray_DIMS( tmp19 )[0];
8456  arg19 = Alen;
8457  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8458  for ( i = 0; i < Alen; i++ )
8459  {
8460  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8461  if ( arg20[i] == NULL )
8462  {
8463  free( arg20 );
8464  return NULL;
8465  }
8466  }
8467  }
8468  {
8469  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8470  if ( tmp21 == NULL )
8471  return NULL;
8472  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8473  {
8474  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8475  return NULL;
8476  }
8477  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8478  }
8479  {
8480  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8481  if ( tmp22 == NULL )
8482  return NULL;
8483  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8484  {
8485  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8486  return NULL;
8487  }
8488  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8489  }
8490  {
8491  int i;
8492  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8493  if ( tmp23 == NULL )
8494  return NULL;
8495  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8496  {
8497  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8498  return NULL;
8499  }
8500  Xlen = PyArray_DIMS( tmp23 )[0];
8501  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8502  Ylen = -1;
8503  for ( i = 0; i < Xlen; i++ )
8504  if ( arg23[i] > Ylen )
8505  Ylen = arg23[i];
8506  }
8507  {
8508  int i, size;
8509  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8510  if ( tmp24 == NULL )
8511  return NULL;
8512  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8513  {
8514  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8515  return NULL;
8516  }
8517  size = Ylen;
8518  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8519  for ( i = 0; i < Xlen; i++ )
8520  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8521  }
8522  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);
8523  resultobj = SWIG_Py_Void();
8524  if (SWIG_IsTmpObj(res1)) {
8525  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8526  } else {
8527  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8528  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8529  }
8530  if (SWIG_IsTmpObj(res2)) {
8531  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8532  } else {
8533  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8534  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8535  }
8536  {
8537  Py_CLEAR( tmp16 );
8538  }
8539  {
8540  Py_CLEAR( tmp18 ); free( arg18 );
8541  }
8542  {
8543  Py_CLEAR( tmp19 ); free( arg20 );
8544  }
8545  {
8546  Py_CLEAR( tmp21 );
8547  }
8548  {
8549  Py_CLEAR( tmp22 );
8550  }
8551  {
8552  Py_CLEAR( tmp23 );
8553  }
8554  {
8555  Py_CLEAR( tmp24 );
8556  free( arg24 );
8557  }
8558  return resultobj;
8559 fail:
8560  {
8561  Py_CLEAR( tmp16 );
8562  }
8563  {
8564  Py_CLEAR( tmp18 ); free( arg18 );
8565  }
8566  {
8567  Py_CLEAR( tmp19 ); free( arg20 );
8568  }
8569  {
8570  Py_CLEAR( tmp21 );
8571  }
8572  {
8573  Py_CLEAR( tmp22 );
8574  }
8575  {
8576  Py_CLEAR( tmp23 );
8577  }
8578  {
8579  Py_CLEAR( tmp24 );
8580  free( arg24 );
8581  }
8582  return NULL;
8583 }
8584 
8585 
8586 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8587  PyObject *resultobj = 0;
8588  PLFLT arg1 ;
8589  PLFLT arg2 ;
8590  PLFLT arg3 ;
8591  double val1 ;
8592  int ecode1 = 0 ;
8593  double val2 ;
8594  int ecode2 = 0 ;
8595  double val3 ;
8596  int ecode3 = 0 ;
8597  PyObject * obj0 = 0 ;
8598  PyObject * obj1 = 0 ;
8599  PyObject * obj2 = 0 ;
8600 
8601  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8602  ecode1 = SWIG_AsVal_double(obj0, &val1);
8603  if (!SWIG_IsOK(ecode1)) {
8604  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8605  }
8606  arg1 = (PLFLT)(val1);
8607  ecode2 = SWIG_AsVal_double(obj1, &val2);
8608  if (!SWIG_IsOK(ecode2)) {
8609  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8610  }
8611  arg2 = (PLFLT)(val2);
8612  ecode3 = SWIG_AsVal_double(obj2, &val3);
8613  if (!SWIG_IsOK(ecode3)) {
8614  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8615  }
8616  arg3 = (PLFLT)(val3);
8617  pllightsource(arg1,arg2,arg3);
8618  resultobj = SWIG_Py_Void();
8619  return resultobj;
8620 fail:
8621  return NULL;
8622 }
8623 
8624 
8625 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8626  PyObject *resultobj = 0;
8627  PLINT arg1 ;
8628  PLFLT *arg2 = (PLFLT *) 0 ;
8629  PLFLT *arg3 = (PLFLT *) 0 ;
8630  PyArrayObject *tmp1 = NULL ;
8631  PyArrayObject *tmp3 = NULL ;
8632  PyObject * obj0 = 0 ;
8633  PyObject * obj1 = 0 ;
8634 
8635  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8636  {
8637  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8638  if ( tmp1 == NULL )
8639  return NULL;
8640  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8641  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8642  }
8643  {
8644  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8645  if ( tmp3 == NULL )
8646  return NULL;
8647  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8648  {
8649  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8650  return NULL;
8651  }
8652  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8653  }
8654  plline(arg1,(double const *)arg2,(double const *)arg3);
8655  resultobj = SWIG_Py_Void();
8656  {
8657  Py_CLEAR( tmp1 );
8658  }
8659  {
8660  Py_CLEAR( tmp3 );
8661  }
8662  return resultobj;
8663 fail:
8664  {
8665  Py_CLEAR( tmp1 );
8666  }
8667  {
8668  Py_CLEAR( tmp3 );
8669  }
8670  return NULL;
8671 }
8672 
8673 
8674 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8675  PyObject *resultobj = 0;
8676  PLINT arg1 ;
8677  PLFLT *arg2 = (PLFLT *) 0 ;
8678  PLFLT *arg3 = (PLFLT *) 0 ;
8679  PLFLT *arg4 = (PLFLT *) 0 ;
8680  PyArrayObject *tmp1 = NULL ;
8681  PyArrayObject *tmp3 = NULL ;
8682  PyArrayObject *tmp4 = NULL ;
8683  PyObject * obj0 = 0 ;
8684  PyObject * obj1 = 0 ;
8685  PyObject * obj2 = 0 ;
8686 
8687  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8688  {
8689  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8690  if ( tmp1 == NULL )
8691  return NULL;
8692  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8693  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8694  }
8695  {
8696  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8697  if ( tmp3 == NULL )
8698  return NULL;
8699  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8700  {
8701  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8702  return NULL;
8703  }
8704  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8705  }
8706  {
8707  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8708  if ( tmp4 == NULL )
8709  return NULL;
8710  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8711  {
8712  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8713  return NULL;
8714  }
8715  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8716  }
8717  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8718  resultobj = SWIG_Py_Void();
8719  {
8720  Py_CLEAR( tmp1 );
8721  }
8722  {
8723  Py_CLEAR( tmp3 );
8724  }
8725  {
8726  Py_CLEAR( tmp4 );
8727  }
8728  return resultobj;
8729 fail:
8730  {
8731  Py_CLEAR( tmp1 );
8732  }
8733  {
8734  Py_CLEAR( tmp3 );
8735  }
8736  {
8737  Py_CLEAR( tmp4 );
8738  }
8739  return NULL;
8740 }
8741 
8742 
8743 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8744  PyObject *resultobj = 0;
8745  PLINT arg1 ;
8746  int val1 ;
8747  int ecode1 = 0 ;
8748  PyObject * obj0 = 0 ;
8749 
8750  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8751  ecode1 = SWIG_AsVal_int(obj0, &val1);
8752  if (!SWIG_IsOK(ecode1)) {
8753  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8754  }
8755  arg1 = (PLINT)(val1);
8756  pllsty(arg1);
8757  resultobj = SWIG_Py_Void();
8758  return resultobj;
8759 fail:
8760  return NULL;
8761 }
8762 
8763 
8764 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8765  PyObject *resultobj = 0;
8766  PLFLT *arg1 = (PLFLT *) 0 ;
8767  PLFLT *arg2 = (PLFLT *) 0 ;
8768  PLFLT **arg3 = (PLFLT **) 0 ;
8769  PLINT arg4 ;
8770  PLINT arg5 ;
8771  PLINT arg6 ;
8772  PyArrayObject *tmp1 = NULL ;
8773  PyArrayObject *tmp2 = NULL ;
8774  PyArrayObject *tmp3 = NULL ;
8775  int val6 ;
8776  int ecode6 = 0 ;
8777  PyObject * obj0 = 0 ;
8778  PyObject * obj1 = 0 ;
8779  PyObject * obj2 = 0 ;
8780  PyObject * obj3 = 0 ;
8781 
8782  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8783  {
8784  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8785  if ( tmp1 == NULL )
8786  return NULL;
8787  Xlen = PyArray_DIMS( tmp1 )[0];
8788  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8789  }
8790  {
8791  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8792  if ( tmp2 == NULL )
8793  return NULL;
8794  Ylen = PyArray_DIMS( tmp2 )[0];
8795  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8796  }
8797  {
8798  int i, size;
8799  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8800  if ( tmp3 == NULL )
8801  return NULL;
8802  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8803  {
8804  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8805  return NULL;
8806  }
8807  arg4 = PyArray_DIMS( tmp3 )[0];
8808  arg5 = PyArray_DIMS( tmp3 )[1];
8809  size = arg5;
8810  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8811  for ( i = 0; i < arg4; i++ )
8812  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8813  }
8814  ecode6 = SWIG_AsVal_int(obj3, &val6);
8815  if (!SWIG_IsOK(ecode6)) {
8816  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8817  }
8818  arg6 = (PLINT)(val6);
8819  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8820  resultobj = SWIG_Py_Void();
8821  {
8822  Py_CLEAR( tmp1 );
8823  }
8824  {
8825  Py_CLEAR( tmp2 );
8826  }
8827  {
8828  Py_CLEAR( tmp3 );
8829  free( arg3 );
8830  }
8831  return resultobj;
8832 fail:
8833  {
8834  Py_CLEAR( tmp1 );
8835  }
8836  {
8837  Py_CLEAR( tmp2 );
8838  }
8839  {
8840  Py_CLEAR( tmp3 );
8841  free( arg3 );
8842  }
8843  return NULL;
8844 }
8845 
8846 
8847 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8848  PyObject *resultobj = 0;
8849  PLFLT *arg1 = (PLFLT *) 0 ;
8850  PLFLT *arg2 = (PLFLT *) 0 ;
8851  PLFLT **arg3 = (PLFLT **) 0 ;
8852  PLINT arg4 ;
8853  PLINT arg5 ;
8854  PLINT arg6 ;
8855  PLFLT *arg7 = (PLFLT *) 0 ;
8856  PLINT arg8 ;
8857  PyArrayObject *tmp1 = NULL ;
8858  PyArrayObject *tmp2 = NULL ;
8859  PyArrayObject *tmp3 = NULL ;
8860  int val6 ;
8861  int ecode6 = 0 ;
8862  PyArrayObject *tmp7 = NULL ;
8863  PyObject * obj0 = 0 ;
8864  PyObject * obj1 = 0 ;
8865  PyObject * obj2 = 0 ;
8866  PyObject * obj3 = 0 ;
8867  PyObject * obj4 = 0 ;
8868 
8869  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8870  {
8871  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8872  if ( tmp1 == NULL )
8873  return NULL;
8874  Xlen = PyArray_DIMS( tmp1 )[0];
8875  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8876  }
8877  {
8878  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8879  if ( tmp2 == NULL )
8880  return NULL;
8881  Ylen = PyArray_DIMS( tmp2 )[0];
8882  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8883  }
8884  {
8885  int i, size;
8886  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8887  if ( tmp3 == NULL )
8888  return NULL;
8889  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8890  {
8891  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8892  return NULL;
8893  }
8894  arg4 = PyArray_DIMS( tmp3 )[0];
8895  arg5 = PyArray_DIMS( tmp3 )[1];
8896  size = arg5;
8897  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8898  for ( i = 0; i < arg4; i++ )
8899  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8900  }
8901  ecode6 = SWIG_AsVal_int(obj3, &val6);
8902  if (!SWIG_IsOK(ecode6)) {
8903  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8904  }
8905  arg6 = (PLINT)(val6);
8906  {
8907  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
8908  if ( tmp7 == NULL )
8909  return NULL;
8910  arg8 = PyArray_DIMS( tmp7 )[0];
8911  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8912  }
8913  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8914  resultobj = SWIG_Py_Void();
8915  {
8916  Py_CLEAR( tmp1 );
8917  }
8918  {
8919  Py_CLEAR( tmp2 );
8920  }
8921  {
8922  Py_CLEAR( tmp3 );
8923  free( arg3 );
8924  }
8925  {
8926  Py_CLEAR( tmp7 );
8927  }
8928  return resultobj;
8929 fail:
8930  {
8931  Py_CLEAR( tmp1 );
8932  }
8933  {
8934  Py_CLEAR( tmp2 );
8935  }
8936  {
8937  Py_CLEAR( tmp3 );
8938  free( arg3 );
8939  }
8940  {
8941  Py_CLEAR( tmp7 );
8942  }
8943  return NULL;
8944 }
8945 
8946 
8947 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8948  PyObject *resultobj = 0;
8949  PLINT *arg1 = (PLINT *) 0 ;
8950  PLINT temp1 ;
8951  int res1 = SWIG_TMPOBJ ;
8952 
8953  arg1 = &temp1;
8954  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
8955  plmkstrm(arg1);
8956  resultobj = SWIG_Py_Void();
8957  if (SWIG_IsTmpObj(res1)) {
8958  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8959  } else {
8960  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8961  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8962  }
8963  return resultobj;
8964 fail:
8965  return NULL;
8966 }
8967 
8968 
8969 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970  PyObject *resultobj = 0;
8971  char *arg1 = (char *) 0 ;
8972  PLFLT arg2 ;
8973  PLFLT arg3 ;
8974  PLFLT arg4 ;
8975  char *arg5 = (char *) 0 ;
8976  int res1 ;
8977  char *buf1 = 0 ;
8978  int alloc1 = 0 ;
8979  double val2 ;
8980  int ecode2 = 0 ;
8981  double val3 ;
8982  int ecode3 = 0 ;
8983  double val4 ;
8984  int ecode4 = 0 ;
8985  int res5 ;
8986  char *buf5 = 0 ;
8987  int alloc5 = 0 ;
8988  PyObject * obj0 = 0 ;
8989  PyObject * obj1 = 0 ;
8990  PyObject * obj2 = 0 ;
8991  PyObject * obj3 = 0 ;
8992  PyObject * obj4 = 0 ;
8993 
8994  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8995  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8996  if (!SWIG_IsOK(res1)) {
8997  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8998  }
8999  arg1 = (char *)(buf1);
9000  ecode2 = SWIG_AsVal_double(obj1, &val2);
9001  if (!SWIG_IsOK(ecode2)) {
9002  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9003  }
9004  arg2 = (PLFLT)(val2);
9005  ecode3 = SWIG_AsVal_double(obj2, &val3);
9006  if (!SWIG_IsOK(ecode3)) {
9007  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9008  }
9009  arg3 = (PLFLT)(val3);
9010  ecode4 = SWIG_AsVal_double(obj3, &val4);
9011  if (!SWIG_IsOK(ecode4)) {
9012  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9013  }
9014  arg4 = (PLFLT)(val4);
9015  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9016  if (!SWIG_IsOK(res5)) {
9017  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9018  }
9019  arg5 = (char *)(buf5);
9020  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9021  resultobj = SWIG_Py_Void();
9022  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9023  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9024  return resultobj;
9025 fail:
9026  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9027  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9028  return NULL;
9029 }
9030 
9031 
9032 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033  PyObject *resultobj = 0;
9034  char *arg1 = (char *) 0 ;
9035  PLFLT arg2 ;
9036  PLFLT arg3 ;
9037  PLFLT arg4 ;
9038  char *arg5 = (char *) 0 ;
9039  int res1 ;
9040  char *buf1 = 0 ;
9041  int alloc1 = 0 ;
9042  double val2 ;
9043  int ecode2 = 0 ;
9044  double val3 ;
9045  int ecode3 = 0 ;
9046  double val4 ;
9047  int ecode4 = 0 ;
9048  int res5 ;
9049  char *buf5 = 0 ;
9050  int alloc5 = 0 ;
9051  PyObject * obj0 = 0 ;
9052  PyObject * obj1 = 0 ;
9053  PyObject * obj2 = 0 ;
9054  PyObject * obj3 = 0 ;
9055  PyObject * obj4 = 0 ;
9056 
9057  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9058  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9059  if (!SWIG_IsOK(res1)) {
9060  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9061  }
9062  arg1 = (char *)(buf1);
9063  ecode2 = SWIG_AsVal_double(obj1, &val2);
9064  if (!SWIG_IsOK(ecode2)) {
9065  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9066  }
9067  arg2 = (PLFLT)(val2);
9068  ecode3 = SWIG_AsVal_double(obj2, &val3);
9069  if (!SWIG_IsOK(ecode3)) {
9070  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9071  }
9072  arg3 = (PLFLT)(val3);
9073  ecode4 = SWIG_AsVal_double(obj3, &val4);
9074  if (!SWIG_IsOK(ecode4)) {
9075  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9076  }
9077  arg4 = (PLFLT)(val4);
9078  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9079  if (!SWIG_IsOK(res5)) {
9080  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9081  }
9082  arg5 = (char *)(buf5);
9083  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9084  resultobj = SWIG_Py_Void();
9085  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9086  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9087  return resultobj;
9088 fail:
9089  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9090  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9091  return NULL;
9092 }
9093 
9094 
9095 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096  PyObject *resultobj = 0;
9097  PLFLT *arg1 = (PLFLT *) 0 ;
9098  PLFLT *arg2 = (PLFLT *) 0 ;
9099  PLFLT **arg3 = (PLFLT **) 0 ;
9100  PLINT arg4 ;
9101  PLINT arg5 ;
9102  PLINT arg6 ;
9103  PLBOOL arg7 ;
9104  PyArrayObject *tmp1 = NULL ;
9105  PyArrayObject *tmp2 = NULL ;
9106  PyArrayObject *tmp3 = NULL ;
9107  int val6 ;
9108  int ecode6 = 0 ;
9109  int val7 ;
9110  int ecode7 = 0 ;
9111  PyObject * obj0 = 0 ;
9112  PyObject * obj1 = 0 ;
9113  PyObject * obj2 = 0 ;
9114  PyObject * obj3 = 0 ;
9115  PyObject * obj4 = 0 ;
9116 
9117  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9118  {
9119  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9120  if ( tmp1 == NULL )
9121  return NULL;
9122  Xlen = PyArray_DIMS( tmp1 )[0];
9123  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9124  }
9125  {
9126  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9127  if ( tmp2 == NULL )
9128  return NULL;
9129  Ylen = PyArray_DIMS( tmp2 )[0];
9130  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9131  }
9132  {
9133  int i, size;
9134  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9135  if ( tmp3 == NULL )
9136  return NULL;
9137  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9138  {
9139  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9140  return NULL;
9141  }
9142  arg4 = PyArray_DIMS( tmp3 )[0];
9143  arg5 = PyArray_DIMS( tmp3 )[1];
9144  size = arg5;
9145  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9146  for ( i = 0; i < arg4; i++ )
9147  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9148  }
9149  ecode6 = SWIG_AsVal_int(obj3, &val6);
9150  if (!SWIG_IsOK(ecode6)) {
9151  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9152  }
9153  arg6 = (PLINT)(val6);
9154  ecode7 = SWIG_AsVal_int(obj4, &val7);
9155  if (!SWIG_IsOK(ecode7)) {
9156  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9157  }
9158  arg7 = (PLBOOL)(val7);
9159  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9160  resultobj = SWIG_Py_Void();
9161  {
9162  Py_CLEAR( tmp1 );
9163  }
9164  {
9165  Py_CLEAR( tmp2 );
9166  }
9167  {
9168  Py_CLEAR( tmp3 );
9169  free( arg3 );
9170  }
9171  return resultobj;
9172 fail:
9173  {
9174  Py_CLEAR( tmp1 );
9175  }
9176  {
9177  Py_CLEAR( tmp2 );
9178  }
9179  {
9180  Py_CLEAR( tmp3 );
9181  free( arg3 );
9182  }
9183  return NULL;
9184 }
9185 
9186 
9187 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9188  PyObject *resultobj = 0;
9189  PLFLT *arg1 = (PLFLT *) 0 ;
9190  PLFLT *arg2 = (PLFLT *) 0 ;
9191  PLFLT **arg3 = (PLFLT **) 0 ;
9192  PLINT arg4 ;
9193  PLINT arg5 ;
9194  PLINT arg6 ;
9195  PLFLT *arg7 = (PLFLT *) 0 ;
9196  PLINT arg8 ;
9197  PyArrayObject *tmp1 = NULL ;
9198  PyArrayObject *tmp2 = NULL ;
9199  PyArrayObject *tmp3 = NULL ;
9200  int val6 ;
9201  int ecode6 = 0 ;
9202  PyArrayObject *tmp7 = NULL ;
9203  PyObject * obj0 = 0 ;
9204  PyObject * obj1 = 0 ;
9205  PyObject * obj2 = 0 ;
9206  PyObject * obj3 = 0 ;
9207  PyObject * obj4 = 0 ;
9208 
9209  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9210  {
9211  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9212  if ( tmp1 == NULL )
9213  return NULL;
9214  Xlen = PyArray_DIMS( tmp1 )[0];
9215  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9216  }
9217  {
9218  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9219  if ( tmp2 == NULL )
9220  return NULL;
9221  Ylen = PyArray_DIMS( tmp2 )[0];
9222  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9223  }
9224  {
9225  int i, size;
9226  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9227  if ( tmp3 == NULL )
9228  return NULL;
9229  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9230  {
9231  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9232  return NULL;
9233  }
9234  arg4 = PyArray_DIMS( tmp3 )[0];
9235  arg5 = PyArray_DIMS( tmp3 )[1];
9236  size = arg5;
9237  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9238  for ( i = 0; i < arg4; i++ )
9239  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9240  }
9241  ecode6 = SWIG_AsVal_int(obj3, &val6);
9242  if (!SWIG_IsOK(ecode6)) {
9243  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9244  }
9245  arg6 = (PLINT)(val6);
9246  {
9247  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9248  if ( tmp7 == NULL )
9249  return NULL;
9250  arg8 = PyArray_DIMS( tmp7 )[0];
9251  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9252  }
9253  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9254  resultobj = SWIG_Py_Void();
9255  {
9256  Py_CLEAR( tmp1 );
9257  }
9258  {
9259  Py_CLEAR( tmp2 );
9260  }
9261  {
9262  Py_CLEAR( tmp3 );
9263  free( arg3 );
9264  }
9265  {
9266  Py_CLEAR( tmp7 );
9267  }
9268  return resultobj;
9269 fail:
9270  {
9271  Py_CLEAR( tmp1 );
9272  }
9273  {
9274  Py_CLEAR( tmp2 );
9275  }
9276  {
9277  Py_CLEAR( tmp3 );
9278  free( arg3 );
9279  }
9280  {
9281  Py_CLEAR( tmp7 );
9282  }
9283  return NULL;
9284 }
9285 
9286 
9287 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9288  PyObject *resultobj = 0;
9289  PLFLT *arg1 = (PLFLT *) 0 ;
9290  PLFLT *arg2 = (PLFLT *) 0 ;
9291  PLFLT **arg3 = (PLFLT **) 0 ;
9292  PLINT arg4 ;
9293  PLINT arg5 ;
9294  PLINT arg6 ;
9295  PLFLT *arg7 = (PLFLT *) 0 ;
9296  PLINT arg8 ;
9297  PLINT arg9 ;
9298  PLINT arg10 ;
9299  PLINT *arg11 = (PLINT *) 0 ;
9300  PLINT *arg12 = (PLINT *) 0 ;
9301  PyArrayObject *tmp1 = NULL ;
9302  PyArrayObject *tmp2 = NULL ;
9303  PyArrayObject *tmp3 = NULL ;
9304  int val6 ;
9305  int ecode6 = 0 ;
9306  PyArrayObject *tmp7 = NULL ;
9307  int val9 ;
9308  int ecode9 = 0 ;
9309  PyArrayObject *tmp10 = NULL ;
9310  PyArrayObject *tmp12 = NULL ;
9311  PyObject * obj0 = 0 ;
9312  PyObject * obj1 = 0 ;
9313  PyObject * obj2 = 0 ;
9314  PyObject * obj3 = 0 ;
9315  PyObject * obj4 = 0 ;
9316  PyObject * obj5 = 0 ;
9317  PyObject * obj6 = 0 ;
9318  PyObject * obj7 = 0 ;
9319 
9320  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9321  {
9322  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9323  if ( tmp1 == NULL )
9324  return NULL;
9325  Xlen = PyArray_DIMS( tmp1 )[0];
9326  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9327  }
9328  {
9329  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9330  if ( tmp2 == NULL )
9331  return NULL;
9332  Ylen = PyArray_DIMS( tmp2 )[0];
9333  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9334  }
9335  {
9336  int i, size;
9337  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9338  if ( tmp3 == NULL )
9339  return NULL;
9340  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9341  {
9342  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9343  return NULL;
9344  }
9345  arg4 = PyArray_DIMS( tmp3 )[0];
9346  arg5 = PyArray_DIMS( tmp3 )[1];
9347  size = arg5;
9348  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9349  for ( i = 0; i < arg4; i++ )
9350  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9351  }
9352  ecode6 = SWIG_AsVal_int(obj3, &val6);
9353  if (!SWIG_IsOK(ecode6)) {
9354  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9355  }
9356  arg6 = (PLINT)(val6);
9357  {
9358  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9359  if ( tmp7 == NULL )
9360  return NULL;
9361  arg8 = PyArray_DIMS( tmp7 )[0];
9362  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9363  }
9364  ecode9 = SWIG_AsVal_int(obj5, &val9);
9365  if (!SWIG_IsOK(ecode9)) {
9366  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9367  }
9368  arg9 = (PLINT)(val9);
9369  {
9370  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9371  if ( tmp10 == NULL )
9372  return NULL;
9373  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9374  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9375  }
9376  {
9377  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9378  if ( tmp12 == NULL )
9379  return NULL;
9380  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9381  {
9382  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9383  return NULL;
9384  }
9385  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9386  }
9387  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);
9388  resultobj = SWIG_Py_Void();
9389  {
9390  Py_CLEAR( tmp1 );
9391  }
9392  {
9393  Py_CLEAR( tmp2 );
9394  }
9395  {
9396  Py_CLEAR( tmp3 );
9397  free( arg3 );
9398  }
9399  {
9400  Py_CLEAR( tmp7 );
9401  }
9402  {
9403  Py_CLEAR( tmp10 );
9404  }
9405  {
9406  Py_CLEAR( tmp12 );
9407  }
9408  return resultobj;
9409 fail:
9410  {
9411  Py_CLEAR( tmp1 );
9412  }
9413  {
9414  Py_CLEAR( tmp2 );
9415  }
9416  {
9417  Py_CLEAR( tmp3 );
9418  free( arg3 );
9419  }
9420  {
9421  Py_CLEAR( tmp7 );
9422  }
9423  {
9424  Py_CLEAR( tmp10 );
9425  }
9426  {
9427  Py_CLEAR( tmp12 );
9428  }
9429  return NULL;
9430 }
9431 
9432 
9433 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9434  PyObject *resultobj = 0;
9435  PLFLT *arg1 = (PLFLT *) 0 ;
9436  PLFLT *arg2 = (PLFLT *) 0 ;
9437  PLFLT **arg3 = (PLFLT **) 0 ;
9438  PLINT arg4 ;
9439  PLINT arg5 ;
9440  PLINT arg6 ;
9441  PLFLT *arg7 = (PLFLT *) 0 ;
9442  PLINT arg8 ;
9443  PyArrayObject *tmp1 = NULL ;
9444  PyArrayObject *tmp2 = NULL ;
9445  PyArrayObject *tmp3 = NULL ;
9446  int val6 ;
9447  int ecode6 = 0 ;
9448  PyArrayObject *tmp7 = NULL ;
9449  PyObject * obj0 = 0 ;
9450  PyObject * obj1 = 0 ;
9451  PyObject * obj2 = 0 ;
9452  PyObject * obj3 = 0 ;
9453  PyObject * obj4 = 0 ;
9454 
9455  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9456  {
9457  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9458  if ( tmp1 == NULL )
9459  return NULL;
9460  Xlen = PyArray_DIMS( tmp1 )[0];
9461  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9462  }
9463  {
9464  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9465  if ( tmp2 == NULL )
9466  return NULL;
9467  Ylen = PyArray_DIMS( tmp2 )[0];
9468  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9469  }
9470  {
9471  int i, size;
9472  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9473  if ( tmp3 == NULL )
9474  return NULL;
9475  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9476  {
9477  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9478  return NULL;
9479  }
9480  arg4 = PyArray_DIMS( tmp3 )[0];
9481  arg5 = PyArray_DIMS( tmp3 )[1];
9482  size = arg5;
9483  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9484  for ( i = 0; i < arg4; i++ )
9485  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9486  }
9487  ecode6 = SWIG_AsVal_int(obj3, &val6);
9488  if (!SWIG_IsOK(ecode6)) {
9489  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9490  }
9491  arg6 = (PLINT)(val6);
9492  {
9493  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9494  if ( tmp7 == NULL )
9495  return NULL;
9496  arg8 = PyArray_DIMS( tmp7 )[0];
9497  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9498  }
9499  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9500  resultobj = SWIG_Py_Void();
9501  {
9502  Py_CLEAR( tmp1 );
9503  }
9504  {
9505  Py_CLEAR( tmp2 );
9506  }
9507  {
9508  Py_CLEAR( tmp3 );
9509  free( arg3 );
9510  }
9511  {
9512  Py_CLEAR( tmp7 );
9513  }
9514  return resultobj;
9515 fail:
9516  {
9517  Py_CLEAR( tmp1 );
9518  }
9519  {
9520  Py_CLEAR( tmp2 );
9521  }
9522  {
9523  Py_CLEAR( tmp3 );
9524  free( arg3 );
9525  }
9526  {
9527  Py_CLEAR( tmp7 );
9528  }
9529  return NULL;
9530 }
9531 
9532 
9533 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534  PyObject *resultobj = 0;
9535  PLFLT *arg1 = (PLFLT *) 0 ;
9536  PLFLT *arg2 = (PLFLT *) 0 ;
9537  PLFLT **arg3 = (PLFLT **) 0 ;
9538  PLINT arg4 ;
9539  PLINT arg5 ;
9540  PLINT arg6 ;
9541  PLFLT *arg7 = (PLFLT *) 0 ;
9542  PLINT arg8 ;
9543  PLINT arg9 ;
9544  PLINT arg10 ;
9545  PLINT *arg11 = (PLINT *) 0 ;
9546  PLINT *arg12 = (PLINT *) 0 ;
9547  PyArrayObject *tmp1 = NULL ;
9548  PyArrayObject *tmp2 = NULL ;
9549  PyArrayObject *tmp3 = NULL ;
9550  int val6 ;
9551  int ecode6 = 0 ;
9552  PyArrayObject *tmp7 = NULL ;
9553  int val9 ;
9554  int ecode9 = 0 ;
9555  PyArrayObject *tmp10 = NULL ;
9556  PyArrayObject *tmp12 = NULL ;
9557  PyObject * obj0 = 0 ;
9558  PyObject * obj1 = 0 ;
9559  PyObject * obj2 = 0 ;
9560  PyObject * obj3 = 0 ;
9561  PyObject * obj4 = 0 ;
9562  PyObject * obj5 = 0 ;
9563  PyObject * obj6 = 0 ;
9564  PyObject * obj7 = 0 ;
9565 
9566  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9567  {
9568  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9569  if ( tmp1 == NULL )
9570  return NULL;
9571  Xlen = PyArray_DIMS( tmp1 )[0];
9572  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9573  }
9574  {
9575  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9576  if ( tmp2 == NULL )
9577  return NULL;
9578  Ylen = PyArray_DIMS( tmp2 )[0];
9579  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9580  }
9581  {
9582  int i, size;
9583  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9584  if ( tmp3 == NULL )
9585  return NULL;
9586  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9587  {
9588  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9589  return NULL;
9590  }
9591  arg4 = PyArray_DIMS( tmp3 )[0];
9592  arg5 = PyArray_DIMS( tmp3 )[1];
9593  size = arg5;
9594  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9595  for ( i = 0; i < arg4; i++ )
9596  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9597  }
9598  ecode6 = SWIG_AsVal_int(obj3, &val6);
9599  if (!SWIG_IsOK(ecode6)) {
9600  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9601  }
9602  arg6 = (PLINT)(val6);
9603  {
9604  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9605  if ( tmp7 == NULL )
9606  return NULL;
9607  arg8 = PyArray_DIMS( tmp7 )[0];
9608  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9609  }
9610  ecode9 = SWIG_AsVal_int(obj5, &val9);
9611  if (!SWIG_IsOK(ecode9)) {
9612  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9613  }
9614  arg9 = (PLINT)(val9);
9615  {
9616  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9617  if ( tmp10 == NULL )
9618  return NULL;
9619  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9620  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9621  }
9622  {
9623  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9624  if ( tmp12 == NULL )
9625  return NULL;
9626  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9627  {
9628  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9629  return NULL;
9630  }
9631  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9632  }
9633  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);
9634  resultobj = SWIG_Py_Void();
9635  {
9636  Py_CLEAR( tmp1 );
9637  }
9638  {
9639  Py_CLEAR( tmp2 );
9640  }
9641  {
9642  Py_CLEAR( tmp3 );
9643  free( arg3 );
9644  }
9645  {
9646  Py_CLEAR( tmp7 );
9647  }
9648  {
9649  Py_CLEAR( tmp10 );
9650  }
9651  {
9652  Py_CLEAR( tmp12 );
9653  }
9654  return resultobj;
9655 fail:
9656  {
9657  Py_CLEAR( tmp1 );
9658  }
9659  {
9660  Py_CLEAR( tmp2 );
9661  }
9662  {
9663  Py_CLEAR( tmp3 );
9664  free( arg3 );
9665  }
9666  {
9667  Py_CLEAR( tmp7 );
9668  }
9669  {
9670  Py_CLEAR( tmp10 );
9671  }
9672  {
9673  Py_CLEAR( tmp12 );
9674  }
9675  return NULL;
9676 }
9677 
9678 
9679 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9680  PyObject *resultobj = 0;
9681  int *arg1 = (int *) 0 ;
9682  char **arg2 = (char **) 0 ;
9683  PLINT arg3 ;
9684  int tmp1 ;
9685  int val3 ;
9686  int ecode3 = 0 ;
9687  PyObject * obj0 = 0 ;
9688  PyObject * obj1 = 0 ;
9689  PLINT result;
9690 
9691  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9692  {
9693  int i;
9694  if ( !PyList_Check( obj0 ) )
9695  {
9696  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9697  return NULL;
9698  }
9699  tmp1 = PyList_Size( obj0 );
9700  arg1 = &tmp1;
9701  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9702  for ( i = 0; i < tmp1; i++ )
9703  {
9704  PyObject *s = PyList_GetItem( obj0, i );
9705  if ( !PyString_Check( s ) )
9706  {
9707  free( arg2 );
9708  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9709  return NULL;
9710  }
9711  arg2[i] = PyString_AsString( s );
9712  }
9713  arg2[i] = 0;
9714  }
9715  ecode3 = SWIG_AsVal_int(obj1, &val3);
9716  if (!SWIG_IsOK(ecode3)) {
9717  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9718  }
9719  arg3 = (PLINT)(val3);
9720  result = (PLINT)plparseopts(arg1,arg2,arg3);
9721  resultobj = SWIG_From_int((int)(result));
9722  {
9723  if ( arg2 )
9724  free( arg2 );
9725  }
9726  return resultobj;
9727 fail:
9728  {
9729  if ( arg2 )
9730  free( arg2 );
9731  }
9732  return NULL;
9733 }
9734 
9735 
9736 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9737  PyObject *resultobj = 0;
9738  PLINT arg1 ;
9739  PLINT *arg2 = (PLINT *) 0 ;
9740  PLINT *arg3 = (PLINT *) 0 ;
9741  PyArrayObject *tmp1 = NULL ;
9742  PyArrayObject *tmp3 = NULL ;
9743  PyObject * obj0 = 0 ;
9744  PyObject * obj1 = 0 ;
9745 
9746  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9747  {
9748  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9749  if ( tmp1 == NULL )
9750  return NULL;
9751  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9752  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9753  }
9754  {
9755  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9756  if ( tmp3 == NULL )
9757  return NULL;
9758  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9759  {
9760  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9761  return NULL;
9762  }
9763  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9764  }
9765  plpat(arg1,(int const *)arg2,(int const *)arg3);
9766  resultobj = SWIG_Py_Void();
9767  {
9768  Py_CLEAR( tmp1 );
9769  }
9770  {
9771  Py_CLEAR( tmp3 );
9772  }
9773  return resultobj;
9774 fail:
9775  {
9776  Py_CLEAR( tmp1 );
9777  }
9778  {
9779  Py_CLEAR( tmp3 );
9780  }
9781  return NULL;
9782 }
9783 
9784 
9785 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9786  PyObject *resultobj = 0;
9787  PLINT arg1 ;
9788  PLFLT arg2 ;
9789  PLFLT arg3 ;
9790  PLFLT arg4 ;
9791  PLFLT arg5 ;
9792  int val1 ;
9793  int ecode1 = 0 ;
9794  double val2 ;
9795  int ecode2 = 0 ;
9796  double val3 ;
9797  int ecode3 = 0 ;
9798  double val4 ;
9799  int ecode4 = 0 ;
9800  double val5 ;
9801  int ecode5 = 0 ;
9802  PyObject * obj0 = 0 ;
9803  PyObject * obj1 = 0 ;
9804  PyObject * obj2 = 0 ;
9805  PyObject * obj3 = 0 ;
9806  PyObject * obj4 = 0 ;
9807 
9808  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9809  ecode1 = SWIG_AsVal_int(obj0, &val1);
9810  if (!SWIG_IsOK(ecode1)) {
9811  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9812  }
9813  arg1 = (PLINT)(val1);
9814  ecode2 = SWIG_AsVal_double(obj1, &val2);
9815  if (!SWIG_IsOK(ecode2)) {
9816  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9817  }
9818  arg2 = (PLFLT)(val2);
9819  ecode3 = SWIG_AsVal_double(obj2, &val3);
9820  if (!SWIG_IsOK(ecode3)) {
9821  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9822  }
9823  arg3 = (PLFLT)(val3);
9824  ecode4 = SWIG_AsVal_double(obj3, &val4);
9825  if (!SWIG_IsOK(ecode4)) {
9826  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9827  }
9828  arg4 = (PLFLT)(val4);
9829  ecode5 = SWIG_AsVal_double(obj4, &val5);
9830  if (!SWIG_IsOK(ecode5)) {
9831  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9832  }
9833  arg5 = (PLFLT)(val5);
9834  plpath(arg1,arg2,arg3,arg4,arg5);
9835  resultobj = SWIG_Py_Void();
9836  return resultobj;
9837 fail:
9838  return NULL;
9839 }
9840 
9841 
9842 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9843  PyObject *resultobj = 0;
9844  PLINT arg1 ;
9845  PLFLT *arg2 = (PLFLT *) 0 ;
9846  PLFLT *arg3 = (PLFLT *) 0 ;
9847  PLINT arg4 ;
9848  PyArrayObject *tmp1 = NULL ;
9849  PyArrayObject *tmp3 = NULL ;
9850  int val4 ;
9851  int ecode4 = 0 ;
9852  PyObject * obj0 = 0 ;
9853  PyObject * obj1 = 0 ;
9854  PyObject * obj2 = 0 ;
9855 
9856  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
9857  {
9858  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9859  if ( tmp1 == NULL )
9860  return NULL;
9861  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9862  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9863  }
9864  {
9865  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9866  if ( tmp3 == NULL )
9867  return NULL;
9868  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9869  {
9870  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9871  return NULL;
9872  }
9873  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9874  }
9875  ecode4 = SWIG_AsVal_int(obj2, &val4);
9876  if (!SWIG_IsOK(ecode4)) {
9877  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9878  }
9879  arg4 = (PLINT)(val4);
9880  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9881  resultobj = SWIG_Py_Void();
9882  {
9883  Py_CLEAR( tmp1 );
9884  }
9885  {
9886  Py_CLEAR( tmp3 );
9887  }
9888  return resultobj;
9889 fail:
9890  {
9891  Py_CLEAR( tmp1 );
9892  }
9893  {
9894  Py_CLEAR( tmp3 );
9895  }
9896  return NULL;
9897 }
9898 
9899 
9900 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901  PyObject *resultobj = 0;
9902  PLINT arg1 ;
9903  PLFLT *arg2 = (PLFLT *) 0 ;
9904  PLFLT *arg3 = (PLFLT *) 0 ;
9905  PLFLT *arg4 = (PLFLT *) 0 ;
9906  PLINT arg5 ;
9907  PyArrayObject *tmp1 = NULL ;
9908  PyArrayObject *tmp3 = NULL ;
9909  PyArrayObject *tmp4 = NULL ;
9910  int val5 ;
9911  int ecode5 = 0 ;
9912  PyObject * obj0 = 0 ;
9913  PyObject * obj1 = 0 ;
9914  PyObject * obj2 = 0 ;
9915  PyObject * obj3 = 0 ;
9916 
9917  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9918  {
9919  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9920  if ( tmp1 == NULL )
9921  return NULL;
9922  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9923  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9924  }
9925  {
9926  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9927  if ( tmp3 == NULL )
9928  return NULL;
9929  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9930  {
9931  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9932  return NULL;
9933  }
9934  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9935  }
9936  {
9937  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9938  if ( tmp4 == NULL )
9939  return NULL;
9940  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9941  {
9942  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9943  return NULL;
9944  }
9945  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9946  }
9947  ecode5 = SWIG_AsVal_int(obj3, &val5);
9948  if (!SWIG_IsOK(ecode5)) {
9949  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9950  }
9951  arg5 = (PLINT)(val5);
9952  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9953  resultobj = SWIG_Py_Void();
9954  {
9955  Py_CLEAR( tmp1 );
9956  }
9957  {
9958  Py_CLEAR( tmp3 );
9959  }
9960  {
9961  Py_CLEAR( tmp4 );
9962  }
9963  return resultobj;
9964 fail:
9965  {
9966  Py_CLEAR( tmp1 );
9967  }
9968  {
9969  Py_CLEAR( tmp3 );
9970  }
9971  {
9972  Py_CLEAR( tmp4 );
9973  }
9974  return NULL;
9975 }
9976 
9977 
9978 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9979  PyObject *resultobj = 0;
9980  PLINT arg1 ;
9981  PLFLT *arg2 = (PLFLT *) 0 ;
9982  PLFLT *arg3 = (PLFLT *) 0 ;
9983  PLFLT *arg4 = (PLFLT *) 0 ;
9984  PLBOOL *arg5 = (PLBOOL *) 0 ;
9985  PLBOOL arg6 ;
9986  PyArrayObject *tmp1 = NULL ;
9987  PyArrayObject *tmp3 = NULL ;
9988  PyArrayObject *tmp4 = NULL ;
9989  PyArrayObject *tmp5 = NULL ;
9990  int val6 ;
9991  int ecode6 = 0 ;
9992  PyObject * obj0 = 0 ;
9993  PyObject * obj1 = 0 ;
9994  PyObject * obj2 = 0 ;
9995  PyObject * obj3 = 0 ;
9996  PyObject * obj4 = 0 ;
9997 
9998  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9999  {
10000  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10001  if ( tmp1 == NULL )
10002  return NULL;
10003  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10004  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10005  }
10006  {
10007  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10008  if ( tmp3 == NULL )
10009  return NULL;
10010  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10011  {
10012  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10013  return NULL;
10014  }
10015  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10016  }
10017  {
10018  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10019  if ( tmp4 == NULL )
10020  return NULL;
10021  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10022  {
10023  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10024  return NULL;
10025  }
10026  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10027  }
10028  {
10029  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10030  if ( tmp5 == NULL )
10031  return NULL;
10032  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10033  {
10034  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10035  return NULL;
10036  }
10037  arg5 = (PLINT *) PyArray_DATA( tmp5 );
10038  }
10039  ecode6 = SWIG_AsVal_int(obj4, &val6);
10040  if (!SWIG_IsOK(ecode6)) {
10041  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10042  }
10043  arg6 = (PLBOOL)(val6);
10044  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10045  resultobj = SWIG_Py_Void();
10046  {
10047  Py_CLEAR( tmp1 );
10048  }
10049  {
10050  Py_CLEAR( tmp3 );
10051  }
10052  {
10053  Py_CLEAR( tmp4 );
10054  }
10055  {
10056  Py_CLEAR( tmp5 );
10057  }
10058  return resultobj;
10059 fail:
10060  {
10061  Py_CLEAR( tmp1 );
10062  }
10063  {
10064  Py_CLEAR( tmp3 );
10065  }
10066  {
10067  Py_CLEAR( tmp4 );
10068  }
10069  {
10070  Py_CLEAR( tmp5 );
10071  }
10072  return NULL;
10073 }
10074 
10075 
10076 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10077  PyObject *resultobj = 0;
10078  PLINT arg1 ;
10079  PLINT arg2 ;
10080  int val1 ;
10081  int ecode1 = 0 ;
10082  int val2 ;
10083  int ecode2 = 0 ;
10084  PyObject * obj0 = 0 ;
10085  PyObject * obj1 = 0 ;
10086 
10087  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10088  ecode1 = SWIG_AsVal_int(obj0, &val1);
10089  if (!SWIG_IsOK(ecode1)) {
10090  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10091  }
10092  arg1 = (PLINT)(val1);
10093  ecode2 = SWIG_AsVal_int(obj1, &val2);
10094  if (!SWIG_IsOK(ecode2)) {
10095  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10096  }
10097  arg2 = (PLINT)(val2);
10098  plprec(arg1,arg2);
10099  resultobj = SWIG_Py_Void();
10100  return resultobj;
10101 fail:
10102  return NULL;
10103 }
10104 
10105 
10106 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10107  PyObject *resultobj = 0;
10108  PLINT arg1 ;
10109  int val1 ;
10110  int ecode1 = 0 ;
10111  PyObject * obj0 = 0 ;
10112 
10113  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10114  ecode1 = SWIG_AsVal_int(obj0, &val1);
10115  if (!SWIG_IsOK(ecode1)) {
10116  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10117  }
10118  arg1 = (PLINT)(val1);
10119  plpsty(arg1);
10120  resultobj = SWIG_Py_Void();
10121  return resultobj;
10122 fail:
10123  return NULL;
10124 }
10125 
10126 
10127 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10128  PyObject *resultobj = 0;
10129  PLFLT arg1 ;
10130  PLFLT arg2 ;
10131  PLFLT arg3 ;
10132  PLFLT arg4 ;
10133  PLFLT arg5 ;
10134  char *arg6 = (char *) 0 ;
10135  double val1 ;
10136  int ecode1 = 0 ;
10137  double val2 ;
10138  int ecode2 = 0 ;
10139  double val3 ;
10140  int ecode3 = 0 ;
10141  double val4 ;
10142  int ecode4 = 0 ;
10143  double val5 ;
10144  int ecode5 = 0 ;
10145  int res6 ;
10146  char *buf6 = 0 ;
10147  int alloc6 = 0 ;
10148  PyObject * obj0 = 0 ;
10149  PyObject * obj1 = 0 ;
10150  PyObject * obj2 = 0 ;
10151  PyObject * obj3 = 0 ;
10152  PyObject * obj4 = 0 ;
10153  PyObject * obj5 = 0 ;
10154 
10155  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10156  ecode1 = SWIG_AsVal_double(obj0, &val1);
10157  if (!SWIG_IsOK(ecode1)) {
10158  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10159  }
10160  arg1 = (PLFLT)(val1);
10161  ecode2 = SWIG_AsVal_double(obj1, &val2);
10162  if (!SWIG_IsOK(ecode2)) {
10163  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10164  }
10165  arg2 = (PLFLT)(val2);
10166  ecode3 = SWIG_AsVal_double(obj2, &val3);
10167  if (!SWIG_IsOK(ecode3)) {
10168  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10169  }
10170  arg3 = (PLFLT)(val3);
10171  ecode4 = SWIG_AsVal_double(obj3, &val4);
10172  if (!SWIG_IsOK(ecode4)) {
10173  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10174  }
10175  arg4 = (PLFLT)(val4);
10176  ecode5 = SWIG_AsVal_double(obj4, &val5);
10177  if (!SWIG_IsOK(ecode5)) {
10178  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10179  }
10180  arg5 = (PLFLT)(val5);
10181  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10182  if (!SWIG_IsOK(res6)) {
10183  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10184  }
10185  arg6 = (char *)(buf6);
10186  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10187  resultobj = SWIG_Py_Void();
10188  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10189  return resultobj;
10190 fail:
10191  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10192  return NULL;
10193 }
10194 
10195 
10196 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10197  PyObject *resultobj = 0;
10198  PLFLT arg1 ;
10199  PLFLT arg2 ;
10200  PLFLT arg3 ;
10201  PLFLT arg4 ;
10202  PLFLT arg5 ;
10203  PLFLT arg6 ;
10204  PLFLT arg7 ;
10205  PLFLT arg8 ;
10206  PLFLT arg9 ;
10207  PLFLT arg10 ;
10208  char *arg11 = (char *) 0 ;
10209  double val1 ;
10210  int ecode1 = 0 ;
10211  double val2 ;
10212  int ecode2 = 0 ;
10213  double val3 ;
10214  int ecode3 = 0 ;
10215  double val4 ;
10216  int ecode4 = 0 ;
10217  double val5 ;
10218  int ecode5 = 0 ;
10219  double val6 ;
10220  int ecode6 = 0 ;
10221  double val7 ;
10222  int ecode7 = 0 ;
10223  double val8 ;
10224  int ecode8 = 0 ;
10225  double val9 ;
10226  int ecode9 = 0 ;
10227  double val10 ;
10228  int ecode10 = 0 ;
10229  int res11 ;
10230  char *buf11 = 0 ;
10231  int alloc11 = 0 ;
10232  PyObject * obj0 = 0 ;
10233  PyObject * obj1 = 0 ;
10234  PyObject * obj2 = 0 ;
10235  PyObject * obj3 = 0 ;
10236  PyObject * obj4 = 0 ;
10237  PyObject * obj5 = 0 ;
10238  PyObject * obj6 = 0 ;
10239  PyObject * obj7 = 0 ;
10240  PyObject * obj8 = 0 ;
10241  PyObject * obj9 = 0 ;
10242  PyObject * obj10 = 0 ;
10243 
10244  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10245  ecode1 = SWIG_AsVal_double(obj0, &val1);
10246  if (!SWIG_IsOK(ecode1)) {
10247  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10248  }
10249  arg1 = (PLFLT)(val1);
10250  ecode2 = SWIG_AsVal_double(obj1, &val2);
10251  if (!SWIG_IsOK(ecode2)) {
10252  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10253  }
10254  arg2 = (PLFLT)(val2);
10255  ecode3 = SWIG_AsVal_double(obj2, &val3);
10256  if (!SWIG_IsOK(ecode3)) {
10257  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10258  }
10259  arg3 = (PLFLT)(val3);
10260  ecode4 = SWIG_AsVal_double(obj3, &val4);
10261  if (!SWIG_IsOK(ecode4)) {
10262  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10263  }
10264  arg4 = (PLFLT)(val4);
10265  ecode5 = SWIG_AsVal_double(obj4, &val5);
10266  if (!SWIG_IsOK(ecode5)) {
10267  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10268  }
10269  arg5 = (PLFLT)(val5);
10270  ecode6 = SWIG_AsVal_double(obj5, &val6);
10271  if (!SWIG_IsOK(ecode6)) {
10272  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10273  }
10274  arg6 = (PLFLT)(val6);
10275  ecode7 = SWIG_AsVal_double(obj6, &val7);
10276  if (!SWIG_IsOK(ecode7)) {
10277  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10278  }
10279  arg7 = (PLFLT)(val7);
10280  ecode8 = SWIG_AsVal_double(obj7, &val8);
10281  if (!SWIG_IsOK(ecode8)) {
10282  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10283  }
10284  arg8 = (PLFLT)(val8);
10285  ecode9 = SWIG_AsVal_double(obj8, &val9);
10286  if (!SWIG_IsOK(ecode9)) {
10287  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10288  }
10289  arg9 = (PLFLT)(val9);
10290  ecode10 = SWIG_AsVal_double(obj9, &val10);
10291  if (!SWIG_IsOK(ecode10)) {
10292  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10293  }
10294  arg10 = (PLFLT)(val10);
10295  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10296  if (!SWIG_IsOK(res11)) {
10297  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10298  }
10299  arg11 = (char *)(buf11);
10300  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10301  resultobj = SWIG_Py_Void();
10302  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10303  return resultobj;
10304 fail:
10305  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10306  return NULL;
10307 }
10308 
10309 
10310 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10311  PyObject *resultobj = 0;
10312  PLFLT result;
10313 
10314  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10315  result = (PLFLT)plrandd();
10316  resultobj = SWIG_From_double((double)(result));
10317  return resultobj;
10318 fail:
10319  return NULL;
10320 }
10321 
10322 
10323 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10324  PyObject *resultobj = 0;
10325 
10326  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10327  plreplot();
10328  resultobj = SWIG_Py_Void();
10329  return resultobj;
10330 fail:
10331  return NULL;
10332 }
10333 
10334 
10335 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10336  PyObject *resultobj = 0;
10337  PLFLT arg1 ;
10338  PLFLT arg2 ;
10339  PLFLT arg3 ;
10340  PLFLT *arg4 = (PLFLT *) 0 ;
10341  PLFLT *arg5 = (PLFLT *) 0 ;
10342  PLFLT *arg6 = (PLFLT *) 0 ;
10343  double val1 ;
10344  int ecode1 = 0 ;
10345  double val2 ;
10346  int ecode2 = 0 ;
10347  double val3 ;
10348  int ecode3 = 0 ;
10349  PLFLT temp4 ;
10350  int res4 = SWIG_TMPOBJ ;
10351  PLFLT temp5 ;
10352  int res5 = SWIG_TMPOBJ ;
10353  PLFLT temp6 ;
10354  int res6 = SWIG_TMPOBJ ;
10355  PyObject * obj0 = 0 ;
10356  PyObject * obj1 = 0 ;
10357  PyObject * obj2 = 0 ;
10358 
10359  arg4 = &temp4;
10360  arg5 = &temp5;
10361  arg6 = &temp6;
10362  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10363  ecode1 = SWIG_AsVal_double(obj0, &val1);
10364  if (!SWIG_IsOK(ecode1)) {
10365  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10366  }
10367  arg1 = (PLFLT)(val1);
10368  ecode2 = SWIG_AsVal_double(obj1, &val2);
10369  if (!SWIG_IsOK(ecode2)) {
10370  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10371  }
10372  arg2 = (PLFLT)(val2);
10373  ecode3 = SWIG_AsVal_double(obj2, &val3);
10374  if (!SWIG_IsOK(ecode3)) {
10375  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10376  }
10377  arg3 = (PLFLT)(val3);
10378  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10379  resultobj = SWIG_Py_Void();
10380  if (SWIG_IsTmpObj(res4)) {
10381  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10382  } else {
10383  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10384  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10385  }
10386  if (SWIG_IsTmpObj(res5)) {
10387  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10388  } else {
10389  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10390  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10391  }
10392  if (SWIG_IsTmpObj(res6)) {
10393  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10394  } else {
10395  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10396  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10397  }
10398  return resultobj;
10399 fail:
10400  return NULL;
10401 }
10402 
10403 
10404 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10405  PyObject *resultobj = 0;
10406  PLFLT arg1 ;
10407  PLFLT arg2 ;
10408  double val1 ;
10409  int ecode1 = 0 ;
10410  double val2 ;
10411  int ecode2 = 0 ;
10412  PyObject * obj0 = 0 ;
10413  PyObject * obj1 = 0 ;
10414 
10415  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10416  ecode1 = SWIG_AsVal_double(obj0, &val1);
10417  if (!SWIG_IsOK(ecode1)) {
10418  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10419  }
10420  arg1 = (PLFLT)(val1);
10421  ecode2 = SWIG_AsVal_double(obj1, &val2);
10422  if (!SWIG_IsOK(ecode2)) {
10423  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10424  }
10425  arg2 = (PLFLT)(val2);
10426  plschr(arg1,arg2);
10427  resultobj = SWIG_Py_Void();
10428  return resultobj;
10429 fail:
10430  return NULL;
10431 }
10432 
10433 
10434 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435  PyObject *resultobj = 0;
10436  PLINT *arg1 = (PLINT *) 0 ;
10437  PLINT *arg2 = (PLINT *) 0 ;
10438  PLINT *arg3 = (PLINT *) 0 ;
10439  PLINT arg4 ;
10440  PyArrayObject *tmp1 = NULL ;
10441  PyArrayObject *tmp2 = NULL ;
10442  PyArrayObject *tmp3 = NULL ;
10443  PyObject * obj0 = 0 ;
10444  PyObject * obj1 = 0 ;
10445  PyObject * obj2 = 0 ;
10446 
10447  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10448  {
10449  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10450  if ( tmp1 == NULL )
10451  return NULL;
10452  Alen = PyArray_DIMS( tmp1 )[0];
10453  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10454  }
10455  {
10456  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10457  if ( tmp2 == NULL )
10458  return NULL;
10459  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10460  {
10461  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10462  return NULL;
10463  }
10464  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10465  }
10466  {
10467  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10468  if ( tmp3 == NULL )
10469  return NULL;
10470  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10471  {
10472  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10473  return NULL;
10474  }
10475  arg4 = PyArray_DIMS( tmp3 )[0];
10476  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10477  }
10478  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10479  resultobj = SWIG_Py_Void();
10480  {
10481  Py_CLEAR( tmp1 );
10482  }
10483  {
10484  Py_CLEAR( tmp2 );
10485  }
10486  {
10487  Py_CLEAR( tmp3 );
10488  }
10489  return resultobj;
10490 fail:
10491  {
10492  Py_CLEAR( tmp1 );
10493  }
10494  {
10495  Py_CLEAR( tmp2 );
10496  }
10497  {
10498  Py_CLEAR( tmp3 );
10499  }
10500  return NULL;
10501 }
10502 
10503 
10504 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10505  PyObject *resultobj = 0;
10506  PLINT *arg1 = (PLINT *) 0 ;
10507  PLINT *arg2 = (PLINT *) 0 ;
10508  PLINT *arg3 = (PLINT *) 0 ;
10509  PLFLT *arg4 = (PLFLT *) 0 ;
10510  PLINT arg5 ;
10511  PyArrayObject *tmp1 = NULL ;
10512  PyArrayObject *tmp2 = NULL ;
10513  PyArrayObject *tmp3 = NULL ;
10514  PyArrayObject *tmp4 = NULL ;
10515  PyObject * obj0 = 0 ;
10516  PyObject * obj1 = 0 ;
10517  PyObject * obj2 = 0 ;
10518  PyObject * obj3 = 0 ;
10519 
10520  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10521  {
10522  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10523  if ( tmp1 == NULL )
10524  return NULL;
10525  Alen = PyArray_DIMS( tmp1 )[0];
10526  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10527  }
10528  {
10529  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10530  if ( tmp2 == NULL )
10531  return NULL;
10532  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10533  {
10534  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10535  return NULL;
10536  }
10537  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10538  }
10539  {
10540  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10541  if ( tmp3 == NULL )
10542  return NULL;
10543  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10544  {
10545  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10546  return NULL;
10547  }
10548  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10549  }
10550  {
10551  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10552  if ( tmp4 == NULL )
10553  return NULL;
10554  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10555  {
10556  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10557  return NULL;
10558  }
10559  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10560  arg5 = PyArray_DIMS( tmp4 )[0];
10561  }
10562  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10563  resultobj = SWIG_Py_Void();
10564  {
10565  Py_CLEAR( tmp1 );
10566  }
10567  {
10568  Py_CLEAR( tmp2 );
10569  }
10570  {
10571  Py_CLEAR( tmp3 );
10572  }
10573  {
10574  Py_CLEAR( tmp4 );
10575  }
10576  return resultobj;
10577 fail:
10578  {
10579  Py_CLEAR( tmp1 );
10580  }
10581  {
10582  Py_CLEAR( tmp2 );
10583  }
10584  {
10585  Py_CLEAR( tmp3 );
10586  }
10587  {
10588  Py_CLEAR( tmp4 );
10589  }
10590  return NULL;
10591 }
10592 
10593 
10594 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10595  PyObject *resultobj = 0;
10596  PLINT arg1 ;
10597  int val1 ;
10598  int ecode1 = 0 ;
10599  PyObject * obj0 = 0 ;
10600 
10601  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10602  ecode1 = SWIG_AsVal_int(obj0, &val1);
10603  if (!SWIG_IsOK(ecode1)) {
10604  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10605  }
10606  arg1 = (PLINT)(val1);
10607  plscmap0n(arg1);
10608  resultobj = SWIG_Py_Void();
10609  return resultobj;
10610 fail:
10611  return NULL;
10612 }
10613 
10614 
10615 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10616  PyObject *resultobj = 0;
10617  PLINT *arg1 = (PLINT *) 0 ;
10618  PLINT *arg2 = (PLINT *) 0 ;
10619  PLINT *arg3 = (PLINT *) 0 ;
10620  PLINT arg4 ;
10621  PyArrayObject *tmp1 = NULL ;
10622  PyArrayObject *tmp2 = NULL ;
10623  PyArrayObject *tmp3 = NULL ;
10624  PyObject * obj0 = 0 ;
10625  PyObject * obj1 = 0 ;
10626  PyObject * obj2 = 0 ;
10627 
10628  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10629  {
10630  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10631  if ( tmp1 == NULL )
10632  return NULL;
10633  Alen = PyArray_DIMS( tmp1 )[0];
10634  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10635  }
10636  {
10637  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10638  if ( tmp2 == NULL )
10639  return NULL;
10640  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10641  {
10642  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10643  return NULL;
10644  }
10645  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10646  }
10647  {
10648  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10649  if ( tmp3 == NULL )
10650  return NULL;
10651  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10652  {
10653  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10654  return NULL;
10655  }
10656  arg4 = PyArray_DIMS( tmp3 )[0];
10657  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10658  }
10659  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10660  resultobj = SWIG_Py_Void();
10661  {
10662  Py_CLEAR( tmp1 );
10663  }
10664  {
10665  Py_CLEAR( tmp2 );
10666  }
10667  {
10668  Py_CLEAR( tmp3 );
10669  }
10670  return resultobj;
10671 fail:
10672  {
10673  Py_CLEAR( tmp1 );
10674  }
10675  {
10676  Py_CLEAR( tmp2 );
10677  }
10678  {
10679  Py_CLEAR( tmp3 );
10680  }
10681  return NULL;
10682 }
10683 
10684 
10685 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10686  PyObject *resultobj = 0;
10687  PLINT *arg1 = (PLINT *) 0 ;
10688  PLINT *arg2 = (PLINT *) 0 ;
10689  PLINT *arg3 = (PLINT *) 0 ;
10690  PLFLT *arg4 = (PLFLT *) 0 ;
10691  PLINT arg5 ;
10692  PyArrayObject *tmp1 = NULL ;
10693  PyArrayObject *tmp2 = NULL ;
10694  PyArrayObject *tmp3 = NULL ;
10695  PyArrayObject *tmp4 = NULL ;
10696  PyObject * obj0 = 0 ;
10697  PyObject * obj1 = 0 ;
10698  PyObject * obj2 = 0 ;
10699  PyObject * obj3 = 0 ;
10700 
10701  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10702  {
10703  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10704  if ( tmp1 == NULL )
10705  return NULL;
10706  Alen = PyArray_DIMS( tmp1 )[0];
10707  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10708  }
10709  {
10710  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10711  if ( tmp2 == NULL )
10712  return NULL;
10713  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10714  {
10715  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10716  return NULL;
10717  }
10718  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10719  }
10720  {
10721  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10722  if ( tmp3 == NULL )
10723  return NULL;
10724  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10725  {
10726  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10727  return NULL;
10728  }
10729  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10730  }
10731  {
10732  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10733  if ( tmp4 == NULL )
10734  return NULL;
10735  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10736  {
10737  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10738  return NULL;
10739  }
10740  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10741  arg5 = PyArray_DIMS( tmp4 )[0];
10742  }
10743  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10744  resultobj = SWIG_Py_Void();
10745  {
10746  Py_CLEAR( tmp1 );
10747  }
10748  {
10749  Py_CLEAR( tmp2 );
10750  }
10751  {
10752  Py_CLEAR( tmp3 );
10753  }
10754  {
10755  Py_CLEAR( tmp4 );
10756  }
10757  return resultobj;
10758 fail:
10759  {
10760  Py_CLEAR( tmp1 );
10761  }
10762  {
10763  Py_CLEAR( tmp2 );
10764  }
10765  {
10766  Py_CLEAR( tmp3 );
10767  }
10768  {
10769  Py_CLEAR( tmp4 );
10770  }
10771  return NULL;
10772 }
10773 
10774 
10775 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10776  PyObject *resultobj = 0;
10777  PLBOOL arg1 ;
10778  PLINT arg2 ;
10779  PLFLT *arg3 = (PLFLT *) 0 ;
10780  PLFLT *arg4 = (PLFLT *) 0 ;
10781  PLFLT *arg5 = (PLFLT *) 0 ;
10782  PLFLT *arg6 = (PLFLT *) 0 ;
10783  PLBOOL *arg7 = (PLBOOL *) 0 ;
10784  int val1 ;
10785  int ecode1 = 0 ;
10786  PyArrayObject *tmp2 = NULL ;
10787  PyArrayObject *tmp4 = NULL ;
10788  PyArrayObject *tmp5 = NULL ;
10789  PyArrayObject *tmp6 = NULL ;
10790  PyArrayObject *tmp7 = NULL ;
10791  PyObject * obj0 = 0 ;
10792  PyObject * obj1 = 0 ;
10793  PyObject * obj2 = 0 ;
10794  PyObject * obj3 = 0 ;
10795  PyObject * obj4 = 0 ;
10796  PyObject * obj5 = 0 ;
10797 
10798  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10799  ecode1 = SWIG_AsVal_int(obj0, &val1);
10800  if (!SWIG_IsOK(ecode1)) {
10801  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10802  }
10803  arg1 = (PLBOOL)(val1);
10804  {
10805  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10806  if ( tmp2 == NULL )
10807  return NULL;
10808  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10809  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10810  }
10811  {
10812  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10813  if ( tmp4 == NULL )
10814  return NULL;
10815  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10816  {
10817  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10818  return NULL;
10819  }
10820  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10821  }
10822  {
10823  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10824  if ( tmp5 == NULL )
10825  return NULL;
10826  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10827  {
10828  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10829  return NULL;
10830  }
10831  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10832  }
10833  {
10834  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10835  if ( tmp6 == NULL )
10836  return NULL;
10837  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10838  {
10839  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10840  return NULL;
10841  }
10842  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10843  }
10844  {
10845  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10846  if ( tmp7 == NULL )
10847  return NULL;
10848  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10849  {
10850  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10851  return NULL;
10852  }
10853  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10854  }
10855  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10856  resultobj = SWIG_Py_Void();
10857  {
10858  Py_CLEAR( tmp2 );
10859  }
10860  {
10861  Py_CLEAR( tmp4 );
10862  }
10863  {
10864  Py_CLEAR( tmp5 );
10865  }
10866  {
10867  Py_CLEAR( tmp6 );
10868  }
10869  {
10870  Py_CLEAR( tmp7 );
10871  }
10872  return resultobj;
10873 fail:
10874  {
10875  Py_CLEAR( tmp2 );
10876  }
10877  {
10878  Py_CLEAR( tmp4 );
10879  }
10880  {
10881  Py_CLEAR( tmp5 );
10882  }
10883  {
10884  Py_CLEAR( tmp6 );
10885  }
10886  {
10887  Py_CLEAR( tmp7 );
10888  }
10889  return NULL;
10890 }
10891 
10892 
10893 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10894  PyObject *resultobj = 0;
10895  PLBOOL arg1 ;
10896  PLINT arg2 ;
10897  PLFLT *arg3 = (PLFLT *) 0 ;
10898  PLFLT *arg4 = (PLFLT *) 0 ;
10899  PLFLT *arg5 = (PLFLT *) 0 ;
10900  PLFLT *arg6 = (PLFLT *) 0 ;
10901  PLFLT *arg7 = (PLFLT *) 0 ;
10902  PLBOOL *arg8 = (PLBOOL *) 0 ;
10903  int val1 ;
10904  int ecode1 = 0 ;
10905  PyArrayObject *tmp2 = NULL ;
10906  PyArrayObject *tmp4 = NULL ;
10907  PyArrayObject *tmp5 = NULL ;
10908  PyArrayObject *tmp6 = NULL ;
10909  PyArrayObject *tmp7 = NULL ;
10910  PyArrayObject *tmp8 = NULL ;
10911  PyObject * obj0 = 0 ;
10912  PyObject * obj1 = 0 ;
10913  PyObject * obj2 = 0 ;
10914  PyObject * obj3 = 0 ;
10915  PyObject * obj4 = 0 ;
10916  PyObject * obj5 = 0 ;
10917  PyObject * obj6 = 0 ;
10918 
10919  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10920  ecode1 = SWIG_AsVal_int(obj0, &val1);
10921  if (!SWIG_IsOK(ecode1)) {
10922  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10923  }
10924  arg1 = (PLBOOL)(val1);
10925  {
10926  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10927  if ( tmp2 == NULL )
10928  return NULL;
10929  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10930  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10931  }
10932  {
10933  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10934  if ( tmp4 == NULL )
10935  return NULL;
10936  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10937  {
10938  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10939  return NULL;
10940  }
10941  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10942  }
10943  {
10944  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10945  if ( tmp5 == NULL )
10946  return NULL;
10947  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10948  {
10949  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10950  return NULL;
10951  }
10952  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10953  }
10954  {
10955  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10956  if ( tmp6 == NULL )
10957  return NULL;
10958  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10959  {
10960  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10961  return NULL;
10962  }
10963  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10964  }
10965  {
10966  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10967  if ( tmp7 == NULL )
10968  return NULL;
10969  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10970  {
10971  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10972  return NULL;
10973  }
10974  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10975  }
10976  {
10977  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10978  if ( tmp8 == NULL )
10979  return NULL;
10980  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10981  {
10982  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10983  return NULL;
10984  }
10985  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10986  }
10987  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10988  resultobj = SWIG_Py_Void();
10989  {
10990  Py_CLEAR( tmp2 );
10991  }
10992  {
10993  Py_CLEAR( tmp4 );
10994  }
10995  {
10996  Py_CLEAR( tmp5 );
10997  }
10998  {
10999  Py_CLEAR( tmp6 );
11000  }
11001  {
11002  Py_CLEAR( tmp7 );
11003  }
11004  {
11005  Py_CLEAR( tmp8 );
11006  }
11007  return resultobj;
11008 fail:
11009  {
11010  Py_CLEAR( tmp2 );
11011  }
11012  {
11013  Py_CLEAR( tmp4 );
11014  }
11015  {
11016  Py_CLEAR( tmp5 );
11017  }
11018  {
11019  Py_CLEAR( tmp6 );
11020  }
11021  {
11022  Py_CLEAR( tmp7 );
11023  }
11024  {
11025  Py_CLEAR( tmp8 );
11026  }
11027  return NULL;
11028 }
11029 
11030 
11031 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11032  PyObject *resultobj = 0;
11033  PLINT arg1 ;
11034  int val1 ;
11035  int ecode1 = 0 ;
11036  PyObject * obj0 = 0 ;
11037 
11038  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11039  ecode1 = SWIG_AsVal_int(obj0, &val1);
11040  if (!SWIG_IsOK(ecode1)) {
11041  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11042  }
11043  arg1 = (PLINT)(val1);
11044  plscmap1n(arg1);
11045  resultobj = SWIG_Py_Void();
11046  return resultobj;
11047 fail:
11048  return NULL;
11049 }
11050 
11051 
11052 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11053  PyObject *resultobj = 0;
11054  PLFLT arg1 ;
11055  PLFLT arg2 ;
11056  double val1 ;
11057  int ecode1 = 0 ;
11058  double val2 ;
11059  int ecode2 = 0 ;
11060  PyObject * obj0 = 0 ;
11061  PyObject * obj1 = 0 ;
11062 
11063  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11064  ecode1 = SWIG_AsVal_double(obj0, &val1);
11065  if (!SWIG_IsOK(ecode1)) {
11066  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11067  }
11068  arg1 = (PLFLT)(val1);
11069  ecode2 = SWIG_AsVal_double(obj1, &val2);
11070  if (!SWIG_IsOK(ecode2)) {
11071  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11072  }
11073  arg2 = (PLFLT)(val2);
11074  plscmap1_range(arg1,arg2);
11075  resultobj = SWIG_Py_Void();
11076  return resultobj;
11077 fail:
11078  return NULL;
11079 }
11080 
11081 
11082 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083  PyObject *resultobj = 0;
11084  PLFLT *arg1 = (PLFLT *) 0 ;
11085  PLFLT *arg2 = (PLFLT *) 0 ;
11086  PLFLT temp1 ;
11087  int res1 = SWIG_TMPOBJ ;
11088  PLFLT temp2 ;
11089  int res2 = SWIG_TMPOBJ ;
11090 
11091  arg1 = &temp1;
11092  arg2 = &temp2;
11093  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11094  plgcmap1_range(arg1,arg2);
11095  resultobj = SWIG_Py_Void();
11096  if (SWIG_IsTmpObj(res1)) {
11097  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11098  } else {
11099  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11100  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11101  }
11102  if (SWIG_IsTmpObj(res2)) {
11103  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11104  } else {
11105  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11106  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11107  }
11108  return resultobj;
11109 fail:
11110  return NULL;
11111 }
11112 
11113 
11114 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11115  PyObject *resultobj = 0;
11116  PLINT arg1 ;
11117  PLINT arg2 ;
11118  PLINT arg3 ;
11119  PLINT arg4 ;
11120  int val1 ;
11121  int ecode1 = 0 ;
11122  int val2 ;
11123  int ecode2 = 0 ;
11124  int val3 ;
11125  int ecode3 = 0 ;
11126  int val4 ;
11127  int ecode4 = 0 ;
11128  PyObject * obj0 = 0 ;
11129  PyObject * obj1 = 0 ;
11130  PyObject * obj2 = 0 ;
11131  PyObject * obj3 = 0 ;
11132 
11133  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11134  ecode1 = SWIG_AsVal_int(obj0, &val1);
11135  if (!SWIG_IsOK(ecode1)) {
11136  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11137  }
11138  arg1 = (PLINT)(val1);
11139  ecode2 = SWIG_AsVal_int(obj1, &val2);
11140  if (!SWIG_IsOK(ecode2)) {
11141  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11142  }
11143  arg2 = (PLINT)(val2);
11144  ecode3 = SWIG_AsVal_int(obj2, &val3);
11145  if (!SWIG_IsOK(ecode3)) {
11146  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11147  }
11148  arg3 = (PLINT)(val3);
11149  ecode4 = SWIG_AsVal_int(obj3, &val4);
11150  if (!SWIG_IsOK(ecode4)) {
11151  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11152  }
11153  arg4 = (PLINT)(val4);
11154  plscol0(arg1,arg2,arg3,arg4);
11155  resultobj = SWIG_Py_Void();
11156  return resultobj;
11157 fail:
11158  return NULL;
11159 }
11160 
11161 
11162 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163  PyObject *resultobj = 0;
11164  PLINT arg1 ;
11165  PLINT arg2 ;
11166  PLINT arg3 ;
11167  PLINT arg4 ;
11168  PLFLT arg5 ;
11169  int val1 ;
11170  int ecode1 = 0 ;
11171  int val2 ;
11172  int ecode2 = 0 ;
11173  int val3 ;
11174  int ecode3 = 0 ;
11175  int val4 ;
11176  int ecode4 = 0 ;
11177  double val5 ;
11178  int ecode5 = 0 ;
11179  PyObject * obj0 = 0 ;
11180  PyObject * obj1 = 0 ;
11181  PyObject * obj2 = 0 ;
11182  PyObject * obj3 = 0 ;
11183  PyObject * obj4 = 0 ;
11184 
11185  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11186  ecode1 = SWIG_AsVal_int(obj0, &val1);
11187  if (!SWIG_IsOK(ecode1)) {
11188  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11189  }
11190  arg1 = (PLINT)(val1);
11191  ecode2 = SWIG_AsVal_int(obj1, &val2);
11192  if (!SWIG_IsOK(ecode2)) {
11193  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11194  }
11195  arg2 = (PLINT)(val2);
11196  ecode3 = SWIG_AsVal_int(obj2, &val3);
11197  if (!SWIG_IsOK(ecode3)) {
11198  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11199  }
11200  arg3 = (PLINT)(val3);
11201  ecode4 = SWIG_AsVal_int(obj3, &val4);
11202  if (!SWIG_IsOK(ecode4)) {
11203  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11204  }
11205  arg4 = (PLINT)(val4);
11206  ecode5 = SWIG_AsVal_double(obj4, &val5);
11207  if (!SWIG_IsOK(ecode5)) {
11208  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11209  }
11210  arg5 = (PLFLT)(val5);
11211  plscol0a(arg1,arg2,arg3,arg4,arg5);
11212  resultobj = SWIG_Py_Void();
11213  return resultobj;
11214 fail:
11215  return NULL;
11216 }
11217 
11218 
11219 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11220  PyObject *resultobj = 0;
11221  PLINT arg1 ;
11222  PLINT arg2 ;
11223  PLINT arg3 ;
11224  int val1 ;
11225  int ecode1 = 0 ;
11226  int val2 ;
11227  int ecode2 = 0 ;
11228  int val3 ;
11229  int ecode3 = 0 ;
11230  PyObject * obj0 = 0 ;
11231  PyObject * obj1 = 0 ;
11232  PyObject * obj2 = 0 ;
11233 
11234  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11235  ecode1 = SWIG_AsVal_int(obj0, &val1);
11236  if (!SWIG_IsOK(ecode1)) {
11237  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11238  }
11239  arg1 = (PLINT)(val1);
11240  ecode2 = SWIG_AsVal_int(obj1, &val2);
11241  if (!SWIG_IsOK(ecode2)) {
11242  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11243  }
11244  arg2 = (PLINT)(val2);
11245  ecode3 = SWIG_AsVal_int(obj2, &val3);
11246  if (!SWIG_IsOK(ecode3)) {
11247  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11248  }
11249  arg3 = (PLINT)(val3);
11250  plscolbg(arg1,arg2,arg3);
11251  resultobj = SWIG_Py_Void();
11252  return resultobj;
11253 fail:
11254  return NULL;
11255 }
11256 
11257 
11258 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11259  PyObject *resultobj = 0;
11260  PLINT arg1 ;
11261  PLINT arg2 ;
11262  PLINT arg3 ;
11263  PLFLT arg4 ;
11264  int val1 ;
11265  int ecode1 = 0 ;
11266  int val2 ;
11267  int ecode2 = 0 ;
11268  int val3 ;
11269  int ecode3 = 0 ;
11270  double val4 ;
11271  int ecode4 = 0 ;
11272  PyObject * obj0 = 0 ;
11273  PyObject * obj1 = 0 ;
11274  PyObject * obj2 = 0 ;
11275  PyObject * obj3 = 0 ;
11276 
11277  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11278  ecode1 = SWIG_AsVal_int(obj0, &val1);
11279  if (!SWIG_IsOK(ecode1)) {
11280  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11281  }
11282  arg1 = (PLINT)(val1);
11283  ecode2 = SWIG_AsVal_int(obj1, &val2);
11284  if (!SWIG_IsOK(ecode2)) {
11285  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11286  }
11287  arg2 = (PLINT)(val2);
11288  ecode3 = SWIG_AsVal_int(obj2, &val3);
11289  if (!SWIG_IsOK(ecode3)) {
11290  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11291  }
11292  arg3 = (PLINT)(val3);
11293  ecode4 = SWIG_AsVal_double(obj3, &val4);
11294  if (!SWIG_IsOK(ecode4)) {
11295  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11296  }
11297  arg4 = (PLFLT)(val4);
11298  plscolbga(arg1,arg2,arg3,arg4);
11299  resultobj = SWIG_Py_Void();
11300  return resultobj;
11301 fail:
11302  return NULL;
11303 }
11304 
11305 
11306 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11307  PyObject *resultobj = 0;
11308  PLINT arg1 ;
11309  int val1 ;
11310  int ecode1 = 0 ;
11311  PyObject * obj0 = 0 ;
11312 
11313  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11314  ecode1 = SWIG_AsVal_int(obj0, &val1);
11315  if (!SWIG_IsOK(ecode1)) {
11316  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11317  }
11318  arg1 = (PLINT)(val1);
11319  plscolor(arg1);
11320  resultobj = SWIG_Py_Void();
11321  return resultobj;
11322 fail:
11323  return NULL;
11324 }
11325 
11326 
11327 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11328  PyObject *resultobj = 0;
11329  PLINT arg1 ;
11330  int val1 ;
11331  int ecode1 = 0 ;
11332  PyObject * obj0 = 0 ;
11333 
11334  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11335  ecode1 = SWIG_AsVal_int(obj0, &val1);
11336  if (!SWIG_IsOK(ecode1)) {
11337  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11338  }
11339  arg1 = (PLINT)(val1);
11340  plscompression(arg1);
11341  resultobj = SWIG_Py_Void();
11342  return resultobj;
11343 fail:
11344  return NULL;
11345 }
11346 
11347 
11348 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11349  PyObject *resultobj = 0;
11350  char *arg1 = (char *) 0 ;
11351  int res1 ;
11352  char *buf1 = 0 ;
11353  int alloc1 = 0 ;
11354  PyObject * obj0 = 0 ;
11355 
11356  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11357  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11358  if (!SWIG_IsOK(res1)) {
11359  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11360  }
11361  arg1 = (char *)(buf1);
11362  plsdev((char const *)arg1);
11363  resultobj = SWIG_Py_Void();
11364  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11365  return resultobj;
11366 fail:
11367  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11368  return NULL;
11369 }
11370 
11371 
11372 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11373  PyObject *resultobj = 0;
11374  PLFLT arg1 ;
11375  PLFLT arg2 ;
11376  PLFLT arg3 ;
11377  PLFLT arg4 ;
11378  double val1 ;
11379  int ecode1 = 0 ;
11380  double val2 ;
11381  int ecode2 = 0 ;
11382  double val3 ;
11383  int ecode3 = 0 ;
11384  double val4 ;
11385  int ecode4 = 0 ;
11386  PyObject * obj0 = 0 ;
11387  PyObject * obj1 = 0 ;
11388  PyObject * obj2 = 0 ;
11389  PyObject * obj3 = 0 ;
11390 
11391  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11392  ecode1 = SWIG_AsVal_double(obj0, &val1);
11393  if (!SWIG_IsOK(ecode1)) {
11394  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11395  }
11396  arg1 = (PLFLT)(val1);
11397  ecode2 = SWIG_AsVal_double(obj1, &val2);
11398  if (!SWIG_IsOK(ecode2)) {
11399  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11400  }
11401  arg2 = (PLFLT)(val2);
11402  ecode3 = SWIG_AsVal_double(obj2, &val3);
11403  if (!SWIG_IsOK(ecode3)) {
11404  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11405  }
11406  arg3 = (PLFLT)(val3);
11407  ecode4 = SWIG_AsVal_double(obj3, &val4);
11408  if (!SWIG_IsOK(ecode4)) {
11409  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11410  }
11411  arg4 = (PLFLT)(val4);
11412  plsdidev(arg1,arg2,arg3,arg4);
11413  resultobj = SWIG_Py_Void();
11414  return resultobj;
11415 fail:
11416  return NULL;
11417 }
11418 
11419 
11420 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421  PyObject *resultobj = 0;
11422  PLINT arg1 ;
11423  PLINT arg2 ;
11424  PLINT arg3 ;
11425  PLINT arg4 ;
11426  PLFLT arg5 ;
11427  PLFLT arg6 ;
11428  int val1 ;
11429  int ecode1 = 0 ;
11430  int val2 ;
11431  int ecode2 = 0 ;
11432  int val3 ;
11433  int ecode3 = 0 ;
11434  int val4 ;
11435  int ecode4 = 0 ;
11436  double val5 ;
11437  int ecode5 = 0 ;
11438  double val6 ;
11439  int ecode6 = 0 ;
11440  PyObject * obj0 = 0 ;
11441  PyObject * obj1 = 0 ;
11442  PyObject * obj2 = 0 ;
11443  PyObject * obj3 = 0 ;
11444  PyObject * obj4 = 0 ;
11445  PyObject * obj5 = 0 ;
11446 
11447  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11448  ecode1 = SWIG_AsVal_int(obj0, &val1);
11449  if (!SWIG_IsOK(ecode1)) {
11450  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11451  }
11452  arg1 = (PLINT)(val1);
11453  ecode2 = SWIG_AsVal_int(obj1, &val2);
11454  if (!SWIG_IsOK(ecode2)) {
11455  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11456  }
11457  arg2 = (PLINT)(val2);
11458  ecode3 = SWIG_AsVal_int(obj2, &val3);
11459  if (!SWIG_IsOK(ecode3)) {
11460  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11461  }
11462  arg3 = (PLINT)(val3);
11463  ecode4 = SWIG_AsVal_int(obj3, &val4);
11464  if (!SWIG_IsOK(ecode4)) {
11465  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11466  }
11467  arg4 = (PLINT)(val4);
11468  ecode5 = SWIG_AsVal_double(obj4, &val5);
11469  if (!SWIG_IsOK(ecode5)) {
11470  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11471  }
11472  arg5 = (PLFLT)(val5);
11473  ecode6 = SWIG_AsVal_double(obj5, &val6);
11474  if (!SWIG_IsOK(ecode6)) {
11475  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11476  }
11477  arg6 = (PLFLT)(val6);
11478  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11479  resultobj = SWIG_Py_Void();
11480  return resultobj;
11481 fail:
11482  return NULL;
11483 }
11484 
11485 
11486 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11487  PyObject *resultobj = 0;
11488  PLFLT arg1 ;
11489  double val1 ;
11490  int ecode1 = 0 ;
11491  PyObject * obj0 = 0 ;
11492 
11493  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11494  ecode1 = SWIG_AsVal_double(obj0, &val1);
11495  if (!SWIG_IsOK(ecode1)) {
11496  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11497  }
11498  arg1 = (PLFLT)(val1);
11499  plsdiori(arg1);
11500  resultobj = SWIG_Py_Void();
11501  return resultobj;
11502 fail:
11503  return NULL;
11504 }
11505 
11506 
11507 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11508  PyObject *resultobj = 0;
11509  PLFLT arg1 ;
11510  PLFLT arg2 ;
11511  PLFLT arg3 ;
11512  PLFLT arg4 ;
11513  double val1 ;
11514  int ecode1 = 0 ;
11515  double val2 ;
11516  int ecode2 = 0 ;
11517  double val3 ;
11518  int ecode3 = 0 ;
11519  double val4 ;
11520  int ecode4 = 0 ;
11521  PyObject * obj0 = 0 ;
11522  PyObject * obj1 = 0 ;
11523  PyObject * obj2 = 0 ;
11524  PyObject * obj3 = 0 ;
11525 
11526  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11527  ecode1 = SWIG_AsVal_double(obj0, &val1);
11528  if (!SWIG_IsOK(ecode1)) {
11529  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11530  }
11531  arg1 = (PLFLT)(val1);
11532  ecode2 = SWIG_AsVal_double(obj1, &val2);
11533  if (!SWIG_IsOK(ecode2)) {
11534  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11535  }
11536  arg2 = (PLFLT)(val2);
11537  ecode3 = SWIG_AsVal_double(obj2, &val3);
11538  if (!SWIG_IsOK(ecode3)) {
11539  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11540  }
11541  arg3 = (PLFLT)(val3);
11542  ecode4 = SWIG_AsVal_double(obj3, &val4);
11543  if (!SWIG_IsOK(ecode4)) {
11544  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11545  }
11546  arg4 = (PLFLT)(val4);
11547  plsdiplt(arg1,arg2,arg3,arg4);
11548  resultobj = SWIG_Py_Void();
11549  return resultobj;
11550 fail:
11551  return NULL;
11552 }
11553 
11554 
11555 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11556  PyObject *resultobj = 0;
11557  PLFLT arg1 ;
11558  PLFLT arg2 ;
11559  PLFLT arg3 ;
11560  PLFLT arg4 ;
11561  double val1 ;
11562  int ecode1 = 0 ;
11563  double val2 ;
11564  int ecode2 = 0 ;
11565  double val3 ;
11566  int ecode3 = 0 ;
11567  double val4 ;
11568  int ecode4 = 0 ;
11569  PyObject * obj0 = 0 ;
11570  PyObject * obj1 = 0 ;
11571  PyObject * obj2 = 0 ;
11572  PyObject * obj3 = 0 ;
11573 
11574  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11575  ecode1 = SWIG_AsVal_double(obj0, &val1);
11576  if (!SWIG_IsOK(ecode1)) {
11577  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11578  }
11579  arg1 = (PLFLT)(val1);
11580  ecode2 = SWIG_AsVal_double(obj1, &val2);
11581  if (!SWIG_IsOK(ecode2)) {
11582  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11583  }
11584  arg2 = (PLFLT)(val2);
11585  ecode3 = SWIG_AsVal_double(obj2, &val3);
11586  if (!SWIG_IsOK(ecode3)) {
11587  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11588  }
11589  arg3 = (PLFLT)(val3);
11590  ecode4 = SWIG_AsVal_double(obj3, &val4);
11591  if (!SWIG_IsOK(ecode4)) {
11592  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11593  }
11594  arg4 = (PLFLT)(val4);
11595  plsdiplz(arg1,arg2,arg3,arg4);
11596  resultobj = SWIG_Py_Void();
11597  return resultobj;
11598 fail:
11599  return NULL;
11600 }
11601 
11602 
11603 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11604  PyObject *resultobj = 0;
11605  unsigned int arg1 ;
11606  unsigned int val1 ;
11607  int ecode1 = 0 ;
11608  PyObject * obj0 = 0 ;
11609 
11610  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11611  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11612  if (!SWIG_IsOK(ecode1)) {
11613  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11614  }
11615  arg1 = (unsigned int)(val1);
11616  plseed(arg1);
11617  resultobj = SWIG_Py_Void();
11618  return resultobj;
11619 fail:
11620  return NULL;
11621 }
11622 
11623 
11624 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11625  PyObject *resultobj = 0;
11626  char arg1 ;
11627  char val1 ;
11628  int ecode1 = 0 ;
11629  PyObject * obj0 = 0 ;
11630 
11631  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11632  ecode1 = SWIG_AsVal_char(obj0, &val1);
11633  if (!SWIG_IsOK(ecode1)) {
11634  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11635  }
11636  arg1 = (char)(val1);
11637  plsesc(arg1);
11638  resultobj = SWIG_Py_Void();
11639  return resultobj;
11640 fail:
11641  return NULL;
11642 }
11643 
11644 
11645 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646  PyObject *resultobj = 0;
11647  char *arg1 = (char *) 0 ;
11648  char *arg2 = (char *) 0 ;
11649  int res1 ;
11650  char *buf1 = 0 ;
11651  int alloc1 = 0 ;
11652  int res2 ;
11653  char *buf2 = 0 ;
11654  int alloc2 = 0 ;
11655  PyObject * obj0 = 0 ;
11656  PyObject * obj1 = 0 ;
11657  PLINT result;
11658 
11659  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11660  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11661  if (!SWIG_IsOK(res1)) {
11662  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11663  }
11664  arg1 = (char *)(buf1);
11665  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11666  if (!SWIG_IsOK(res2)) {
11667  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11668  }
11669  arg2 = (char *)(buf2);
11670  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11671  resultobj = SWIG_From_int((int)(result));
11672  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11673  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11674  return resultobj;
11675 fail:
11676  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11677  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11678  return NULL;
11679 }
11680 
11681 
11682 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683  PyObject *resultobj = 0;
11684  PLINT arg1 ;
11685  PLINT arg2 ;
11686  PLINT arg3 ;
11687  int val1 ;
11688  int ecode1 = 0 ;
11689  int val2 ;
11690  int ecode2 = 0 ;
11691  int val3 ;
11692  int ecode3 = 0 ;
11693  PyObject * obj0 = 0 ;
11694  PyObject * obj1 = 0 ;
11695  PyObject * obj2 = 0 ;
11696 
11697  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11698  ecode1 = SWIG_AsVal_int(obj0, &val1);
11699  if (!SWIG_IsOK(ecode1)) {
11700  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11701  }
11702  arg1 = (PLINT)(val1);
11703  ecode2 = SWIG_AsVal_int(obj1, &val2);
11704  if (!SWIG_IsOK(ecode2)) {
11705  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11706  }
11707  arg2 = (PLINT)(val2);
11708  ecode3 = SWIG_AsVal_int(obj2, &val3);
11709  if (!SWIG_IsOK(ecode3)) {
11710  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11711  }
11712  arg3 = (PLINT)(val3);
11713  plsfam(arg1,arg2,arg3);
11714  resultobj = SWIG_Py_Void();
11715  return resultobj;
11716 fail:
11717  return NULL;
11718 }
11719 
11720 
11721 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722  PyObject *resultobj = 0;
11723  PLUNICODE arg1 ;
11724  unsigned int val1 ;
11725  int ecode1 = 0 ;
11726  PyObject * obj0 = 0 ;
11727 
11728  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11729  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11730  if (!SWIG_IsOK(ecode1)) {
11731  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11732  }
11733  arg1 = (PLUNICODE)(val1);
11734  plsfci(arg1);
11735  resultobj = SWIG_Py_Void();
11736  return resultobj;
11737 fail:
11738  return NULL;
11739 }
11740 
11741 
11742 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11743  PyObject *resultobj = 0;
11744  char *arg1 = (char *) 0 ;
11745  int res1 ;
11746  char *buf1 = 0 ;
11747  int alloc1 = 0 ;
11748  PyObject * obj0 = 0 ;
11749 
11750  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11751  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11752  if (!SWIG_IsOK(res1)) {
11753  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11754  }
11755  arg1 = (char *)(buf1);
11756  plsfnam((char const *)arg1);
11757  resultobj = SWIG_Py_Void();
11758  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11759  return resultobj;
11760 fail:
11761  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11762  return NULL;
11763 }
11764 
11765 
11766 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767  PyObject *resultobj = 0;
11768  PLINT arg1 ;
11769  PLINT arg2 ;
11770  PLINT arg3 ;
11771  int val1 ;
11772  int ecode1 = 0 ;
11773  int val2 ;
11774  int ecode2 = 0 ;
11775  int val3 ;
11776  int ecode3 = 0 ;
11777  PyObject * obj0 = 0 ;
11778  PyObject * obj1 = 0 ;
11779  PyObject * obj2 = 0 ;
11780 
11781  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11782  ecode1 = SWIG_AsVal_int(obj0, &val1);
11783  if (!SWIG_IsOK(ecode1)) {
11784  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11785  }
11786  arg1 = (PLINT)(val1);
11787  ecode2 = SWIG_AsVal_int(obj1, &val2);
11788  if (!SWIG_IsOK(ecode2)) {
11789  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11790  }
11791  arg2 = (PLINT)(val2);
11792  ecode3 = SWIG_AsVal_int(obj2, &val3);
11793  if (!SWIG_IsOK(ecode3)) {
11794  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11795  }
11796  arg3 = (PLINT)(val3);
11797  plsfont(arg1,arg2,arg3);
11798  resultobj = SWIG_Py_Void();
11799  return resultobj;
11800 fail:
11801  return NULL;
11802 }
11803 
11804 
11805 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11806  PyObject *resultobj = 0;
11807  PLFLT **arg1 = (PLFLT **) 0 ;
11808  PLINT arg2 ;
11809  PLINT arg3 ;
11810  defined_func arg4 = (defined_func) 0 ;
11811  PLFLT arg5 ;
11812  PLFLT arg6 ;
11813  PLFLT arg7 ;
11814  PLFLT arg8 ;
11815  PLFLT *arg9 = (PLFLT *) 0 ;
11816  PLINT arg10 ;
11817  PLFLT arg11 ;
11818  PLINT arg12 ;
11819  PLFLT arg13 ;
11820  fill_func arg14 = (fill_func) 0 ;
11821  PLBOOL arg15 ;
11822  pltr_func arg16 = (pltr_func) 0 ;
11823  PLPointer arg17 = (PLPointer) 0 ;
11824  PyArrayObject *tmp1 = NULL ;
11825  double val5 ;
11826  int ecode5 = 0 ;
11827  double val6 ;
11828  int ecode6 = 0 ;
11829  double val7 ;
11830  int ecode7 = 0 ;
11831  double val8 ;
11832  int ecode8 = 0 ;
11833  PyArrayObject *tmp9 = NULL ;
11834  double val11 ;
11835  int ecode11 = 0 ;
11836  int val12 ;
11837  int ecode12 = 0 ;
11838  double val13 ;
11839  int ecode13 = 0 ;
11840  int val15 ;
11841  int ecode15 = 0 ;
11842  PyObject * obj0 = 0 ;
11843  PyObject * obj1 = 0 ;
11844  PyObject * obj2 = 0 ;
11845  PyObject * obj3 = 0 ;
11846  PyObject * obj4 = 0 ;
11847  PyObject * obj5 = 0 ;
11848  PyObject * obj6 = 0 ;
11849  PyObject * obj7 = 0 ;
11850  PyObject * obj8 = 0 ;
11851  PyObject * obj9 = 0 ;
11852  PyObject * obj10 = 0 ;
11853  PyObject * obj11 = 0 ;
11854 
11855  {
11856  python_pltr = 0;
11857  arg16 = NULL;
11858  }
11859  {
11860  arg17 = NULL;
11861  }
11862  {
11863  arg4 = NULL;
11864  }
11865  {
11866  arg14 = plfill;
11867  }
11868  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11869  {
11870  int i, size;
11871  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11872  if ( tmp1 == NULL )
11873  return NULL;
11874  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11875  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11876  size = arg3;
11877  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11878  for ( i = 0; i < arg2; i++ )
11879  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11880  }
11881  ecode5 = SWIG_AsVal_double(obj1, &val5);
11882  if (!SWIG_IsOK(ecode5)) {
11883  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11884  }
11885  arg5 = (PLFLT)(val5);
11886  ecode6 = SWIG_AsVal_double(obj2, &val6);
11887  if (!SWIG_IsOK(ecode6)) {
11888  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11889  }
11890  arg6 = (PLFLT)(val6);
11891  ecode7 = SWIG_AsVal_double(obj3, &val7);
11892  if (!SWIG_IsOK(ecode7)) {
11893  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11894  }
11895  arg7 = (PLFLT)(val7);
11896  ecode8 = SWIG_AsVal_double(obj4, &val8);
11897  if (!SWIG_IsOK(ecode8)) {
11898  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11899  }
11900  arg8 = (PLFLT)(val8);
11901  {
11902  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11903  if ( tmp9 == NULL )
11904  return NULL;
11905  arg10 = PyArray_DIMS( tmp9 )[0];
11906  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11907  }
11908  ecode11 = SWIG_AsVal_double(obj6, &val11);
11909  if (!SWIG_IsOK(ecode11)) {
11910  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11911  }
11912  arg11 = (PLFLT)(val11);
11913  ecode12 = SWIG_AsVal_int(obj7, &val12);
11914  if (!SWIG_IsOK(ecode12)) {
11915  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11916  }
11917  arg12 = (PLINT)(val12);
11918  ecode13 = SWIG_AsVal_double(obj8, &val13);
11919  if (!SWIG_IsOK(ecode13)) {
11920  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11921  }
11922  arg13 = (PLFLT)(val13);
11923  ecode15 = SWIG_AsVal_int(obj9, &val15);
11924  if (!SWIG_IsOK(ecode15)) {
11925  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11926  }
11927  arg15 = (PLBOOL)(val15);
11928  if (obj10) {
11929  {
11930  // it must be a callable or None
11931  if ( obj10 == Py_None )
11932  {
11933  arg16 = NULL;
11934  }
11935  else
11936  {
11937  if ( !PyCallable_Check( (PyObject *) obj10 ) )
11938  {
11939  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11940  return NULL;
11941  }
11942  arg16 = marshal_pltr( obj10 );
11943  }
11944  }
11945  }
11946  if (obj11) {
11947  {
11948  if ( obj11 == Py_None )
11949  arg17 = NULL;
11950  else
11951  {
11952  arg17 = marshal_PLPointer( obj11, 0 );
11953  }
11954  }
11955  }
11956  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11957  resultobj = SWIG_Py_Void();
11958  {
11959  Py_CLEAR( tmp1 );
11960  free( arg1 );
11961  }
11962  {
11963  Py_CLEAR( tmp9 );
11964  }
11965  {
11966  cleanup_pltr();
11967  }
11968  {
11970  }
11971  return resultobj;
11972 fail:
11973  {
11974  Py_CLEAR( tmp1 );
11975  free( arg1 );
11976  }
11977  {
11978  Py_CLEAR( tmp9 );
11979  }
11980  {
11981  cleanup_pltr();
11982  }
11983  {
11985  }
11986  return NULL;
11987 }
11988 
11989 
11990 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11991  PyObject *resultobj = 0;
11992  PLFLT **arg1 = (PLFLT **) 0 ;
11993  PLINT arg2 ;
11994  PLINT arg3 ;
11995  defined_func arg4 = (defined_func) 0 ;
11996  PLFLT arg5 ;
11997  PLFLT arg6 ;
11998  PLFLT arg7 ;
11999  PLFLT arg8 ;
12000  PLFLT arg9 ;
12001  PLFLT arg10 ;
12002  PLINT arg11 ;
12003  PLFLT arg12 ;
12004  PLFLT arg13 ;
12005  PLINT arg14 ;
12006  PLFLT arg15 ;
12007  PLINT arg16 ;
12008  PLFLT arg17 ;
12009  fill_func arg18 = (fill_func) 0 ;
12010  PLBOOL arg19 ;
12011  pltr_func arg20 = (pltr_func) 0 ;
12012  PLPointer arg21 = (PLPointer) 0 ;
12013  PyArrayObject *tmp1 = NULL ;
12014  double val5 ;
12015  int ecode5 = 0 ;
12016  double val6 ;
12017  int ecode6 = 0 ;
12018  double val7 ;
12019  int ecode7 = 0 ;
12020  double val8 ;
12021  int ecode8 = 0 ;
12022  double val9 ;
12023  int ecode9 = 0 ;
12024  double val10 ;
12025  int ecode10 = 0 ;
12026  int val11 ;
12027  int ecode11 = 0 ;
12028  double val12 ;
12029  int ecode12 = 0 ;
12030  double val13 ;
12031  int ecode13 = 0 ;
12032  int val14 ;
12033  int ecode14 = 0 ;
12034  double val15 ;
12035  int ecode15 = 0 ;
12036  int val16 ;
12037  int ecode16 = 0 ;
12038  double val17 ;
12039  int ecode17 = 0 ;
12040  int val19 ;
12041  int ecode19 = 0 ;
12042  PyObject * obj0 = 0 ;
12043  PyObject * obj1 = 0 ;
12044  PyObject * obj2 = 0 ;
12045  PyObject * obj3 = 0 ;
12046  PyObject * obj4 = 0 ;
12047  PyObject * obj5 = 0 ;
12048  PyObject * obj6 = 0 ;
12049  PyObject * obj7 = 0 ;
12050  PyObject * obj8 = 0 ;
12051  PyObject * obj9 = 0 ;
12052  PyObject * obj10 = 0 ;
12053  PyObject * obj11 = 0 ;
12054  PyObject * obj12 = 0 ;
12055  PyObject * obj13 = 0 ;
12056  PyObject * obj14 = 0 ;
12057  PyObject * obj15 = 0 ;
12058  PyObject * obj16 = 0 ;
12059 
12060  {
12061  python_pltr = 0;
12062  arg20 = NULL;
12063  }
12064  {
12065  arg21 = NULL;
12066  }
12067  {
12068  arg4 = NULL;
12069  }
12070  {
12071  arg18 = plfill;
12072  }
12073  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;
12074  {
12075  int i, size;
12076  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12077  if ( tmp1 == NULL )
12078  return NULL;
12079  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12080  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12081  size = arg3;
12082  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12083  for ( i = 0; i < arg2; i++ )
12084  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12085  }
12086  ecode5 = SWIG_AsVal_double(obj1, &val5);
12087  if (!SWIG_IsOK(ecode5)) {
12088  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12089  }
12090  arg5 = (PLFLT)(val5);
12091  ecode6 = SWIG_AsVal_double(obj2, &val6);
12092  if (!SWIG_IsOK(ecode6)) {
12093  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12094  }
12095  arg6 = (PLFLT)(val6);
12096  ecode7 = SWIG_AsVal_double(obj3, &val7);
12097  if (!SWIG_IsOK(ecode7)) {
12098  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12099  }
12100  arg7 = (PLFLT)(val7);
12101  ecode8 = SWIG_AsVal_double(obj4, &val8);
12102  if (!SWIG_IsOK(ecode8)) {
12103  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12104  }
12105  arg8 = (PLFLT)(val8);
12106  ecode9 = SWIG_AsVal_double(obj5, &val9);
12107  if (!SWIG_IsOK(ecode9)) {
12108  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12109  }
12110  arg9 = (PLFLT)(val9);
12111  ecode10 = SWIG_AsVal_double(obj6, &val10);
12112  if (!SWIG_IsOK(ecode10)) {
12113  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12114  }
12115  arg10 = (PLFLT)(val10);
12116  ecode11 = SWIG_AsVal_int(obj7, &val11);
12117  if (!SWIG_IsOK(ecode11)) {
12118  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12119  }
12120  arg11 = (PLINT)(val11);
12121  ecode12 = SWIG_AsVal_double(obj8, &val12);
12122  if (!SWIG_IsOK(ecode12)) {
12123  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12124  }
12125  arg12 = (PLFLT)(val12);
12126  ecode13 = SWIG_AsVal_double(obj9, &val13);
12127  if (!SWIG_IsOK(ecode13)) {
12128  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12129  }
12130  arg13 = (PLFLT)(val13);
12131  ecode14 = SWIG_AsVal_int(obj10, &val14);
12132  if (!SWIG_IsOK(ecode14)) {
12133  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12134  }
12135  arg14 = (PLINT)(val14);
12136  ecode15 = SWIG_AsVal_double(obj11, &val15);
12137  if (!SWIG_IsOK(ecode15)) {
12138  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12139  }
12140  arg15 = (PLFLT)(val15);
12141  ecode16 = SWIG_AsVal_int(obj12, &val16);
12142  if (!SWIG_IsOK(ecode16)) {
12143  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12144  }
12145  arg16 = (PLINT)(val16);
12146  ecode17 = SWIG_AsVal_double(obj13, &val17);
12147  if (!SWIG_IsOK(ecode17)) {
12148  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12149  }
12150  arg17 = (PLFLT)(val17);
12151  ecode19 = SWIG_AsVal_int(obj14, &val19);
12152  if (!SWIG_IsOK(ecode19)) {
12153  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12154  }
12155  arg19 = (PLBOOL)(val19);
12156  if (obj15) {
12157  {
12158  // it must be a callable or None
12159  if ( obj15 == Py_None )
12160  {
12161  arg20 = NULL;
12162  }
12163  else
12164  {
12165  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12166  {
12167  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12168  return NULL;
12169  }
12170  arg20 = marshal_pltr( obj15 );
12171  }
12172  }
12173  }
12174  if (obj16) {
12175  {
12176  if ( obj16 == Py_None )
12177  arg21 = NULL;
12178  else
12179  {
12180  arg21 = marshal_PLPointer( obj16, 0 );
12181  }
12182  }
12183  }
12184  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12185  resultobj = SWIG_Py_Void();
12186  {
12187  Py_CLEAR( tmp1 );
12188  free( arg1 );
12189  }
12190  {
12191  cleanup_pltr();
12192  }
12193  {
12195  }
12196  return resultobj;
12197 fail:
12198  {
12199  Py_CLEAR( tmp1 );
12200  free( arg1 );
12201  }
12202  {
12203  cleanup_pltr();
12204  }
12205  {
12207  }
12208  return NULL;
12209 }
12210 
12211 
12212 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12213  PyObject *resultobj = 0;
12214  label_func arg1 = (label_func) 0 ;
12215  PLPointer arg2 = (PLPointer) 0 ;
12216  int res2 ;
12217  PyObject * obj0 = 0 ;
12218  PyObject * obj1 = 0 ;
12219 
12220  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12221  {
12222  // Release reference to previous function if applicable
12223  if ( python_label )
12224  {
12225  Py_CLEAR( python_label );
12226  python_label = 0;
12227  }
12228  // it must be a callable or None
12229  if ( obj0 == Py_None )
12230  {
12231  arg1 = NULL;
12232  }
12233  else
12234  {
12235  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12236  {
12237  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12238  return NULL;
12239  }
12240  // hold a reference to it
12241  Py_XINCREF( (PyObject *) obj0 );
12242  python_label = (PyObject *) obj0;
12243  // this function handles calling the python function
12244  arg1 = do_label_callback;
12245  }
12246  }
12247  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12248  if (!SWIG_IsOK(res2)) {
12249  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12250  }
12251  plslabelfunc(arg1,arg2);
12252  resultobj = SWIG_Py_Void();
12253  return resultobj;
12254 fail:
12255  return NULL;
12256 }
12257 
12258 
12259 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12260  PyObject *resultobj = 0;
12261  PLFLT arg1 ;
12262  PLFLT arg2 ;
12263  double val1 ;
12264  int ecode1 = 0 ;
12265  double val2 ;
12266  int ecode2 = 0 ;
12267  PyObject * obj0 = 0 ;
12268  PyObject * obj1 = 0 ;
12269 
12270  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12271  ecode1 = SWIG_AsVal_double(obj0, &val1);
12272  if (!SWIG_IsOK(ecode1)) {
12273  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12274  }
12275  arg1 = (PLFLT)(val1);
12276  ecode2 = SWIG_AsVal_double(obj1, &val2);
12277  if (!SWIG_IsOK(ecode2)) {
12278  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12279  }
12280  arg2 = (PLFLT)(val2);
12281  plsmaj(arg1,arg2);
12282  resultobj = SWIG_Py_Void();
12283  return resultobj;
12284 fail:
12285  return NULL;
12286 }
12287 
12288 
12289 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12290  PyObject *resultobj = 0;
12291  PLINT arg1 ;
12292  PLINT arg2 ;
12293  void *arg3 = (void *) 0 ;
12294  int val1 ;
12295  int ecode1 = 0 ;
12296  int val2 ;
12297  int ecode2 = 0 ;
12298  int res3 ;
12299  Py_ssize_t size3 = 0 ;
12300  void *buf3 = 0 ;
12301  PyObject * obj0 = 0 ;
12302  PyObject * obj1 = 0 ;
12303  PyObject * obj2 = 0 ;
12304 
12305  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12306  ecode1 = SWIG_AsVal_int(obj0, &val1);
12307  if (!SWIG_IsOK(ecode1)) {
12308  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12309  }
12310  arg1 = (PLINT)(val1);
12311  ecode2 = SWIG_AsVal_int(obj1, &val2);
12312  if (!SWIG_IsOK(ecode2)) {
12313  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12314  }
12315  arg2 = (PLINT)(val2);
12316  {
12317  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12318  if (res3<0) {
12319  PyErr_Clear();
12320  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12321  }
12322  arg3 = (void *) buf3;
12323  }
12324  plsmem(arg1,arg2,arg3);
12325  resultobj = SWIG_Py_Void();
12326  return resultobj;
12327 fail:
12328  return NULL;
12329 }
12330 
12331 
12332 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12333  PyObject *resultobj = 0;
12334  PLINT arg1 ;
12335  PLINT arg2 ;
12336  void *arg3 = (void *) 0 ;
12337  int val1 ;
12338  int ecode1 = 0 ;
12339  int val2 ;
12340  int ecode2 = 0 ;
12341  int res3 ;
12342  Py_ssize_t size3 = 0 ;
12343  void *buf3 = 0 ;
12344  PyObject * obj0 = 0 ;
12345  PyObject * obj1 = 0 ;
12346  PyObject * obj2 = 0 ;
12347 
12348  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12349  ecode1 = SWIG_AsVal_int(obj0, &val1);
12350  if (!SWIG_IsOK(ecode1)) {
12351  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12352  }
12353  arg1 = (PLINT)(val1);
12354  ecode2 = SWIG_AsVal_int(obj1, &val2);
12355  if (!SWIG_IsOK(ecode2)) {
12356  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12357  }
12358  arg2 = (PLINT)(val2);
12359  {
12360  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12361  if (res3<0) {
12362  PyErr_Clear();
12363  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12364  }
12365  arg3 = (void *) buf3;
12366  }
12367  plsmema(arg1,arg2,arg3);
12368  resultobj = SWIG_Py_Void();
12369  return resultobj;
12370 fail:
12371  return NULL;
12372 }
12373 
12374 
12375 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12376  PyObject *resultobj = 0;
12377  PLFLT arg1 ;
12378  PLFLT arg2 ;
12379  double val1 ;
12380  int ecode1 = 0 ;
12381  double val2 ;
12382  int ecode2 = 0 ;
12383  PyObject * obj0 = 0 ;
12384  PyObject * obj1 = 0 ;
12385 
12386  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12387  ecode1 = SWIG_AsVal_double(obj0, &val1);
12388  if (!SWIG_IsOK(ecode1)) {
12389  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12390  }
12391  arg1 = (PLFLT)(val1);
12392  ecode2 = SWIG_AsVal_double(obj1, &val2);
12393  if (!SWIG_IsOK(ecode2)) {
12394  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12395  }
12396  arg2 = (PLFLT)(val2);
12397  plsmin(arg1,arg2);
12398  resultobj = SWIG_Py_Void();
12399  return resultobj;
12400 fail:
12401  return NULL;
12402 }
12403 
12404 
12405 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406  PyObject *resultobj = 0;
12407  PLINT arg1 ;
12408  int val1 ;
12409  int ecode1 = 0 ;
12410  PyObject * obj0 = 0 ;
12411 
12412  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12413  ecode1 = SWIG_AsVal_int(obj0, &val1);
12414  if (!SWIG_IsOK(ecode1)) {
12415  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12416  }
12417  arg1 = (PLINT)(val1);
12418  plsori(arg1);
12419  resultobj = SWIG_Py_Void();
12420  return resultobj;
12421 fail:
12422  return NULL;
12423 }
12424 
12425 
12426 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12427  PyObject *resultobj = 0;
12428  PLFLT arg1 ;
12429  PLFLT arg2 ;
12430  PLINT arg3 ;
12431  PLINT arg4 ;
12432  PLINT arg5 ;
12433  PLINT arg6 ;
12434  double val1 ;
12435  int ecode1 = 0 ;
12436  double val2 ;
12437  int ecode2 = 0 ;
12438  int val3 ;
12439  int ecode3 = 0 ;
12440  int val4 ;
12441  int ecode4 = 0 ;
12442  int val5 ;
12443  int ecode5 = 0 ;
12444  int val6 ;
12445  int ecode6 = 0 ;
12446  PyObject * obj0 = 0 ;
12447  PyObject * obj1 = 0 ;
12448  PyObject * obj2 = 0 ;
12449  PyObject * obj3 = 0 ;
12450  PyObject * obj4 = 0 ;
12451  PyObject * obj5 = 0 ;
12452 
12453  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12454  ecode1 = SWIG_AsVal_double(obj0, &val1);
12455  if (!SWIG_IsOK(ecode1)) {
12456  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12457  }
12458  arg1 = (PLFLT)(val1);
12459  ecode2 = SWIG_AsVal_double(obj1, &val2);
12460  if (!SWIG_IsOK(ecode2)) {
12461  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12462  }
12463  arg2 = (PLFLT)(val2);
12464  ecode3 = SWIG_AsVal_int(obj2, &val3);
12465  if (!SWIG_IsOK(ecode3)) {
12466  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12467  }
12468  arg3 = (PLINT)(val3);
12469  ecode4 = SWIG_AsVal_int(obj3, &val4);
12470  if (!SWIG_IsOK(ecode4)) {
12471  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12472  }
12473  arg4 = (PLINT)(val4);
12474  ecode5 = SWIG_AsVal_int(obj4, &val5);
12475  if (!SWIG_IsOK(ecode5)) {
12476  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12477  }
12478  arg5 = (PLINT)(val5);
12479  ecode6 = SWIG_AsVal_int(obj5, &val6);
12480  if (!SWIG_IsOK(ecode6)) {
12481  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12482  }
12483  arg6 = (PLINT)(val6);
12484  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12485  resultobj = SWIG_Py_Void();
12486  return resultobj;
12487 fail:
12488  return NULL;
12489 }
12490 
12491 
12492 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12493  PyObject *resultobj = 0;
12494  char *arg1 = (char *) 0 ;
12495  int res1 ;
12496  char *buf1 = 0 ;
12497  int alloc1 = 0 ;
12498  PyObject * obj0 = 0 ;
12499 
12500  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12501  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12502  if (!SWIG_IsOK(res1)) {
12503  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12504  }
12505  arg1 = (char *)(buf1);
12506  plspal0((char const *)arg1);
12507  resultobj = SWIG_Py_Void();
12508  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12509  return resultobj;
12510 fail:
12511  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12512  return NULL;
12513 }
12514 
12515 
12516 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12517  PyObject *resultobj = 0;
12518  char *arg1 = (char *) 0 ;
12519  PLBOOL arg2 ;
12520  int res1 ;
12521  char *buf1 = 0 ;
12522  int alloc1 = 0 ;
12523  int val2 ;
12524  int ecode2 = 0 ;
12525  PyObject * obj0 = 0 ;
12526  PyObject * obj1 = 0 ;
12527 
12528  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12529  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12530  if (!SWIG_IsOK(res1)) {
12531  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12532  }
12533  arg1 = (char *)(buf1);
12534  ecode2 = SWIG_AsVal_int(obj1, &val2);
12535  if (!SWIG_IsOK(ecode2)) {
12536  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12537  }
12538  arg2 = (PLBOOL)(val2);
12539  plspal1((char const *)arg1,arg2);
12540  resultobj = SWIG_Py_Void();
12541  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12542  return resultobj;
12543 fail:
12544  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12545  return NULL;
12546 }
12547 
12548 
12549 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12550  PyObject *resultobj = 0;
12551  PLBOOL arg1 ;
12552  int val1 ;
12553  int ecode1 = 0 ;
12554  PyObject * obj0 = 0 ;
12555 
12556  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12557  ecode1 = SWIG_AsVal_int(obj0, &val1);
12558  if (!SWIG_IsOK(ecode1)) {
12559  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12560  }
12561  arg1 = (PLBOOL)(val1);
12562  plspause(arg1);
12563  resultobj = SWIG_Py_Void();
12564  return resultobj;
12565 fail:
12566  return NULL;
12567 }
12568 
12569 
12570 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12571  PyObject *resultobj = 0;
12572  PLINT arg1 ;
12573  int val1 ;
12574  int ecode1 = 0 ;
12575  PyObject * obj0 = 0 ;
12576 
12577  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12578  ecode1 = SWIG_AsVal_int(obj0, &val1);
12579  if (!SWIG_IsOK(ecode1)) {
12580  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12581  }
12582  arg1 = (PLINT)(val1);
12583  plsstrm(arg1);
12584  resultobj = SWIG_Py_Void();
12585  return resultobj;
12586 fail:
12587  return NULL;
12588 }
12589 
12590 
12591 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12592  PyObject *resultobj = 0;
12593  PLINT arg1 ;
12594  PLINT arg2 ;
12595  int val1 ;
12596  int ecode1 = 0 ;
12597  int val2 ;
12598  int ecode2 = 0 ;
12599  PyObject * obj0 = 0 ;
12600  PyObject * obj1 = 0 ;
12601 
12602  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12603  ecode1 = SWIG_AsVal_int(obj0, &val1);
12604  if (!SWIG_IsOK(ecode1)) {
12605  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12606  }
12607  arg1 = (PLINT)(val1);
12608  ecode2 = SWIG_AsVal_int(obj1, &val2);
12609  if (!SWIG_IsOK(ecode2)) {
12610  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12611  }
12612  arg2 = (PLINT)(val2);
12613  plssub(arg1,arg2);
12614  resultobj = SWIG_Py_Void();
12615  return resultobj;
12616 fail:
12617  return NULL;
12618 }
12619 
12620 
12621 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622  PyObject *resultobj = 0;
12623  PLFLT arg1 ;
12624  PLFLT arg2 ;
12625  double val1 ;
12626  int ecode1 = 0 ;
12627  double val2 ;
12628  int ecode2 = 0 ;
12629  PyObject * obj0 = 0 ;
12630  PyObject * obj1 = 0 ;
12631 
12632  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12633  ecode1 = SWIG_AsVal_double(obj0, &val1);
12634  if (!SWIG_IsOK(ecode1)) {
12635  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12636  }
12637  arg1 = (PLFLT)(val1);
12638  ecode2 = SWIG_AsVal_double(obj1, &val2);
12639  if (!SWIG_IsOK(ecode2)) {
12640  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12641  }
12642  arg2 = (PLFLT)(val2);
12643  plssym(arg1,arg2);
12644  resultobj = SWIG_Py_Void();
12645  return resultobj;
12646 fail:
12647  return NULL;
12648 }
12649 
12650 
12651 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12652  PyObject *resultobj = 0;
12653  PLINT arg1 ;
12654  PLINT arg2 ;
12655  int val1 ;
12656  int ecode1 = 0 ;
12657  int val2 ;
12658  int ecode2 = 0 ;
12659  PyObject * obj0 = 0 ;
12660  PyObject * obj1 = 0 ;
12661 
12662  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12663  ecode1 = SWIG_AsVal_int(obj0, &val1);
12664  if (!SWIG_IsOK(ecode1)) {
12665  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12666  }
12667  arg1 = (PLINT)(val1);
12668  ecode2 = SWIG_AsVal_int(obj1, &val2);
12669  if (!SWIG_IsOK(ecode2)) {
12670  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12671  }
12672  arg2 = (PLINT)(val2);
12673  plstar(arg1,arg2);
12674  resultobj = SWIG_Py_Void();
12675  return resultobj;
12676 fail:
12677  return NULL;
12678 }
12679 
12680 
12681 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12682  PyObject *resultobj = 0;
12683  char *arg1 = (char *) 0 ;
12684  PLINT arg2 ;
12685  PLINT arg3 ;
12686  int res1 ;
12687  char *buf1 = 0 ;
12688  int alloc1 = 0 ;
12689  int val2 ;
12690  int ecode2 = 0 ;
12691  int val3 ;
12692  int ecode3 = 0 ;
12693  PyObject * obj0 = 0 ;
12694  PyObject * obj1 = 0 ;
12695  PyObject * obj2 = 0 ;
12696 
12697  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12698  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12699  if (!SWIG_IsOK(res1)) {
12700  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12701  }
12702  arg1 = (char *)(buf1);
12703  ecode2 = SWIG_AsVal_int(obj1, &val2);
12704  if (!SWIG_IsOK(ecode2)) {
12705  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12706  }
12707  arg2 = (PLINT)(val2);
12708  ecode3 = SWIG_AsVal_int(obj2, &val3);
12709  if (!SWIG_IsOK(ecode3)) {
12710  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12711  }
12712  arg3 = (PLINT)(val3);
12713  plstart((char const *)arg1,arg2,arg3);
12714  resultobj = SWIG_Py_Void();
12715  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12716  return resultobj;
12717 fail:
12718  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12719  return NULL;
12720 }
12721 
12722 
12723 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724  PyObject *resultobj = 0;
12725  ct_func arg1 = (ct_func) 0 ;
12726  PLPointer arg2 = (PLPointer) 0 ;
12727  int res2 ;
12728  PyObject * obj0 = 0 ;
12729  PyObject * obj1 = 0 ;
12730 
12731  {
12732  python_ct = 0;
12733  arg1 = NULL;
12734  }
12735  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12736  if (obj0) {
12737  {
12738  if ( python_ct )
12739  cleanup_ct();
12740  // it must be a callable or none
12741  if ( obj0 == Py_None )
12742  {
12743  arg1 = NULL;
12744  }
12745  else
12746  {
12747  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12748  {
12749  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12750  return NULL;
12751  }
12752  arg1 = marshal_ct( obj0 );
12753  }
12754  }
12755  }
12756  if (obj1) {
12757  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12758  if (!SWIG_IsOK(res2)) {
12759  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12760  }
12761  }
12762  plstransform(arg1,arg2);
12763  resultobj = SWIG_Py_Void();
12764  return resultobj;
12765 fail:
12766  return NULL;
12767 }
12768 
12769 
12770 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12771  PyObject *resultobj = 0;
12772  PLINT arg1 ;
12773  PLFLT *arg2 = (PLFLT *) 0 ;
12774  PLFLT *arg3 = (PLFLT *) 0 ;
12775  char *arg4 = (char *) 0 ;
12776  PyArrayObject *tmp1 = NULL ;
12777  PyArrayObject *tmp3 = NULL ;
12778  int res4 ;
12779  char *buf4 = 0 ;
12780  int alloc4 = 0 ;
12781  PyObject * obj0 = 0 ;
12782  PyObject * obj1 = 0 ;
12783  PyObject * obj2 = 0 ;
12784 
12785  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12786  {
12787  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12788  if ( tmp1 == NULL )
12789  return NULL;
12790  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12791  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12792  }
12793  {
12794  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12795  if ( tmp3 == NULL )
12796  return NULL;
12797  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12798  {
12799  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12800  return NULL;
12801  }
12802  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12803  }
12804  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12805  if (!SWIG_IsOK(res4)) {
12806  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12807  }
12808  arg4 = (char *)(buf4);
12809  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12810  resultobj = SWIG_Py_Void();
12811  {
12812  Py_CLEAR( tmp1 );
12813  }
12814  {
12815  Py_CLEAR( tmp3 );
12816  }
12817  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12818  return resultobj;
12819 fail:
12820  {
12821  Py_CLEAR( tmp1 );
12822  }
12823  {
12824  Py_CLEAR( tmp3 );
12825  }
12826  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12827  return NULL;
12828 }
12829 
12830 
12831 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832  PyObject *resultobj = 0;
12833  PLINT arg1 ;
12834  PLFLT *arg2 = (PLFLT *) 0 ;
12835  PLFLT *arg3 = (PLFLT *) 0 ;
12836  PLFLT *arg4 = (PLFLT *) 0 ;
12837  char *arg5 = (char *) 0 ;
12838  PyArrayObject *tmp1 = NULL ;
12839  PyArrayObject *tmp3 = NULL ;
12840  PyArrayObject *tmp4 = NULL ;
12841  int res5 ;
12842  char *buf5 = 0 ;
12843  int alloc5 = 0 ;
12844  PyObject * obj0 = 0 ;
12845  PyObject * obj1 = 0 ;
12846  PyObject * obj2 = 0 ;
12847  PyObject * obj3 = 0 ;
12848 
12849  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12850  {
12851  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12852  if ( tmp1 == NULL )
12853  return NULL;
12854  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12855  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12856  }
12857  {
12858  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12859  if ( tmp3 == NULL )
12860  return NULL;
12861  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12862  {
12863  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12864  return NULL;
12865  }
12866  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12867  }
12868  {
12869  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12870  if ( tmp4 == NULL )
12871  return NULL;
12872  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12873  {
12874  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12875  return NULL;
12876  }
12877  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12878  }
12879  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12880  if (!SWIG_IsOK(res5)) {
12881  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12882  }
12883  arg5 = (char *)(buf5);
12884  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12885  resultobj = SWIG_Py_Void();
12886  {
12887  Py_CLEAR( tmp1 );
12888  }
12889  {
12890  Py_CLEAR( tmp3 );
12891  }
12892  {
12893  Py_CLEAR( tmp4 );
12894  }
12895  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12896  return resultobj;
12897 fail:
12898  {
12899  Py_CLEAR( tmp1 );
12900  }
12901  {
12902  Py_CLEAR( tmp3 );
12903  }
12904  {
12905  Py_CLEAR( tmp4 );
12906  }
12907  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12908  return NULL;
12909 }
12910 
12911 
12912 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12913  PyObject *resultobj = 0;
12914  PLINT arg1 ;
12915  PLINT arg2 ;
12916  PLFLT arg3 ;
12917  PLFLT arg4 ;
12918  int val1 ;
12919  int ecode1 = 0 ;
12920  int val2 ;
12921  int ecode2 = 0 ;
12922  double val3 ;
12923  int ecode3 = 0 ;
12924  double val4 ;
12925  int ecode4 = 0 ;
12926  PyObject * obj0 = 0 ;
12927  PyObject * obj1 = 0 ;
12928  PyObject * obj2 = 0 ;
12929  PyObject * obj3 = 0 ;
12930 
12931  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12932  ecode1 = SWIG_AsVal_int(obj0, &val1);
12933  if (!SWIG_IsOK(ecode1)) {
12934  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12935  }
12936  arg1 = (PLINT)(val1);
12937  ecode2 = SWIG_AsVal_int(obj1, &val2);
12938  if (!SWIG_IsOK(ecode2)) {
12939  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12940  }
12941  arg2 = (PLINT)(val2);
12942  ecode3 = SWIG_AsVal_double(obj2, &val3);
12943  if (!SWIG_IsOK(ecode3)) {
12944  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12945  }
12946  arg3 = (PLFLT)(val3);
12947  ecode4 = SWIG_AsVal_double(obj3, &val4);
12948  if (!SWIG_IsOK(ecode4)) {
12949  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12950  }
12951  arg4 = (PLFLT)(val4);
12952  plstripa(arg1,arg2,arg3,arg4);
12953  resultobj = SWIG_Py_Void();
12954  return resultobj;
12955 fail:
12956  return NULL;
12957 }
12958 
12959 
12960 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961  PyObject *resultobj = 0;
12962  PLINT *arg1 = (PLINT *) 0 ;
12963  char *arg2 = (char *) 0 ;
12964  char *arg3 = (char *) 0 ;
12965  PLFLT arg4 ;
12966  PLFLT arg5 ;
12967  PLFLT arg6 ;
12968  PLFLT arg7 ;
12969  PLFLT arg8 ;
12970  PLFLT arg9 ;
12971  PLFLT arg10 ;
12972  PLBOOL arg11 ;
12973  PLBOOL arg12 ;
12974  PLINT arg13 ;
12975  PLINT arg14 ;
12976  PLINT *arg15 = (PLINT *) 0 ;
12977  PLINT *arg16 = (PLINT *) 0 ;
12978  char **arg17 ;
12979  char *arg18 = (char *) 0 ;
12980  char *arg19 = (char *) 0 ;
12981  char *arg20 = (char *) 0 ;
12982  PLINT temp1 ;
12983  int res1 = SWIG_TMPOBJ ;
12984  int res2 ;
12985  char *buf2 = 0 ;
12986  int alloc2 = 0 ;
12987  int res3 ;
12988  char *buf3 = 0 ;
12989  int alloc3 = 0 ;
12990  double val4 ;
12991  int ecode4 = 0 ;
12992  double val5 ;
12993  int ecode5 = 0 ;
12994  double val6 ;
12995  int ecode6 = 0 ;
12996  double val7 ;
12997  int ecode7 = 0 ;
12998  double val8 ;
12999  int ecode8 = 0 ;
13000  double val9 ;
13001  int ecode9 = 0 ;
13002  double val10 ;
13003  int ecode10 = 0 ;
13004  int val11 ;
13005  int ecode11 = 0 ;
13006  int val12 ;
13007  int ecode12 = 0 ;
13008  int val13 ;
13009  int ecode13 = 0 ;
13010  int val14 ;
13011  int ecode14 = 0 ;
13012  PyArrayObject *tmp15 = NULL ;
13013  PyArrayObject *tmp16 = NULL ;
13014  char **tmp17 = NULL ;
13015  int res18 ;
13016  char *buf18 = 0 ;
13017  int alloc18 = 0 ;
13018  int res19 ;
13019  char *buf19 = 0 ;
13020  int alloc19 = 0 ;
13021  int res20 ;
13022  char *buf20 = 0 ;
13023  int alloc20 = 0 ;
13024  PyObject * obj0 = 0 ;
13025  PyObject * obj1 = 0 ;
13026  PyObject * obj2 = 0 ;
13027  PyObject * obj3 = 0 ;
13028  PyObject * obj4 = 0 ;
13029  PyObject * obj5 = 0 ;
13030  PyObject * obj6 = 0 ;
13031  PyObject * obj7 = 0 ;
13032  PyObject * obj8 = 0 ;
13033  PyObject * obj9 = 0 ;
13034  PyObject * obj10 = 0 ;
13035  PyObject * obj11 = 0 ;
13036  PyObject * obj12 = 0 ;
13037  PyObject * obj13 = 0 ;
13038  PyObject * obj14 = 0 ;
13039  PyObject * obj15 = 0 ;
13040  PyObject * obj16 = 0 ;
13041  PyObject * obj17 = 0 ;
13042  PyObject * obj18 = 0 ;
13043 
13044  arg1 = &temp1;
13045  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;
13046  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13047  if (!SWIG_IsOK(res2)) {
13048  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13049  }
13050  arg2 = (char *)(buf2);
13051  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13052  if (!SWIG_IsOK(res3)) {
13053  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13054  }
13055  arg3 = (char *)(buf3);
13056  ecode4 = SWIG_AsVal_double(obj2, &val4);
13057  if (!SWIG_IsOK(ecode4)) {
13058  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13059  }
13060  arg4 = (PLFLT)(val4);
13061  ecode5 = SWIG_AsVal_double(obj3, &val5);
13062  if (!SWIG_IsOK(ecode5)) {
13063  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13064  }
13065  arg5 = (PLFLT)(val5);
13066  ecode6 = SWIG_AsVal_double(obj4, &val6);
13067  if (!SWIG_IsOK(ecode6)) {
13068  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13069  }
13070  arg6 = (PLFLT)(val6);
13071  ecode7 = SWIG_AsVal_double(obj5, &val7);
13072  if (!SWIG_IsOK(ecode7)) {
13073  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13074  }
13075  arg7 = (PLFLT)(val7);
13076  ecode8 = SWIG_AsVal_double(obj6, &val8);
13077  if (!SWIG_IsOK(ecode8)) {
13078  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13079  }
13080  arg8 = (PLFLT)(val8);
13081  ecode9 = SWIG_AsVal_double(obj7, &val9);
13082  if (!SWIG_IsOK(ecode9)) {
13083  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13084  }
13085  arg9 = (PLFLT)(val9);
13086  ecode10 = SWIG_AsVal_double(obj8, &val10);
13087  if (!SWIG_IsOK(ecode10)) {
13088  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13089  }
13090  arg10 = (PLFLT)(val10);
13091  ecode11 = SWIG_AsVal_int(obj9, &val11);
13092  if (!SWIG_IsOK(ecode11)) {
13093  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13094  }
13095  arg11 = (PLBOOL)(val11);
13096  ecode12 = SWIG_AsVal_int(obj10, &val12);
13097  if (!SWIG_IsOK(ecode12)) {
13098  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13099  }
13100  arg12 = (PLBOOL)(val12);
13101  ecode13 = SWIG_AsVal_int(obj11, &val13);
13102  if (!SWIG_IsOK(ecode13)) {
13103  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13104  }
13105  arg13 = (PLINT)(val13);
13106  ecode14 = SWIG_AsVal_int(obj12, &val14);
13107  if (!SWIG_IsOK(ecode14)) {
13108  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13109  }
13110  arg14 = (PLINT)(val14);
13111  {
13112  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13113  if ( tmp15 == NULL )
13114  return NULL;
13115  Alen = PyArray_DIMS( tmp15 )[0];
13116  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13117  }
13118  {
13119  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13120  if ( tmp16 == NULL )
13121  return NULL;
13122  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13123  {
13124  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13125  return NULL;
13126  }
13127  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13128  }
13129  {
13130  int i;
13131  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13132  {
13133  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13134  return NULL;
13135  }
13136  if ( Alen != 4 )
13137  {
13138  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13139  return NULL;
13140  }
13141  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13142  if ( tmp17 == NULL )
13143  return NULL;
13144  arg17 = tmp17;
13145  for ( i = 0; i < 4; i++ )
13146  {
13147  arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13148  if ( arg17[i] == NULL )
13149  {
13150  free( tmp17 );
13151  return NULL;
13152  }
13153  }
13154  }
13155  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13156  if (!SWIG_IsOK(res18)) {
13157  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13158  }
13159  arg18 = (char *)(buf18);
13160  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13161  if (!SWIG_IsOK(res19)) {
13162  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13163  }
13164  arg19 = (char *)(buf19);
13165  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13166  if (!SWIG_IsOK(res20)) {
13167  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13168  }
13169  arg20 = (char *)(buf20);
13170  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);
13171  resultobj = SWIG_Py_Void();
13172  if (SWIG_IsTmpObj(res1)) {
13173  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13174  } else {
13175  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13176  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13177  }
13178  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13179  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13180  {
13181  Py_CLEAR( tmp15 );
13182  }
13183  {
13184  Py_CLEAR( tmp16 );
13185  }
13186  {
13187  free( tmp17 );
13188  }
13189  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13190  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13191  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13192  return resultobj;
13193 fail:
13194  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13195  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13196  {
13197  Py_CLEAR( tmp15 );
13198  }
13199  {
13200  Py_CLEAR( tmp16 );
13201  }
13202  {
13203  free( tmp17 );
13204  }
13205  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13206  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13207  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13208  return NULL;
13209 }
13210 
13211 
13212 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13213  PyObject *resultobj = 0;
13214  PLINT arg1 ;
13215  int val1 ;
13216  int ecode1 = 0 ;
13217  PyObject * obj0 = 0 ;
13218 
13219  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13220  ecode1 = SWIG_AsVal_int(obj0, &val1);
13221  if (!SWIG_IsOK(ecode1)) {
13222  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13223  }
13224  arg1 = (PLINT)(val1);
13225  plstripd(arg1);
13226  resultobj = SWIG_Py_Void();
13227  return resultobj;
13228 fail:
13229  return NULL;
13230 }
13231 
13232 
13233 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13234  PyObject *resultobj = 0;
13235  PLINT arg1 ;
13236  PLINT *arg2 = (PLINT *) 0 ;
13237  PLINT *arg3 = (PLINT *) 0 ;
13238  PyArrayObject *tmp1 = NULL ;
13239  PyArrayObject *tmp3 = NULL ;
13240  PyObject * obj0 = 0 ;
13241  PyObject * obj1 = 0 ;
13242 
13243  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13244  {
13245  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13246  if ( tmp1 == NULL )
13247  return NULL;
13248  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13249  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13250  }
13251  {
13252  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13253  if ( tmp3 == NULL )
13254  return NULL;
13255  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13256  {
13257  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13258  return NULL;
13259  }
13260  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13261  }
13262  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13263  resultobj = SWIG_Py_Void();
13264  {
13265  Py_CLEAR( tmp1 );
13266  }
13267  {
13268  Py_CLEAR( tmp3 );
13269  }
13270  return resultobj;
13271 fail:
13272  {
13273  Py_CLEAR( tmp1 );
13274  }
13275  {
13276  Py_CLEAR( tmp3 );
13277  }
13278  return NULL;
13279 }
13280 
13281 
13282 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13283  PyObject *resultobj = 0;
13284  PLFLT *arg1 = (PLFLT *) 0 ;
13285  PLFLT *arg2 = (PLFLT *) 0 ;
13286  PLINT arg3 ;
13287  PLBOOL arg4 ;
13288  PyArrayObject *tmp1 = NULL ;
13289  PyArrayObject *tmp2 = NULL ;
13290  int val4 ;
13291  int ecode4 = 0 ;
13292  PyObject * obj0 = 0 ;
13293  PyObject * obj1 = 0 ;
13294  PyObject * obj2 = 0 ;
13295 
13296  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13297  {
13298  if ( obj0 != Py_None )
13299  {
13300  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13301  if ( tmp1 == NULL )
13302  return NULL;
13303  Alen = PyArray_DIMS( tmp1 )[0];
13304  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13305  }
13306  else
13307  {
13308  arg1 = NULL;
13309  Alen = 0;
13310  }
13311  }
13312  {
13313  if ( obj1 != Py_None )
13314  {
13315  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13316  if ( tmp2 == NULL )
13317  return NULL;
13318  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13319  {
13320  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13321  return NULL;
13322  }
13323  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13324  arg3 = PyArray_DIMS( tmp2 )[0];
13325  }
13326  else
13327  {
13328  arg2 = NULL;
13329  arg3 = 0;
13330  }
13331  }
13332  ecode4 = SWIG_AsVal_int(obj2, &val4);
13333  if (!SWIG_IsOK(ecode4)) {
13334  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13335  }
13336  arg4 = (PLBOOL)(val4);
13337  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13338  resultobj = SWIG_Py_Void();
13339  {
13340  Py_CLEAR( tmp1 );
13341  }
13342  {
13343  Py_CLEAR( tmp2 );
13344  }
13345  return resultobj;
13346 fail:
13347  {
13348  Py_CLEAR( tmp1 );
13349  }
13350  {
13351  Py_CLEAR( tmp2 );
13352  }
13353  return NULL;
13354 }
13355 
13356 
13357 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13358  PyObject *resultobj = 0;
13359  PLFLT arg1 ;
13360  PLFLT arg2 ;
13361  PLFLT arg3 ;
13362  PLFLT arg4 ;
13363  double val1 ;
13364  int ecode1 = 0 ;
13365  double val2 ;
13366  int ecode2 = 0 ;
13367  double val3 ;
13368  int ecode3 = 0 ;
13369  double val4 ;
13370  int ecode4 = 0 ;
13371  PyObject * obj0 = 0 ;
13372  PyObject * obj1 = 0 ;
13373  PyObject * obj2 = 0 ;
13374  PyObject * obj3 = 0 ;
13375 
13376  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13377  ecode1 = SWIG_AsVal_double(obj0, &val1);
13378  if (!SWIG_IsOK(ecode1)) {
13379  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13380  }
13381  arg1 = (PLFLT)(val1);
13382  ecode2 = SWIG_AsVal_double(obj1, &val2);
13383  if (!SWIG_IsOK(ecode2)) {
13384  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13385  }
13386  arg2 = (PLFLT)(val2);
13387  ecode3 = SWIG_AsVal_double(obj2, &val3);
13388  if (!SWIG_IsOK(ecode3)) {
13389  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13390  }
13391  arg3 = (PLFLT)(val3);
13392  ecode4 = SWIG_AsVal_double(obj3, &val4);
13393  if (!SWIG_IsOK(ecode4)) {
13394  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13395  }
13396  arg4 = (PLFLT)(val4);
13397  plsvpa(arg1,arg2,arg3,arg4);
13398  resultobj = SWIG_Py_Void();
13399  return resultobj;
13400 fail:
13401  return NULL;
13402 }
13403 
13404 
13405 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13406  PyObject *resultobj = 0;
13407  PLINT arg1 ;
13408  PLINT arg2 ;
13409  int val1 ;
13410  int ecode1 = 0 ;
13411  int val2 ;
13412  int ecode2 = 0 ;
13413  PyObject * obj0 = 0 ;
13414  PyObject * obj1 = 0 ;
13415 
13416  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13417  ecode1 = SWIG_AsVal_int(obj0, &val1);
13418  if (!SWIG_IsOK(ecode1)) {
13419  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13420  }
13421  arg1 = (PLINT)(val1);
13422  ecode2 = SWIG_AsVal_int(obj1, &val2);
13423  if (!SWIG_IsOK(ecode2)) {
13424  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13425  }
13426  arg2 = (PLINT)(val2);
13427  plsxax(arg1,arg2);
13428  resultobj = SWIG_Py_Void();
13429  return resultobj;
13430 fail:
13431  return NULL;
13432 }
13433 
13434 
13435 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436  PyObject *resultobj = 0;
13437  PLINT arg1 ;
13438  PLINT arg2 ;
13439  int val1 ;
13440  int ecode1 = 0 ;
13441  int val2 ;
13442  int ecode2 = 0 ;
13443  PyObject * obj0 = 0 ;
13444  PyObject * obj1 = 0 ;
13445 
13446  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13447  ecode1 = SWIG_AsVal_int(obj0, &val1);
13448  if (!SWIG_IsOK(ecode1)) {
13449  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13450  }
13451  arg1 = (PLINT)(val1);
13452  ecode2 = SWIG_AsVal_int(obj1, &val2);
13453  if (!SWIG_IsOK(ecode2)) {
13454  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13455  }
13456  arg2 = (PLINT)(val2);
13457  plsyax(arg1,arg2);
13458  resultobj = SWIG_Py_Void();
13459  return resultobj;
13460 fail:
13461  return NULL;
13462 }
13463 
13464 
13465 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13466  PyObject *resultobj = 0;
13467  PLINT arg1 ;
13468  PLFLT *arg2 = (PLFLT *) 0 ;
13469  PLFLT *arg3 = (PLFLT *) 0 ;
13470  PLINT arg4 ;
13471  PyArrayObject *tmp1 = NULL ;
13472  PyArrayObject *tmp3 = NULL ;
13473  int val4 ;
13474  int ecode4 = 0 ;
13475  PyObject * obj0 = 0 ;
13476  PyObject * obj1 = 0 ;
13477  PyObject * obj2 = 0 ;
13478 
13479  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13480  {
13481  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13482  if ( tmp1 == NULL )
13483  return NULL;
13484  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13485  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13486  }
13487  {
13488  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13489  if ( tmp3 == NULL )
13490  return NULL;
13491  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13492  {
13493  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13494  return NULL;
13495  }
13496  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13497  }
13498  ecode4 = SWIG_AsVal_int(obj2, &val4);
13499  if (!SWIG_IsOK(ecode4)) {
13500  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13501  }
13502  arg4 = (PLINT)(val4);
13503  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13504  resultobj = SWIG_Py_Void();
13505  {
13506  Py_CLEAR( tmp1 );
13507  }
13508  {
13509  Py_CLEAR( tmp3 );
13510  }
13511  return resultobj;
13512 fail:
13513  {
13514  Py_CLEAR( tmp1 );
13515  }
13516  {
13517  Py_CLEAR( tmp3 );
13518  }
13519  return NULL;
13520 }
13521 
13522 
13523 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13524  PyObject *resultobj = 0;
13525  PLINT arg1 ;
13526  PLINT arg2 ;
13527  int val1 ;
13528  int ecode1 = 0 ;
13529  int val2 ;
13530  int ecode2 = 0 ;
13531  PyObject * obj0 = 0 ;
13532  PyObject * obj1 = 0 ;
13533 
13534  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13535  ecode1 = SWIG_AsVal_int(obj0, &val1);
13536  if (!SWIG_IsOK(ecode1)) {
13537  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13538  }
13539  arg1 = (PLINT)(val1);
13540  ecode2 = SWIG_AsVal_int(obj1, &val2);
13541  if (!SWIG_IsOK(ecode2)) {
13542  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13543  }
13544  arg2 = (PLINT)(val2);
13545  plszax(arg1,arg2);
13546  resultobj = SWIG_Py_Void();
13547  return resultobj;
13548 fail:
13549  return NULL;
13550 }
13551 
13552 
13553 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13554  PyObject *resultobj = 0;
13555 
13556  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13557  pltext();
13558  resultobj = SWIG_Py_Void();
13559  return resultobj;
13560 fail:
13561  return NULL;
13562 }
13563 
13564 
13565 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13566  PyObject *resultobj = 0;
13567  char *arg1 = (char *) 0 ;
13568  int res1 ;
13569  char *buf1 = 0 ;
13570  int alloc1 = 0 ;
13571  PyObject * obj0 = 0 ;
13572 
13573  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13574  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13575  if (!SWIG_IsOK(res1)) {
13576  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13577  }
13578  arg1 = (char *)(buf1);
13579  pltimefmt((char const *)arg1);
13580  resultobj = SWIG_Py_Void();
13581  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13582  return resultobj;
13583 fail:
13584  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13585  return NULL;
13586 }
13587 
13588 
13589 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13590  PyObject *resultobj = 0;
13591  PLFLT arg1 ;
13592  double val1 ;
13593  int ecode1 = 0 ;
13594  PyObject * obj0 = 0 ;
13595 
13596  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13597  ecode1 = SWIG_AsVal_double(obj0, &val1);
13598  if (!SWIG_IsOK(ecode1)) {
13599  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13600  }
13601  arg1 = (PLFLT)(val1);
13602  plvasp(arg1);
13603  resultobj = SWIG_Py_Void();
13604  return resultobj;
13605 fail:
13606  return NULL;
13607 }
13608 
13609 
13610 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13611  PyObject *resultobj = 0;
13612  PLFLT **arg1 = (PLFLT **) 0 ;
13613  PLFLT **arg2 = (PLFLT **) 0 ;
13614  PLINT arg3 ;
13615  PLINT arg4 ;
13616  PLFLT arg5 ;
13617  pltr_func arg6 = (pltr_func) 0 ;
13618  PLPointer arg7 = (PLPointer) 0 ;
13619  PyArrayObject *tmp1 = NULL ;
13620  PyArrayObject *tmp2 = NULL ;
13621  double val5 ;
13622  int ecode5 = 0 ;
13623  PyObject * obj0 = 0 ;
13624  PyObject * obj1 = 0 ;
13625  PyObject * obj2 = 0 ;
13626  PyObject * obj3 = 0 ;
13627  PyObject * obj4 = 0 ;
13628 
13629  {
13630  python_pltr = 0;
13631  arg6 = NULL;
13632  }
13633  {
13634  arg7 = NULL;
13635  }
13636  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13637  {
13638  int i, size;
13639  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13640  if ( tmp1 == NULL )
13641  return NULL;
13642  Xlen = PyArray_DIMS( tmp1 )[0];
13643  Ylen = PyArray_DIMS( tmp1 )[1];
13644  size = Ylen;
13645  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13646  for ( i = 0; i < Xlen; i++ )
13647  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13648  }
13649  {
13650  int i, size;
13651  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13652  if ( tmp2 == NULL )
13653  return NULL;
13654  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13655  {
13656  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13657  return NULL;
13658  }
13659  arg3 = PyArray_DIMS( tmp2 )[0];
13660  arg4 = PyArray_DIMS( tmp2 )[1];
13661  size = arg4;
13662  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13663  for ( i = 0; i < arg3; i++ )
13664  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13665  }
13666  ecode5 = SWIG_AsVal_double(obj2, &val5);
13667  if (!SWIG_IsOK(ecode5)) {
13668  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13669  }
13670  arg5 = (PLFLT)(val5);
13671  if (obj3) {
13672  {
13673  // it must be a callable or None
13674  if ( obj3 == Py_None )
13675  {
13676  arg6 = NULL;
13677  }
13678  else
13679  {
13680  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13681  {
13682  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13683  return NULL;
13684  }
13685  arg6 = marshal_pltr( obj3 );
13686  }
13687  }
13688  }
13689  if (obj4) {
13690  {
13691  if ( obj4 == Py_None )
13692  arg7 = NULL;
13693  else
13694  {
13695  arg7 = marshal_PLPointer( obj4, 0 );
13696  }
13697  }
13698  }
13699  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13700  resultobj = SWIG_Py_Void();
13701  {
13702  Py_CLEAR( tmp1 );
13703  free( arg1 );
13704  }
13705  {
13706  Py_CLEAR( tmp2 );
13707  free( arg2 );
13708  }
13709  {
13710  cleanup_pltr();
13711  }
13712  {
13714  }
13715  return resultobj;
13716 fail:
13717  {
13718  Py_CLEAR( tmp1 );
13719  free( arg1 );
13720  }
13721  {
13722  Py_CLEAR( tmp2 );
13723  free( arg2 );
13724  }
13725  {
13726  cleanup_pltr();
13727  }
13728  {
13730  }
13731  return NULL;
13732 }
13733 
13734 
13735 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13736  PyObject *resultobj = 0;
13737  PLFLT arg1 ;
13738  PLFLT arg2 ;
13739  PLFLT arg3 ;
13740  PLFLT arg4 ;
13741  PLFLT arg5 ;
13742  double val1 ;
13743  int ecode1 = 0 ;
13744  double val2 ;
13745  int ecode2 = 0 ;
13746  double val3 ;
13747  int ecode3 = 0 ;
13748  double val4 ;
13749  int ecode4 = 0 ;
13750  double val5 ;
13751  int ecode5 = 0 ;
13752  PyObject * obj0 = 0 ;
13753  PyObject * obj1 = 0 ;
13754  PyObject * obj2 = 0 ;
13755  PyObject * obj3 = 0 ;
13756  PyObject * obj4 = 0 ;
13757 
13758  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13759  ecode1 = SWIG_AsVal_double(obj0, &val1);
13760  if (!SWIG_IsOK(ecode1)) {
13761  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13762  }
13763  arg1 = (PLFLT)(val1);
13764  ecode2 = SWIG_AsVal_double(obj1, &val2);
13765  if (!SWIG_IsOK(ecode2)) {
13766  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13767  }
13768  arg2 = (PLFLT)(val2);
13769  ecode3 = SWIG_AsVal_double(obj2, &val3);
13770  if (!SWIG_IsOK(ecode3)) {
13771  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13772  }
13773  arg3 = (PLFLT)(val3);
13774  ecode4 = SWIG_AsVal_double(obj3, &val4);
13775  if (!SWIG_IsOK(ecode4)) {
13776  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13777  }
13778  arg4 = (PLFLT)(val4);
13779  ecode5 = SWIG_AsVal_double(obj4, &val5);
13780  if (!SWIG_IsOK(ecode5)) {
13781  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13782  }
13783  arg5 = (PLFLT)(val5);
13784  plvpas(arg1,arg2,arg3,arg4,arg5);
13785  resultobj = SWIG_Py_Void();
13786  return resultobj;
13787 fail:
13788  return NULL;
13789 }
13790 
13791 
13792 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13793  PyObject *resultobj = 0;
13794  PLFLT arg1 ;
13795  PLFLT arg2 ;
13796  PLFLT arg3 ;
13797  PLFLT arg4 ;
13798  double val1 ;
13799  int ecode1 = 0 ;
13800  double val2 ;
13801  int ecode2 = 0 ;
13802  double val3 ;
13803  int ecode3 = 0 ;
13804  double val4 ;
13805  int ecode4 = 0 ;
13806  PyObject * obj0 = 0 ;
13807  PyObject * obj1 = 0 ;
13808  PyObject * obj2 = 0 ;
13809  PyObject * obj3 = 0 ;
13810 
13811  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13812  ecode1 = SWIG_AsVal_double(obj0, &val1);
13813  if (!SWIG_IsOK(ecode1)) {
13814  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13815  }
13816  arg1 = (PLFLT)(val1);
13817  ecode2 = SWIG_AsVal_double(obj1, &val2);
13818  if (!SWIG_IsOK(ecode2)) {
13819  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13820  }
13821  arg2 = (PLFLT)(val2);
13822  ecode3 = SWIG_AsVal_double(obj2, &val3);
13823  if (!SWIG_IsOK(ecode3)) {
13824  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13825  }
13826  arg3 = (PLFLT)(val3);
13827  ecode4 = SWIG_AsVal_double(obj3, &val4);
13828  if (!SWIG_IsOK(ecode4)) {
13829  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13830  }
13831  arg4 = (PLFLT)(val4);
13832  plvpor(arg1,arg2,arg3,arg4);
13833  resultobj = SWIG_Py_Void();
13834  return resultobj;
13835 fail:
13836  return NULL;
13837 }
13838 
13839 
13840 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13841  PyObject *resultobj = 0;
13842 
13843  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13844  plvsta();
13845  resultobj = SWIG_Py_Void();
13846  return resultobj;
13847 fail:
13848  return NULL;
13849 }
13850 
13851 
13852 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13853  PyObject *resultobj = 0;
13854  PLFLT arg1 ;
13855  PLFLT arg2 ;
13856  PLFLT arg3 ;
13857  PLFLT arg4 ;
13858  PLFLT arg5 ;
13859  PLFLT arg6 ;
13860  PLFLT arg7 ;
13861  PLFLT arg8 ;
13862  PLFLT arg9 ;
13863  PLFLT arg10 ;
13864  PLFLT arg11 ;
13865  double val1 ;
13866  int ecode1 = 0 ;
13867  double val2 ;
13868  int ecode2 = 0 ;
13869  double val3 ;
13870  int ecode3 = 0 ;
13871  double val4 ;
13872  int ecode4 = 0 ;
13873  double val5 ;
13874  int ecode5 = 0 ;
13875  double val6 ;
13876  int ecode6 = 0 ;
13877  double val7 ;
13878  int ecode7 = 0 ;
13879  double val8 ;
13880  int ecode8 = 0 ;
13881  double val9 ;
13882  int ecode9 = 0 ;
13883  double val10 ;
13884  int ecode10 = 0 ;
13885  double val11 ;
13886  int ecode11 = 0 ;
13887  PyObject * obj0 = 0 ;
13888  PyObject * obj1 = 0 ;
13889  PyObject * obj2 = 0 ;
13890  PyObject * obj3 = 0 ;
13891  PyObject * obj4 = 0 ;
13892  PyObject * obj5 = 0 ;
13893  PyObject * obj6 = 0 ;
13894  PyObject * obj7 = 0 ;
13895  PyObject * obj8 = 0 ;
13896  PyObject * obj9 = 0 ;
13897  PyObject * obj10 = 0 ;
13898 
13899  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13900  ecode1 = SWIG_AsVal_double(obj0, &val1);
13901  if (!SWIG_IsOK(ecode1)) {
13902  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13903  }
13904  arg1 = (PLFLT)(val1);
13905  ecode2 = SWIG_AsVal_double(obj1, &val2);
13906  if (!SWIG_IsOK(ecode2)) {
13907  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13908  }
13909  arg2 = (PLFLT)(val2);
13910  ecode3 = SWIG_AsVal_double(obj2, &val3);
13911  if (!SWIG_IsOK(ecode3)) {
13912  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13913  }
13914  arg3 = (PLFLT)(val3);
13915  ecode4 = SWIG_AsVal_double(obj3, &val4);
13916  if (!SWIG_IsOK(ecode4)) {
13917  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13918  }
13919  arg4 = (PLFLT)(val4);
13920  ecode5 = SWIG_AsVal_double(obj4, &val5);
13921  if (!SWIG_IsOK(ecode5)) {
13922  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13923  }
13924  arg5 = (PLFLT)(val5);
13925  ecode6 = SWIG_AsVal_double(obj5, &val6);
13926  if (!SWIG_IsOK(ecode6)) {
13927  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13928  }
13929  arg6 = (PLFLT)(val6);
13930  ecode7 = SWIG_AsVal_double(obj6, &val7);
13931  if (!SWIG_IsOK(ecode7)) {
13932  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13933  }
13934  arg7 = (PLFLT)(val7);
13935  ecode8 = SWIG_AsVal_double(obj7, &val8);
13936  if (!SWIG_IsOK(ecode8)) {
13937  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13938  }
13939  arg8 = (PLFLT)(val8);
13940  ecode9 = SWIG_AsVal_double(obj8, &val9);
13941  if (!SWIG_IsOK(ecode9)) {
13942  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13943  }
13944  arg9 = (PLFLT)(val9);
13945  ecode10 = SWIG_AsVal_double(obj9, &val10);
13946  if (!SWIG_IsOK(ecode10)) {
13947  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13948  }
13949  arg10 = (PLFLT)(val10);
13950  ecode11 = SWIG_AsVal_double(obj10, &val11);
13951  if (!SWIG_IsOK(ecode11)) {
13952  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13953  }
13954  arg11 = (PLFLT)(val11);
13955  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13956  resultobj = SWIG_Py_Void();
13957  return resultobj;
13958 fail:
13959  return NULL;
13960 }
13961 
13962 
13963 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964  PyObject *resultobj = 0;
13965  PLFLT arg1 ;
13966  double val1 ;
13967  int ecode1 = 0 ;
13968  PyObject * obj0 = 0 ;
13969 
13970  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13971  ecode1 = SWIG_AsVal_double(obj0, &val1);
13972  if (!SWIG_IsOK(ecode1)) {
13973  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13974  }
13975  arg1 = (PLFLT)(val1);
13976  plwidth(arg1);
13977  resultobj = SWIG_Py_Void();
13978  return resultobj;
13979 fail:
13980  return NULL;
13981 }
13982 
13983 
13984 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13985  PyObject *resultobj = 0;
13986  PLFLT arg1 ;
13987  PLFLT arg2 ;
13988  PLFLT arg3 ;
13989  PLFLT arg4 ;
13990  double val1 ;
13991  int ecode1 = 0 ;
13992  double val2 ;
13993  int ecode2 = 0 ;
13994  double val3 ;
13995  int ecode3 = 0 ;
13996  double val4 ;
13997  int ecode4 = 0 ;
13998  PyObject * obj0 = 0 ;
13999  PyObject * obj1 = 0 ;
14000  PyObject * obj2 = 0 ;
14001  PyObject * obj3 = 0 ;
14002 
14003  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14004  ecode1 = SWIG_AsVal_double(obj0, &val1);
14005  if (!SWIG_IsOK(ecode1)) {
14006  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14007  }
14008  arg1 = (PLFLT)(val1);
14009  ecode2 = SWIG_AsVal_double(obj1, &val2);
14010  if (!SWIG_IsOK(ecode2)) {
14011  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14012  }
14013  arg2 = (PLFLT)(val2);
14014  ecode3 = SWIG_AsVal_double(obj2, &val3);
14015  if (!SWIG_IsOK(ecode3)) {
14016  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14017  }
14018  arg3 = (PLFLT)(val3);
14019  ecode4 = SWIG_AsVal_double(obj3, &val4);
14020  if (!SWIG_IsOK(ecode4)) {
14021  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14022  }
14023  arg4 = (PLFLT)(val4);
14024  plwind(arg1,arg2,arg3,arg4);
14025  resultobj = SWIG_Py_Void();
14026  return resultobj;
14027 fail:
14028  return NULL;
14029 }
14030 
14031 
14032 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14033  PyObject *resultobj = 0;
14034  PLBOOL arg1 ;
14035  PLBOOL *arg2 = (PLBOOL *) 0 ;
14036  int val1 ;
14037  int ecode1 = 0 ;
14038  PLBOOL temp2 ;
14039  int res2 = SWIG_TMPOBJ ;
14040  PyObject * obj0 = 0 ;
14041 
14042  arg2 = &temp2;
14043  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14044  ecode1 = SWIG_AsVal_int(obj0, &val1);
14045  if (!SWIG_IsOK(ecode1)) {
14046  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14047  }
14048  arg1 = (PLBOOL)(val1);
14049  plxormod(arg1,arg2);
14050  resultobj = SWIG_Py_Void();
14051  if (SWIG_IsTmpObj(res2)) {
14052  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14053  } else {
14054  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14055  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14056  }
14057  return resultobj;
14058 fail:
14059  return NULL;
14060 }
14061 
14062 
14063 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14064  PyObject *resultobj = 0;
14065  mapform_func arg1 = (mapform_func) 0 ;
14066  char *arg2 = (char *) 0 ;
14067  PLFLT arg3 ;
14068  PLFLT arg4 ;
14069  PLFLT arg5 ;
14070  PLFLT arg6 ;
14071  int res2 ;
14072  char *buf2 = 0 ;
14073  int alloc2 = 0 ;
14074  double val3 ;
14075  int ecode3 = 0 ;
14076  double val4 ;
14077  int ecode4 = 0 ;
14078  double val5 ;
14079  int ecode5 = 0 ;
14080  double val6 ;
14081  int ecode6 = 0 ;
14082  PyObject * obj0 = 0 ;
14083  PyObject * obj1 = 0 ;
14084  PyObject * obj2 = 0 ;
14085  PyObject * obj3 = 0 ;
14086  PyObject * obj4 = 0 ;
14087  PyObject * obj5 = 0 ;
14088 
14089  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14090  {
14091  // it must be a callable or none
14092  if ( obj0 == Py_None )
14093  {
14094  arg1 = NULL;
14095  }
14096  else
14097  {
14098  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14099  {
14100  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14101  return NULL;
14102  }
14103  arg1 = marshal_mapform( obj0 );
14104  }
14105  }
14106  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14107  if (!SWIG_IsOK(res2)) {
14108  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14109  }
14110  arg2 = (char *)(buf2);
14111  ecode3 = SWIG_AsVal_double(obj2, &val3);
14112  if (!SWIG_IsOK(ecode3)) {
14113  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14114  }
14115  arg3 = (PLFLT)(val3);
14116  ecode4 = SWIG_AsVal_double(obj3, &val4);
14117  if (!SWIG_IsOK(ecode4)) {
14118  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14119  }
14120  arg4 = (PLFLT)(val4);
14121  ecode5 = SWIG_AsVal_double(obj4, &val5);
14122  if (!SWIG_IsOK(ecode5)) {
14123  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14124  }
14125  arg5 = (PLFLT)(val5);
14126  ecode6 = SWIG_AsVal_double(obj5, &val6);
14127  if (!SWIG_IsOK(ecode6)) {
14128  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14129  }
14130  arg6 = (PLFLT)(val6);
14131  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14132  resultobj = SWIG_Py_Void();
14133  {
14134  cleanup_mapform();
14135  }
14136  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14137  return resultobj;
14138 fail:
14139  {
14140  cleanup_mapform();
14141  }
14142  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14143  return NULL;
14144 }
14145 
14146 
14147 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14148  PyObject *resultobj = 0;
14149  mapform_func arg1 = (mapform_func) 0 ;
14150  char *arg2 = (char *) 0 ;
14151  PLFLT arg3 ;
14152  PLFLT arg4 ;
14153  PLFLT arg5 ;
14154  PLFLT arg6 ;
14155  PLINT *arg7 = (PLINT *) 0 ;
14156  PLINT arg8 ;
14157  int res2 ;
14158  char *buf2 = 0 ;
14159  int alloc2 = 0 ;
14160  double val3 ;
14161  int ecode3 = 0 ;
14162  double val4 ;
14163  int ecode4 = 0 ;
14164  double val5 ;
14165  int ecode5 = 0 ;
14166  double val6 ;
14167  int ecode6 = 0 ;
14168  PyArrayObject *tmp7 = NULL ;
14169  PyObject * obj0 = 0 ;
14170  PyObject * obj1 = 0 ;
14171  PyObject * obj2 = 0 ;
14172  PyObject * obj3 = 0 ;
14173  PyObject * obj4 = 0 ;
14174  PyObject * obj5 = 0 ;
14175  PyObject * obj6 = 0 ;
14176 
14177  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14178  {
14179  // it must be a callable or none
14180  if ( obj0 == Py_None )
14181  {
14182  arg1 = NULL;
14183  }
14184  else
14185  {
14186  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14187  {
14188  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14189  return NULL;
14190  }
14191  arg1 = marshal_mapform( obj0 );
14192  }
14193  }
14194  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14195  if (!SWIG_IsOK(res2)) {
14196  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14197  }
14198  arg2 = (char *)(buf2);
14199  ecode3 = SWIG_AsVal_double(obj2, &val3);
14200  if (!SWIG_IsOK(ecode3)) {
14201  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14202  }
14203  arg3 = (PLFLT)(val3);
14204  ecode4 = SWIG_AsVal_double(obj3, &val4);
14205  if (!SWIG_IsOK(ecode4)) {
14206  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14207  }
14208  arg4 = (PLFLT)(val4);
14209  ecode5 = SWIG_AsVal_double(obj4, &val5);
14210  if (!SWIG_IsOK(ecode5)) {
14211  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14212  }
14213  arg5 = (PLFLT)(val5);
14214  ecode6 = SWIG_AsVal_double(obj5, &val6);
14215  if (!SWIG_IsOK(ecode6)) {
14216  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14217  }
14218  arg6 = (PLFLT)(val6);
14219  {
14220  if ( obj6 != Py_None )
14221  {
14222  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14223  if ( tmp7 == NULL )
14224  return NULL;
14225  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14226  arg8 = PyArray_DIMS( tmp7 )[0];
14227  }
14228  else
14229  {
14230  arg7 = NULL;
14231  arg8 = 0;
14232  }
14233  }
14234  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14235  resultobj = SWIG_Py_Void();
14236  {
14237  cleanup_mapform();
14238  }
14239  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14240  {
14241  Py_CLEAR( tmp7 );
14242  }
14243  return resultobj;
14244 fail:
14245  {
14246  cleanup_mapform();
14247  }
14248  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14249  {
14250  Py_CLEAR( tmp7 );
14251  }
14252  return NULL;
14253 }
14254 
14255 
14256 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14257  PyObject *resultobj = 0;
14258  mapform_func arg1 = (mapform_func) 0 ;
14259  char *arg2 = (char *) 0 ;
14260  char *arg3 = (char *) 0 ;
14261  PLFLT arg4 ;
14262  PLFLT arg5 ;
14263  PLFLT arg6 ;
14264  PLFLT arg7 ;
14265  PLINT *arg8 = (PLINT *) 0 ;
14266  PLINT arg9 ;
14267  int res2 ;
14268  char *buf2 = 0 ;
14269  int alloc2 = 0 ;
14270  int res3 ;
14271  char *buf3 = 0 ;
14272  int alloc3 = 0 ;
14273  double val4 ;
14274  int ecode4 = 0 ;
14275  double val5 ;
14276  int ecode5 = 0 ;
14277  double val6 ;
14278  int ecode6 = 0 ;
14279  double val7 ;
14280  int ecode7 = 0 ;
14281  PyArrayObject *tmp8 = NULL ;
14282  PyObject * obj0 = 0 ;
14283  PyObject * obj1 = 0 ;
14284  PyObject * obj2 = 0 ;
14285  PyObject * obj3 = 0 ;
14286  PyObject * obj4 = 0 ;
14287  PyObject * obj5 = 0 ;
14288  PyObject * obj6 = 0 ;
14289  PyObject * obj7 = 0 ;
14290 
14291  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
14292  {
14293  // it must be a callable or none
14294  if ( obj0 == Py_None )
14295  {
14296  arg1 = NULL;
14297  }
14298  else
14299  {
14300  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14301  {
14302  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14303  return NULL;
14304  }
14305  arg1 = marshal_mapform( obj0 );
14306  }
14307  }
14308  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14309  if (!SWIG_IsOK(res2)) {
14310  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14311  }
14312  arg2 = (char *)(buf2);
14313  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
14314  if (!SWIG_IsOK(res3)) {
14315  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14316  }
14317  arg3 = (char *)(buf3);
14318  ecode4 = SWIG_AsVal_double(obj3, &val4);
14319  if (!SWIG_IsOK(ecode4)) {
14320  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14321  }
14322  arg4 = (PLFLT)(val4);
14323  ecode5 = SWIG_AsVal_double(obj4, &val5);
14324  if (!SWIG_IsOK(ecode5)) {
14325  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14326  }
14327  arg5 = (PLFLT)(val5);
14328  ecode6 = SWIG_AsVal_double(obj5, &val6);
14329  if (!SWIG_IsOK(ecode6)) {
14330  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14331  }
14332  arg6 = (PLFLT)(val6);
14333  ecode7 = SWIG_AsVal_double(obj6, &val7);
14334  if (!SWIG_IsOK(ecode7)) {
14335  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14336  }
14337  arg7 = (PLFLT)(val7);
14338  {
14339  if ( obj7 != Py_None )
14340  {
14341  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
14342  if ( tmp8 == NULL )
14343  return NULL;
14344  arg8 = (PLINT *) PyArray_DATA( tmp8 );
14345  arg9 = PyArray_DIMS( tmp8 )[0];
14346  }
14347  else
14348  {
14349  arg8 = NULL;
14350  arg9 = 0;
14351  }
14352  }
14353  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14354  resultobj = SWIG_Py_Void();
14355  {
14356  cleanup_mapform();
14357  }
14358  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14359  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14360  {
14361  Py_CLEAR( tmp8 );
14362  }
14363  return resultobj;
14364 fail:
14365  {
14366  cleanup_mapform();
14367  }
14368  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14369  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14370  {
14371  Py_CLEAR( tmp8 );
14372  }
14373  return NULL;
14374 }
14375 
14376 
14377 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14378  PyObject *resultobj = 0;
14379  mapform_func arg1 = (mapform_func) 0 ;
14380  char *arg2 = (char *) 0 ;
14381  PLFLT arg3 ;
14382  PLFLT arg4 ;
14383  PLFLT arg5 ;
14384  char *arg6 = (char *) 0 ;
14385  PLFLT arg7 ;
14386  PLFLT arg8 ;
14387  PLFLT arg9 ;
14388  PLFLT arg10 ;
14389  PLINT arg11 ;
14390  int res2 ;
14391  char *buf2 = 0 ;
14392  int alloc2 = 0 ;
14393  double val3 ;
14394  int ecode3 = 0 ;
14395  double val4 ;
14396  int ecode4 = 0 ;
14397  double val5 ;
14398  int ecode5 = 0 ;
14399  int res6 ;
14400  char *buf6 = 0 ;
14401  int alloc6 = 0 ;
14402  double val7 ;
14403  int ecode7 = 0 ;
14404  double val8 ;
14405  int ecode8 = 0 ;
14406  double val9 ;
14407  int ecode9 = 0 ;
14408  double val10 ;
14409  int ecode10 = 0 ;
14410  int val11 ;
14411  int ecode11 = 0 ;
14412  PyObject * obj0 = 0 ;
14413  PyObject * obj1 = 0 ;
14414  PyObject * obj2 = 0 ;
14415  PyObject * obj3 = 0 ;
14416  PyObject * obj4 = 0 ;
14417  PyObject * obj5 = 0 ;
14418  PyObject * obj6 = 0 ;
14419  PyObject * obj7 = 0 ;
14420  PyObject * obj8 = 0 ;
14421  PyObject * obj9 = 0 ;
14422  PyObject * obj10 = 0 ;
14423 
14424  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14425  {
14426  // it must be a callable or none
14427  if ( obj0 == Py_None )
14428  {
14429  arg1 = NULL;
14430  }
14431  else
14432  {
14433  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14434  {
14435  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14436  return NULL;
14437  }
14438  arg1 = marshal_mapform( obj0 );
14439  }
14440  }
14441  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14442  if (!SWIG_IsOK(res2)) {
14443  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14444  }
14445  arg2 = (char *)(buf2);
14446  ecode3 = SWIG_AsVal_double(obj2, &val3);
14447  if (!SWIG_IsOK(ecode3)) {
14448  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14449  }
14450  arg3 = (PLFLT)(val3);
14451  ecode4 = SWIG_AsVal_double(obj3, &val4);
14452  if (!SWIG_IsOK(ecode4)) {
14453  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14454  }
14455  arg4 = (PLFLT)(val4);
14456  ecode5 = SWIG_AsVal_double(obj4, &val5);
14457  if (!SWIG_IsOK(ecode5)) {
14458  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14459  }
14460  arg5 = (PLFLT)(val5);
14461  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
14462  if (!SWIG_IsOK(res6)) {
14463  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14464  }
14465  arg6 = (char *)(buf6);
14466  ecode7 = SWIG_AsVal_double(obj6, &val7);
14467  if (!SWIG_IsOK(ecode7)) {
14468  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14469  }
14470  arg7 = (PLFLT)(val7);
14471  ecode8 = SWIG_AsVal_double(obj7, &val8);
14472  if (!SWIG_IsOK(ecode8)) {
14473  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14474  }
14475  arg8 = (PLFLT)(val8);
14476  ecode9 = SWIG_AsVal_double(obj8, &val9);
14477  if (!SWIG_IsOK(ecode9)) {
14478  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14479  }
14480  arg9 = (PLFLT)(val9);
14481  ecode10 = SWIG_AsVal_double(obj9, &val10);
14482  if (!SWIG_IsOK(ecode10)) {
14483  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14484  }
14485  arg10 = (PLFLT)(val10);
14486  ecode11 = SWIG_AsVal_int(obj10, &val11);
14487  if (!SWIG_IsOK(ecode11)) {
14488  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14489  }
14490  arg11 = (PLINT)(val11);
14491  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14492  resultobj = SWIG_Py_Void();
14493  {
14494  cleanup_mapform();
14495  }
14496  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14497  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14498  return resultobj;
14499 fail:
14500  {
14501  cleanup_mapform();
14502  }
14503  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14504  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14505  return NULL;
14506 }
14507 
14508 
14509 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14510  PyObject *resultobj = 0;
14511  mapform_func arg1 = (mapform_func) 0 ;
14512  char *arg2 = (char *) 0 ;
14513  PLFLT arg3 ;
14514  PLFLT arg4 ;
14515  PLFLT arg5 ;
14516  PLFLT arg6 ;
14517  PLINT *arg7 = (PLINT *) 0 ;
14518  PLINT arg8 ;
14519  int res2 ;
14520  char *buf2 = 0 ;
14521  int alloc2 = 0 ;
14522  double val3 ;
14523  int ecode3 = 0 ;
14524  double val4 ;
14525  int ecode4 = 0 ;
14526  double val5 ;
14527  int ecode5 = 0 ;
14528  double val6 ;
14529  int ecode6 = 0 ;
14530  PyArrayObject *tmp7 = NULL ;
14531  PyObject * obj0 = 0 ;
14532  PyObject * obj1 = 0 ;
14533  PyObject * obj2 = 0 ;
14534  PyObject * obj3 = 0 ;
14535  PyObject * obj4 = 0 ;
14536  PyObject * obj5 = 0 ;
14537  PyObject * obj6 = 0 ;
14538 
14539  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14540  {
14541  // it must be a callable or none
14542  if ( obj0 == Py_None )
14543  {
14544  arg1 = NULL;
14545  }
14546  else
14547  {
14548  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14549  {
14550  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14551  return NULL;
14552  }
14553  arg1 = marshal_mapform( obj0 );
14554  }
14555  }
14556  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14557  if (!SWIG_IsOK(res2)) {
14558  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14559  }
14560  arg2 = (char *)(buf2);
14561  ecode3 = SWIG_AsVal_double(obj2, &val3);
14562  if (!SWIG_IsOK(ecode3)) {
14563  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14564  }
14565  arg3 = (PLFLT)(val3);
14566  ecode4 = SWIG_AsVal_double(obj3, &val4);
14567  if (!SWIG_IsOK(ecode4)) {
14568  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14569  }
14570  arg4 = (PLFLT)(val4);
14571  ecode5 = SWIG_AsVal_double(obj4, &val5);
14572  if (!SWIG_IsOK(ecode5)) {
14573  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14574  }
14575  arg5 = (PLFLT)(val5);
14576  ecode6 = SWIG_AsVal_double(obj5, &val6);
14577  if (!SWIG_IsOK(ecode6)) {
14578  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14579  }
14580  arg6 = (PLFLT)(val6);
14581  {
14582  if ( obj6 != Py_None )
14583  {
14584  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14585  if ( tmp7 == NULL )
14586  return NULL;
14587  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14588  arg8 = PyArray_DIMS( tmp7 )[0];
14589  }
14590  else
14591  {
14592  arg7 = NULL;
14593  arg8 = 0;
14594  }
14595  }
14596  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14597  resultobj = SWIG_Py_Void();
14598  {
14599  cleanup_mapform();
14600  }
14601  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14602  {
14603  Py_CLEAR( tmp7 );
14604  }
14605  return resultobj;
14606 fail:
14607  {
14608  cleanup_mapform();
14609  }
14610  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14611  {
14612  Py_CLEAR( tmp7 );
14613  }
14614  return NULL;
14615 }
14616 
14617 
14618 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14619  PyObject *resultobj = 0;
14620  mapform_func arg1 = (mapform_func) 0 ;
14621  PLFLT arg2 ;
14622  PLFLT arg3 ;
14623  PLFLT arg4 ;
14624  PLFLT arg5 ;
14625  PLFLT arg6 ;
14626  PLFLT arg7 ;
14627  double val2 ;
14628  int ecode2 = 0 ;
14629  double val3 ;
14630  int ecode3 = 0 ;
14631  double val4 ;
14632  int ecode4 = 0 ;
14633  double val5 ;
14634  int ecode5 = 0 ;
14635  double val6 ;
14636  int ecode6 = 0 ;
14637  double val7 ;
14638  int ecode7 = 0 ;
14639  PyObject * obj0 = 0 ;
14640  PyObject * obj1 = 0 ;
14641  PyObject * obj2 = 0 ;
14642  PyObject * obj3 = 0 ;
14643  PyObject * obj4 = 0 ;
14644  PyObject * obj5 = 0 ;
14645  PyObject * obj6 = 0 ;
14646 
14647  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14648  {
14649  // it must be a callable or none
14650  if ( obj0 == Py_None )
14651  {
14652  arg1 = NULL;
14653  }
14654  else
14655  {
14656  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14657  {
14658  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14659  return NULL;
14660  }
14661  arg1 = marshal_mapform( obj0 );
14662  }
14663  }
14664  ecode2 = SWIG_AsVal_double(obj1, &val2);
14665  if (!SWIG_IsOK(ecode2)) {
14666  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14667  }
14668  arg2 = (PLFLT)(val2);
14669  ecode3 = SWIG_AsVal_double(obj2, &val3);
14670  if (!SWIG_IsOK(ecode3)) {
14671  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14672  }
14673  arg3 = (PLFLT)(val3);
14674  ecode4 = SWIG_AsVal_double(obj3, &val4);
14675  if (!SWIG_IsOK(ecode4)) {
14676  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14677  }
14678  arg4 = (PLFLT)(val4);
14679  ecode5 = SWIG_AsVal_double(obj4, &val5);
14680  if (!SWIG_IsOK(ecode5)) {
14681  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14682  }
14683  arg5 = (PLFLT)(val5);
14684  ecode6 = SWIG_AsVal_double(obj5, &val6);
14685  if (!SWIG_IsOK(ecode6)) {
14686  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14687  }
14688  arg6 = (PLFLT)(val6);
14689  ecode7 = SWIG_AsVal_double(obj6, &val7);
14690  if (!SWIG_IsOK(ecode7)) {
14691  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14692  }
14693  arg7 = (PLFLT)(val7);
14694  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14695  resultobj = SWIG_Py_Void();
14696  {
14697  cleanup_mapform();
14698  }
14699  return resultobj;
14700 fail:
14701  {
14702  cleanup_mapform();
14703  }
14704  return NULL;
14705 }
14706 
14707 
14708 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14709  PyObject *resultobj = 0;
14710  PLFLT **arg1 = (PLFLT **) 0 ;
14711  PLINT arg2 ;
14712  PLINT arg3 ;
14713  PLFLT arg4 ;
14714  PLFLT arg5 ;
14715  PLFLT arg6 ;
14716  PLFLT arg7 ;
14717  PLFLT arg8 ;
14718  PLFLT arg9 ;
14719  PLFLT arg10 ;
14720  PLFLT arg11 ;
14721  PLFLT arg12 ;
14722  PLFLT arg13 ;
14723  PyArrayObject *tmp1 = NULL ;
14724  double val4 ;
14725  int ecode4 = 0 ;
14726  double val5 ;
14727  int ecode5 = 0 ;
14728  double val6 ;
14729  int ecode6 = 0 ;
14730  double val7 ;
14731  int ecode7 = 0 ;
14732  double val8 ;
14733  int ecode8 = 0 ;
14734  double val9 ;
14735  int ecode9 = 0 ;
14736  double val10 ;
14737  int ecode10 = 0 ;
14738  double val11 ;
14739  int ecode11 = 0 ;
14740  double val12 ;
14741  int ecode12 = 0 ;
14742  double val13 ;
14743  int ecode13 = 0 ;
14744  PyObject * obj0 = 0 ;
14745  PyObject * obj1 = 0 ;
14746  PyObject * obj2 = 0 ;
14747  PyObject * obj3 = 0 ;
14748  PyObject * obj4 = 0 ;
14749  PyObject * obj5 = 0 ;
14750  PyObject * obj6 = 0 ;
14751  PyObject * obj7 = 0 ;
14752  PyObject * obj8 = 0 ;
14753  PyObject * obj9 = 0 ;
14754  PyObject * obj10 = 0 ;
14755 
14756  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14757  {
14758  int i, size;
14759  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14760  if ( tmp1 == NULL )
14761  return NULL;
14762  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14763  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14764  size = arg3;
14765  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14766  for ( i = 0; i < arg2; i++ )
14767  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14768  }
14769  ecode4 = SWIG_AsVal_double(obj1, &val4);
14770  if (!SWIG_IsOK(ecode4)) {
14771  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14772  }
14773  arg4 = (PLFLT)(val4);
14774  ecode5 = SWIG_AsVal_double(obj2, &val5);
14775  if (!SWIG_IsOK(ecode5)) {
14776  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14777  }
14778  arg5 = (PLFLT)(val5);
14779  ecode6 = SWIG_AsVal_double(obj3, &val6);
14780  if (!SWIG_IsOK(ecode6)) {
14781  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14782  }
14783  arg6 = (PLFLT)(val6);
14784  ecode7 = SWIG_AsVal_double(obj4, &val7);
14785  if (!SWIG_IsOK(ecode7)) {
14786  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14787  }
14788  arg7 = (PLFLT)(val7);
14789  ecode8 = SWIG_AsVal_double(obj5, &val8);
14790  if (!SWIG_IsOK(ecode8)) {
14791  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14792  }
14793  arg8 = (PLFLT)(val8);
14794  ecode9 = SWIG_AsVal_double(obj6, &val9);
14795  if (!SWIG_IsOK(ecode9)) {
14796  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14797  }
14798  arg9 = (PLFLT)(val9);
14799  ecode10 = SWIG_AsVal_double(obj7, &val10);
14800  if (!SWIG_IsOK(ecode10)) {
14801  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14802  }
14803  arg10 = (PLFLT)(val10);
14804  ecode11 = SWIG_AsVal_double(obj8, &val11);
14805  if (!SWIG_IsOK(ecode11)) {
14806  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14807  }
14808  arg11 = (PLFLT)(val11);
14809  ecode12 = SWIG_AsVal_double(obj9, &val12);
14810  if (!SWIG_IsOK(ecode12)) {
14811  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14812  }
14813  arg12 = (PLFLT)(val12);
14814  ecode13 = SWIG_AsVal_double(obj10, &val13);
14815  if (!SWIG_IsOK(ecode13)) {
14816  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14817  }
14818  arg13 = (PLFLT)(val13);
14819  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14820  resultobj = SWIG_Py_Void();
14821  {
14822  Py_CLEAR( tmp1 );
14823  free( arg1 );
14824  }
14825  return resultobj;
14826 fail:
14827  {
14828  Py_CLEAR( tmp1 );
14829  free( arg1 );
14830  }
14831  return NULL;
14832 }
14833 
14834 
14835 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14836  PyObject *resultobj = 0;
14837  PLFLT **arg1 = (PLFLT **) 0 ;
14838  PLINT arg2 ;
14839  PLINT arg3 ;
14840  PLFLT arg4 ;
14841  PLFLT arg5 ;
14842  PLFLT arg6 ;
14843  PLFLT arg7 ;
14844  PLFLT arg8 ;
14845  PLFLT arg9 ;
14846  PLFLT arg10 ;
14847  PLFLT arg11 ;
14848  pltr_func arg12 = (pltr_func) 0 ;
14849  PLPointer arg13 = (PLPointer) 0 ;
14850  PyArrayObject *tmp1 = NULL ;
14851  double val4 ;
14852  int ecode4 = 0 ;
14853  double val5 ;
14854  int ecode5 = 0 ;
14855  double val6 ;
14856  int ecode6 = 0 ;
14857  double val7 ;
14858  int ecode7 = 0 ;
14859  double val8 ;
14860  int ecode8 = 0 ;
14861  double val9 ;
14862  int ecode9 = 0 ;
14863  double val10 ;
14864  int ecode10 = 0 ;
14865  double val11 ;
14866  int ecode11 = 0 ;
14867  PyObject * obj0 = 0 ;
14868  PyObject * obj1 = 0 ;
14869  PyObject * obj2 = 0 ;
14870  PyObject * obj3 = 0 ;
14871  PyObject * obj4 = 0 ;
14872  PyObject * obj5 = 0 ;
14873  PyObject * obj6 = 0 ;
14874  PyObject * obj7 = 0 ;
14875  PyObject * obj8 = 0 ;
14876  PyObject * obj9 = 0 ;
14877  PyObject * obj10 = 0 ;
14878 
14879  {
14880  python_pltr = 0;
14881  arg12 = NULL;
14882  }
14883  {
14884  arg13 = NULL;
14885  }
14886  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14887  {
14888  int i, size;
14889  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14890  if ( tmp1 == NULL )
14891  return NULL;
14892  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14893  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14894  size = arg3;
14895  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14896  for ( i = 0; i < arg2; i++ )
14897  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14898  }
14899  ecode4 = SWIG_AsVal_double(obj1, &val4);
14900  if (!SWIG_IsOK(ecode4)) {
14901  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14902  }
14903  arg4 = (PLFLT)(val4);
14904  ecode5 = SWIG_AsVal_double(obj2, &val5);
14905  if (!SWIG_IsOK(ecode5)) {
14906  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14907  }
14908  arg5 = (PLFLT)(val5);
14909  ecode6 = SWIG_AsVal_double(obj3, &val6);
14910  if (!SWIG_IsOK(ecode6)) {
14911  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14912  }
14913  arg6 = (PLFLT)(val6);
14914  ecode7 = SWIG_AsVal_double(obj4, &val7);
14915  if (!SWIG_IsOK(ecode7)) {
14916  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14917  }
14918  arg7 = (PLFLT)(val7);
14919  ecode8 = SWIG_AsVal_double(obj5, &val8);
14920  if (!SWIG_IsOK(ecode8)) {
14921  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14922  }
14923  arg8 = (PLFLT)(val8);
14924  ecode9 = SWIG_AsVal_double(obj6, &val9);
14925  if (!SWIG_IsOK(ecode9)) {
14926  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14927  }
14928  arg9 = (PLFLT)(val9);
14929  ecode10 = SWIG_AsVal_double(obj7, &val10);
14930  if (!SWIG_IsOK(ecode10)) {
14931  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14932  }
14933  arg10 = (PLFLT)(val10);
14934  ecode11 = SWIG_AsVal_double(obj8, &val11);
14935  if (!SWIG_IsOK(ecode11)) {
14936  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14937  }
14938  arg11 = (PLFLT)(val11);
14939  if (obj9) {
14940  {
14941  // it must be a callable or None
14942  if ( obj9 == Py_None )
14943  {
14944  arg12 = NULL;
14945  }
14946  else
14947  {
14948  if ( !PyCallable_Check( (PyObject *) obj9 ) )
14949  {
14950  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14951  return NULL;
14952  }
14953  arg12 = marshal_pltr( obj9 );
14954  }
14955  }
14956  }
14957  if (obj10) {
14958  {
14959  if ( obj10 == Py_None )
14960  arg13 = NULL;
14961  else
14962  {
14963  arg13 = marshal_PLPointer( obj10, 1 );
14964  }
14965  }
14966  }
14967  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14968  resultobj = SWIG_Py_Void();
14969  {
14970  Py_CLEAR( tmp1 );
14971  free( arg1 );
14972  }
14973  {
14974  cleanup_pltr();
14975  }
14976  {
14978  }
14979  return resultobj;
14980 fail:
14981  {
14982  Py_CLEAR( tmp1 );
14983  free( arg1 );
14984  }
14985  {
14986  cleanup_pltr();
14987  }
14988  {
14990  }
14991  return NULL;
14992 }
14993 
14994 
14995 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996  PyObject *resultobj = 0;
14997 
14998  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
14999  plClearOpts();
15000  resultobj = SWIG_Py_Void();
15001  return resultobj;
15002 fail:
15003  return NULL;
15004 }
15005 
15006 
15007 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15008  PyObject *resultobj = 0;
15009 
15010  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
15011  plResetOpts();
15012  resultobj = SWIG_Py_Void();
15013  return resultobj;
15014 fail:
15015  return NULL;
15016 }
15017 
15018 
15019 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15020  PyObject *resultobj = 0;
15021  char *arg1 = (char *) 0 ;
15022  char *arg2 = (char *) 0 ;
15023  int res1 ;
15024  char *buf1 = 0 ;
15025  int alloc1 = 0 ;
15026  int res2 ;
15027  char *buf2 = 0 ;
15028  int alloc2 = 0 ;
15029  PyObject * obj0 = 0 ;
15030  PyObject * obj1 = 0 ;
15031 
15032  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
15033  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
15034  if (!SWIG_IsOK(res1)) {
15035  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15036  }
15037  arg1 = (char *)(buf1);
15038  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15039  if (!SWIG_IsOK(res2)) {
15040  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15041  }
15042  arg2 = (char *)(buf2);
15043  plSetUsage((char const *)arg1,(char const *)arg2);
15044  resultobj = SWIG_Py_Void();
15045  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15046  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15047  return resultobj;
15048 fail:
15049  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15050  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15051  return NULL;
15052 }
15053 
15054 
15055 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15056  PyObject *resultobj = 0;
15057 
15058  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
15059  plOptUsage();
15060  resultobj = SWIG_Py_Void();
15061  return resultobj;
15062 fail:
15063  return NULL;
15064 }
15065 
15066 
15067 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15068  PyObject *resultobj = 0;
15069  PLFLT **arg1 = (PLFLT **) 0 ;
15070  PLINT arg2 ;
15071  PLINT arg3 ;
15072  PLFLT *arg4 = (PLFLT *) 0 ;
15073  PLFLT *arg5 = (PLFLT *) 0 ;
15074  PyArrayObject *tmp1 = NULL ;
15075  PLFLT temp4 ;
15076  int res4 = SWIG_TMPOBJ ;
15077  PLFLT temp5 ;
15078  int res5 = SWIG_TMPOBJ ;
15079  PyObject * obj0 = 0 ;
15080 
15081  arg4 = &temp4;
15082  arg5 = &temp5;
15083  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
15084  {
15085  int i, size;
15086  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15087  if ( tmp1 == NULL )
15088  return NULL;
15089  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15090  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15091  size = arg3;
15092  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15093  for ( i = 0; i < arg2; i++ )
15094  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15095  }
15096  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15097  resultobj = SWIG_Py_Void();
15098  if (SWIG_IsTmpObj(res4)) {
15099  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15100  } else {
15101  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15102  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15103  }
15104  if (SWIG_IsTmpObj(res5)) {
15105  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15106  } else {
15107  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15108  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15109  }
15110  {
15111  Py_CLEAR( tmp1 );
15112  free( arg1 );
15113  }
15114  return resultobj;
15115 fail:
15116  {
15117  Py_CLEAR( tmp1 );
15118  free( arg1 );
15119  }
15120  return NULL;
15121 }
15122 
15123 
15124 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15125  PyObject *resultobj = 0;
15126  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15127  void *argp1 = 0 ;
15128  int res1 = 0 ;
15129  PyObject * obj0 = 0 ;
15130  PLINT result;
15131 
15132  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
15133  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15134  if (!SWIG_IsOK(res1)) {
15135  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15136  }
15137  arg1 = (PLGraphicsIn *)(argp1);
15138  result = (PLINT)plGetCursor(arg1);
15139  resultobj = SWIG_From_int((int)(result));
15140  return resultobj;
15141 fail:
15142  return NULL;
15143 }
15144 
15145 
15146 static PyMethodDef SwigMethods[] = {
15147  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
15148  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15149  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15150  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15151  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15152  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
15153  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15154  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
15155  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15156  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
15157  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15158  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
15159  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15160  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
15161  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15162  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
15163  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15164  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
15165  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15166  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
15167  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15168  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
15169  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15170  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
15171  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15172  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
15173  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15174  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
15175  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
15176  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
15177  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
15178  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
15179  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
15180  "Set format of numerical label for contours\n"
15181  "\n"
15182  "DESCRIPTION:\n"
15183  "\n"
15184  " Set format of numerical label for contours.\n"
15185  "\n"
15186  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15187  "\n"
15188  " This function is used example 9.\n"
15189  "\n"
15190  "\n"
15191  "\n"
15192  "SYNOPSIS:\n"
15193  "\n"
15194  "pl_setcontlabelformat(lexp, sigdig)\n"
15195  "\n"
15196  "ARGUMENTS:\n"
15197  "\n"
15198  " lexp (PLINT, input) : If the contour numerical label is greater\n"
15199  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15200  " format is used. Default value of lexp is 4.\n"
15201  "\n"
15202  " sigdig (PLINT, input) : Number of significant digits. Default\n"
15203  " value is 2.\n"
15204  "\n"
15205  ""},
15206  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
15207  "Set parameters of contour labelling other than format of numerical label\n"
15208  "\n"
15209  "DESCRIPTION:\n"
15210  "\n"
15211  " Set parameters of contour labelling other than those handled by\n"
15212  " pl_setcontlabelformat.\n"
15213  "\n"
15214  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15215  "\n"
15216  " This function is used in example 9.\n"
15217  "\n"
15218  "\n"
15219  "\n"
15220  "SYNOPSIS:\n"
15221  "\n"
15222  "pl_setcontlabelparam(offset, size, spacing, active)\n"
15223  "\n"
15224  "ARGUMENTS:\n"
15225  "\n"
15226  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15227  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15228  "\n"
15229  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15230  " Default value is 0.3.\n"
15231  "\n"
15232  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15233  " Default value is 0.1.\n"
15234  "\n"
15235  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15236  " contour labels on. Default is off (0).\n"
15237  "\n"
15238  ""},
15239  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
15240  "Advance the (sub-)page\n"
15241  "\n"
15242  "DESCRIPTION:\n"
15243  "\n"
15244  " Advances to the next subpage if sub=0, performing a page advance if\n"
15245  " there are no remaining subpages on the current page. If subpages\n"
15246  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15247  " PLplot switches to the specified subpage. Note that this allows you\n"
15248  " to overwrite a plot on the specified subpage; if this is not what you\n"
15249  " intended, use pleop followed by plbop to first advance the page. This\n"
15250  " routine is called automatically (with page=0) by plenv, but if plenv\n"
15251  " is not used, pladv must be called after initializing PLplot but before\n"
15252  " defining the viewport.\n"
15253  "\n"
15254  " Redacted form: pladv(page)\n"
15255  "\n"
15256  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15257  " 29, and 31.\n"
15258  "\n"
15259  "\n"
15260  "\n"
15261  "SYNOPSIS:\n"
15262  "\n"
15263  "pladv(page)\n"
15264  "\n"
15265  "ARGUMENTS:\n"
15266  "\n"
15267  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15268  " in the top left corner and increasing along the rows) to which to\n"
15269  " advance. Set to zero to advance to the next subpage (or to the\n"
15270  " next page if subpages are not being used).\n"
15271  "\n"
15272  ""},
15273  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
15274  "Draw a circular or elliptical arc\n"
15275  "\n"
15276  "DESCRIPTION:\n"
15277  "\n"
15278  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15279  " semiminor axis b, starting at angle1 and ending at angle2.\n"
15280  "\n"
15281  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15282  " fill)\n"
15283  "\n"
15284  "\n"
15285  " This function is used in examples 3 and 27.\n"
15286  "\n"
15287  "\n"
15288  "\n"
15289  "SYNOPSIS:\n"
15290  "\n"
15291  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15292  "\n"
15293  "ARGUMENTS:\n"
15294  "\n"
15295  " x (PLFLT, input) : X coordinate of arc center.\n"
15296  "\n"
15297  " y (PLFLT, input) : Y coordinate of arc center.\n"
15298  "\n"
15299  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15300  "\n"
15301  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15302  "\n"
15303  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15304  " semimajor axis.\n"
15305  "\n"
15306  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15307  " semimajor axis.\n"
15308  "\n"
15309  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15310  " X-axis.\n"
15311  "\n"
15312  " fill (PLBOOL, input) : Draw a filled arc.\n"
15313  "\n"
15314  ""},
15315  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
15316  "Draw a box with axes, etc. with arbitrary origin\n"
15317  "\n"
15318  "DESCRIPTION:\n"
15319  "\n"
15320  " Draws a box around the currently defined viewport with arbitrary\n"
15321  " world-coordinate origin specified by x0 and y0 and labels it with\n"
15322  " world coordinate values appropriate to the window. Thus plaxes should\n"
15323  " only be called after defining both viewport and window. The ascii\n"
15324  " character strings xopt and yopt specify how the box should be drawn as\n"
15325  " described below. If ticks and/or subticks are to be drawn for a\n"
15326  " particular axis, the tick intervals and number of subintervals may be\n"
15327  " specified explicitly, or they may be defaulted by setting the\n"
15328  " appropriate arguments to zero.\n"
15329  "\n"
15330  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15331  " ytick, nysub)\n"
15332  " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
15333  " yopt)\n"
15334  "\n"
15335  "\n"
15336  " This function is not used in any examples.\n"
15337  "\n"
15338  "\n"
15339  "\n"
15340  "SYNOPSIS:\n"
15341  "\n"
15342  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15343  "\n"
15344  "ARGUMENTS:\n"
15345  "\n"
15346  " x0 (PLFLT, input) : World X coordinate of origin.\n"
15347  "\n"
15348  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15349  "\n"
15350  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15351  " options for the x axis. The string can include any combination of\n"
15352  " the following letters (upper or lower case) in any order: a: Draws\n"
15353  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15354  " (x=0).\n"
15355  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15356  " c: Draws top (X) or right (Y) edge of frame.\n"
15357  " d: Plot labels as date / time. Values are assumed to be\n"
15358  " seconds since the epoch (as used by gmtime).\n"
15359  " f: Always use fixed point numeric labels.\n"
15360  " g: Draws a grid at the major tick interval.\n"
15361  " h: Draws a grid at the minor tick interval.\n"
15362  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15363  " inwards.\n"
15364  " l: Labels axis logarithmically. This only affects the labels,\n"
15365  " not the data, and so it is necessary to compute the logarithms\n"
15366  " of data points before passing them to any of the drawing\n"
15367  " routines.\n"
15368  " m: Writes numeric labels at major tick intervals in the\n"
15369  " unconventional location (above box for X, right of box for Y).\n"
15370  " n: Writes numeric labels at major tick intervals in the\n"
15371  " conventional location (below box for X, left of box for Y).\n"
15372  " o: Use custom labelling function to generate axis label text.\n"
15373  " The custom labelling function can be defined with the\n"
15374  " plslabelfunc command.\n"
15375  " s: Enables subticks between major ticks, only valid if t is\n"
15376  " also specified.\n"
15377  " t: Draws major ticks.\n"
15378  " u: Exactly like \"b\" except don't draw edge line.\n"
15379  " w: Exactly like \"c\" except don't draw edge line.\n"
15380  " x: Exactly like \"t\" (including the side effect of the\n"
15381  " numerical labels for the major ticks) except exclude drawing\n"
15382  " the major and minor tick marks.\n"
15383  "\n"
15384  "\n"
15385  " xtick (PLFLT, input) : World coordinate interval between major\n"
15386  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15387  " generates a suitable tick interval.\n"
15388  "\n"
15389  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15390  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15391  " generates a suitable minor tick interval.\n"
15392  "\n"
15393  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15394  " options for the y axis. The string can include any combination of\n"
15395  " the letters defined above for xopt, and in addition may contain:\n"
15396  " v: Write numeric labels for the y axis parallel to the base of the\n"
15397  " graph, rather than parallel to the axis.\n"
15398  "\n"
15399  "\n"
15400  " ytick (PLFLT, input) : World coordinate interval between major\n"
15401  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15402  " generates a suitable tick interval.\n"
15403  "\n"
15404  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15405  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15406  " generates a suitable minor tick interval.\n"
15407  "\n"
15408  ""},
15409  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
15410  "Plot a histogram from binned data\n"
15411  "\n"
15412  "DESCRIPTION:\n"
15413  "\n"
15414  " Plots a histogram consisting of nbin bins. The value associated with\n"
15415  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15416  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15417  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15418  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15419  " placed midway between the values in the x vector. Also see plhist for\n"
15420  " drawing histograms from unbinned data.\n"
15421  "\n"
15422  " Redacted form: General: plbin(x, y, opt)\n"
15423  " Perl/PDL: plbin(nbin, x, y, opt)\n"
15424  " Python: plbin(nbin, x, y, opt)\n"
15425  "\n"
15426  "\n"
15427  " This function is not used in any examples.\n"
15428  "\n"
15429  "\n"
15430  "\n"
15431  "SYNOPSIS:\n"
15432  "\n"
15433  "plbin(nbin, x, y, opt)\n"
15434  "\n"
15435  "ARGUMENTS:\n"
15436  "\n"
15437  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15438  " and y vectors.)\n"
15439  "\n"
15440  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15441  " with bins. These must form a strictly increasing sequence.\n"
15442  "\n"
15443  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15444  " proportional to the number of points in each bin. This is a PLFLT\n"
15445  " (instead of PLINT) vector so as to allow histograms of\n"
15446  " probabilities, etc.\n"
15447  "\n"
15448  " opt (PLINT, input) : Is a combination of several flags:\n"
15449  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15450  " outer bins are expanded to fill up the entire x-axis and bins of\n"
15451  " zero height are simply drawn.\n"
15452  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15453  " between the x values. If the values in x are equally spaced,\n"
15454  " the values are the center values of the bins.\n"
15455  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15456  " size as the ones inside.\n"
15457  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15458  " (there is a gap for such bins).\n"
15459  "\n"
15460  ""},
15461  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15462  "Calculate broken-down time from continuous time for the current stream\n"
15463  "\n"
15464  "DESCRIPTION:\n"
15465  "\n"
15466  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15467  " continuous time, ctime for the current stream. This function is the\n"
15468  " inverse of plctime.\n"
15469  "\n"
15470  " The PLplot definition of broken-down time is a calendar time that\n"
15471  " completely ignores all time zone offsets, i.e., it is the user's\n"
15472  " responsibility to apply those offsets (if so desired) before using the\n"
15473  " PLplot time API. By default broken-down time is defined using the\n"
15474  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15475  " continuous time is defined as the number of seconds since the Unix\n"
15476  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15477  " broken-down and continuous time are possible, see plconfigtime.\n"
15478  "\n"
15479  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15480  " ctime)\n"
15481  " Perl/PDL: Not available?\n"
15482  "\n"
15483  "\n"
15484  " This function is used in example 29.\n"
15485  "\n"
15486  "\n"
15487  "\n"
15488  "SYNOPSIS:\n"
15489  "\n"
15490  "plbtime(year, month, day, hour, min, sec, ctime)\n"
15491  "\n"
15492  "ARGUMENTS:\n"
15493  "\n"
15494  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15495  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15496  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15497  " BCE, etc.)\n"
15498  "\n"
15499  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15500  " the year in the range from 0 (January) to 11 (December).\n"
15501  "\n"
15502  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15503  " month in the range from 1 to 31.\n"
15504  "\n"
15505  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15506  " day in the range from 0 to 23.\n"
15507  "\n"
15508  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15509  " hour in the range from 0 to 59\n"
15510  "\n"
15511  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15512  " minute in range from 0. to 60.\n"
15513  "\n"
15514  " ctime (PLFLT, input) : Continous time from which the broken-down\n"
15515  " time is calculated.\n"
15516  "\n"
15517  ""},
15518  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15519  "Begin a new page\n"
15520  "\n"
15521  "DESCRIPTION:\n"
15522  "\n"
15523  " Begins a new page. For a file driver, the output file is opened if\n"
15524  " necessary. Advancing the page via pleop and plbop is useful when a\n"
15525  " page break is desired at a particular point when plotting to subpages.\n"
15526  " Another use for pleop and plbop is when plotting pages to different\n"
15527  " files, since you can manually set the file name by calling plsfnam\n"
15528  " after the call to pleop. (In fact some drivers may only support a\n"
15529  " single page per file, making this a necessity.) One way to handle\n"
15530  " this case automatically is to page advance via pladv, but enable\n"
15531  " familying (see plsfam) with a small limit on the file size so that a\n"
15532  " new family member file will be created on each page break.\n"
15533  "\n"
15534  " Redacted form: plbop()\n"
15535  "\n"
15536  " This function is used in examples 2 and 20.\n"
15537  "\n"
15538  "\n"
15539  "\n"
15540  "SYNOPSIS:\n"
15541  "\n"
15542  "plbop()\n"
15543  "\n"
15544  ""},
15545  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15546  "Draw a box with axes, etc\n"
15547  "\n"
15548  "DESCRIPTION:\n"
15549  "\n"
15550  " Draws a box around the currently defined viewport, and labels it with\n"
15551  " world coordinate values appropriate to the window. Thus plbox should\n"
15552  " only be called after defining both viewport and window. The ascii\n"
15553  " character strings xopt and yopt specify how the box should be drawn as\n"
15554  " described below. If ticks and/or subticks are to be drawn for a\n"
15555  " particular axis, the tick intervals and number of subintervals may be\n"
15556  " specified explicitly, or they may be defaulted by setting the\n"
15557  " appropriate arguments to zero.\n"
15558  "\n"
15559  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15560  " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15561  "\n"
15562  "\n"
15563  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15564  " and 29.\n"
15565  "\n"
15566  "\n"
15567  "\n"
15568  "SYNOPSIS:\n"
15569  "\n"
15570  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15571  "\n"
15572  "ARGUMENTS:\n"
15573  "\n"
15574  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15575  " options for the x axis. The string can include any combination of\n"
15576  " the following letters (upper or lower case) in any order: a: Draws\n"
15577  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15578  " (x=0).\n"
15579  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15580  " c: Draws top (X) or right (Y) edge of frame.\n"
15581  " d: Plot labels as date / time. Values are assumed to be\n"
15582  " seconds since the epoch (as used by gmtime).\n"
15583  " f: Always use fixed point numeric labels.\n"
15584  " g: Draws a grid at the major tick interval.\n"
15585  " h: Draws a grid at the minor tick interval.\n"
15586  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15587  " inwards.\n"
15588  " l: Labels axis logarithmically. This only affects the labels,\n"
15589  " not the data, and so it is necessary to compute the logarithms\n"
15590  " of data points before passing them to any of the drawing\n"
15591  " routines.\n"
15592  " m: Writes numeric labels at major tick intervals in the\n"
15593  " unconventional location (above box for X, right of box for Y).\n"
15594  " n: Writes numeric labels at major tick intervals in the\n"
15595  " conventional location (below box for X, left of box for Y).\n"
15596  " o: Use custom labelling function to generate axis label text.\n"
15597  " The custom labelling function can be defined with the\n"
15598  " plslabelfunc command.\n"
15599  " s: Enables subticks between major ticks, only valid if t is\n"
15600  " also specified.\n"
15601  " t: Draws major ticks.\n"
15602  " u: Exactly like \"b\" except don't draw edge line.\n"
15603  " w: Exactly like \"c\" except don't draw edge line.\n"
15604  " x: Exactly like \"t\" (including the side effect of the\n"
15605  " numerical labels for the major ticks) except exclude drawing\n"
15606  " the major and minor tick marks.\n"
15607  "\n"
15608  "\n"
15609  " xtick (PLFLT, input) : World coordinate interval between major\n"
15610  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15611  " generates a suitable tick interval.\n"
15612  "\n"
15613  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15614  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15615  " generates a suitable minor tick interval.\n"
15616  "\n"
15617  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15618  " options for the y axis. The string can include any combination of\n"
15619  " the letters defined above for xopt, and in addition may contain:\n"
15620  " v: Write numeric labels for the y axis parallel to the base of the\n"
15621  " graph, rather than parallel to the axis.\n"
15622  "\n"
15623  "\n"
15624  " ytick (PLFLT, input) : World coordinate interval between major\n"
15625  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15626  " generates a suitable tick interval.\n"
15627  "\n"
15628  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15629  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15630  " generates a suitable minor tick interval.\n"
15631  "\n"
15632  ""},
15633  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15634  "Draw a box with axes, etc, in 3-d\n"
15635  "\n"
15636  "DESCRIPTION:\n"
15637  "\n"
15638  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15639  " plot. For a more complete description of three-dimensional plotting\n"
15640  " see the PLplot documentation.\n"
15641  "\n"
15642  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15643  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15644  " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15645  " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15646  "\n"
15647  "\n"
15648  " This function is used in examples 8, 11, 18, and 21.\n"
15649  "\n"
15650  "\n"
15651  "\n"
15652  "SYNOPSIS:\n"
15653  "\n"
15654  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15655  "\n"
15656  "ARGUMENTS:\n"
15657  "\n"
15658  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15659  " options for the x axis. The string can include any combination of\n"
15660  " the following letters (upper or lower case) in any order: b: Draws\n"
15661  " axis at base, at height z=\n"
15662  " zmin where zmin is defined by call to plw3d. This character must be\n"
15663  " specified in order to use any of the other options.\n"
15664  " d: Plot labels as date / time. Values are assumed to be\n"
15665  " seconds since the epoch (as used by gmtime).\n"
15666  " f: Always use fixed point numeric labels.\n"
15667  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15668  " than upwards.\n"
15669  " l: Labels axis logarithmically. This only affects the labels,\n"
15670  " not the data, and so it is necessary to compute the logarithms\n"
15671  " of data points before passing them to any of the drawing\n"
15672  " routines.\n"
15673  " n: Writes numeric labels at major tick intervals.\n"
15674  " o: Use custom labelling function to generate axis label text.\n"
15675  " The custom labelling function can be defined with the\n"
15676  " plslabelfunc command.\n"
15677  " s: Enables subticks between major ticks, only valid if t is\n"
15678  " also specified.\n"
15679  " t: Draws major ticks.\n"
15680  " u: If this is specified, the text label for the axis is\n"
15681  " written under the axis.\n"
15682  "\n"
15683  "\n"
15684  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15685  " the text label for the x axis. It is only drawn if u is in the\n"
15686  " xopt string.\n"
15687  "\n"
15688  " xtick (PLFLT, input) : World coordinate interval between major\n"
15689  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15690  " generates a suitable tick interval.\n"
15691  "\n"
15692  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15693  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15694  " generates a suitable minor tick interval.\n"
15695  "\n"
15696  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15697  " options for the y axis. The string is interpreted in the same way\n"
15698  " as xopt.\n"
15699  "\n"
15700  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15701  " the text label for the y axis. It is only drawn if u is in the\n"
15702  " yopt string.\n"
15703  "\n"
15704  " ytick (PLFLT, input) : World coordinate interval between major\n"
15705  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15706  " generates a suitable tick interval.\n"
15707  "\n"
15708  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15709  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15710  " generates a suitable minor tick interval.\n"
15711  "\n"
15712  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15713  " options for the z axis. The string can include any combination of\n"
15714  " the following letters (upper or lower case) in any order: b: Draws\n"
15715  " z axis to the left of the surface plot.\n"
15716  " c: Draws z axis to the right of the surface plot.\n"
15717  " d: Draws grid lines parallel to the x-y plane behind the\n"
15718  " figure. These lines are not drawn until after plot3d or\n"
15719  " plmesh are called because of the need for hidden line removal.\n"
15720  " e: Plot labels as date / time. Values are assumed to be\n"
15721  " seconds since the epoch (as used by gmtime). Note this\n"
15722  " suboption is interpreted the same as the d suboption for xopt\n"
15723  " and yopt, but it has to be identified as e for zopt since d\n"
15724  " has already been used for the different purpose above.\n"
15725  " f: Always use fixed point numeric labels.\n"
15726  " i: Inverts tick marks, so they are drawn away from the center.\n"
15727  " l: Labels axis logarithmically. This only affects the labels,\n"
15728  " not the data, and so it is necessary to compute the logarithms\n"
15729  " of data points before passing them to any of the drawing\n"
15730  " routines.\n"
15731  " m: Writes numeric labels at major tick intervals on the\n"
15732  " right-hand z axis.\n"
15733  " n: Writes numeric labels at major tick intervals on the\n"
15734  " left-hand z axis.\n"
15735  " o: Use custom labelling function to generate axis label text.\n"
15736  " The custom labelling function can be defined with the\n"
15737  " plslabelfunc command.\n"
15738  " s: Enables subticks between major ticks, only valid if t is\n"
15739  " also specified.\n"
15740  " t: Draws major ticks.\n"
15741  " u: If this is specified, the text label is written beside the\n"
15742  " left-hand axis.\n"
15743  " v: If this is specified, the text label is written beside the\n"
15744  " right-hand axis.\n"
15745  "\n"
15746  "\n"
15747  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15748  " the text label for the z axis. It is only drawn if u or v are in\n"
15749  " the zopt string.\n"
15750  "\n"
15751  " ztick (PLFLT, input) : World coordinate interval between major\n"
15752  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15753  " generates a suitable tick interval.\n"
15754  "\n"
15755  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15756  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15757  " generates a suitable minor tick interval.\n"
15758  "\n"
15759  ""},
15760  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15761  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15762  "\n"
15763  "DESCRIPTION:\n"
15764  "\n"
15765  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15766  " from relative device coordinates, rx and ry.\n"
15767  "\n"
15768  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15769  " Perl/PDL: Not available?\n"
15770  "\n"
15771  "\n"
15772  " This function is used in example 31.\n"
15773  "\n"
15774  "\n"
15775  "\n"
15776  "SYNOPSIS:\n"
15777  "\n"
15778  "plcalc_world(rx, ry, wx, wy, window)\n"
15779  "\n"
15780  "ARGUMENTS:\n"
15781  "\n"
15782  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15783  " the x coordinate.\n"
15784  "\n"
15785  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15786  " the y coordinate.\n"
15787  "\n"
15788  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15789  " coordinate corresponding to the relative device coordinates rx and\n"
15790  " ry.\n"
15791  "\n"
15792  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15793  " coordinate corresponding to the relative device coordinates rx and\n"
15794  " ry.\n"
15795  "\n"
15796  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15797  " defined window index that corresponds to the input relative device\n"
15798  " coordinates (and the returned world coordinates). To give some\n"
15799  " background on the window index, for each page the initial window\n"
15800  " index is set to zero, and each time plwind is called within the\n"
15801  " page, world and device coordinates are stored for the window and\n"
15802  " the window index is incremented. Thus, for a simple page layout\n"
15803  " with non-overlapping viewports and one window per viewport, window\n"
15804  " corresponds to the viewport index (in the order which the\n"
15805  " viewport/windows were created) of the only viewport/window\n"
15806  " corresponding to rx and ry. However, for more complicated layouts\n"
15807  " with potentially overlapping viewports and possibly more than one\n"
15808  " window (set of world coordinates) per viewport, window and the\n"
15809  " corresponding output world coordinates corresponds to the last\n"
15810  " window created that fulfills the criterion that the relative\n"
15811  " device coordinates are inside it. Finally, in all cases where the\n"
15812  " input relative device coordinates are not inside any\n"
15813  " viewport/window, then the returned value of the last defined\n"
15814  " window index is set to -1.\n"
15815  "\n"
15816  ""},
15817  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15818  "Clear current (sub)page\n"
15819  "\n"
15820  "DESCRIPTION:\n"
15821  "\n"
15822  " Clears the current page, effectively erasing everything that have been\n"
15823  " drawn. This command only works with interactive drivers; if the\n"
15824  " driver does not support this, the page is filled with the background\n"
15825  " color in use. If the current page is divided into subpages, only the\n"
15826  " current subpage is erased. The nth subpage can be selected with\n"
15827  " pladv(n).\n"
15828  "\n"
15829  " Redacted form: General: plclear()\n"
15830  " Perl/PDL: Not available?\n"
15831  "\n"
15832  "\n"
15833  " This function is not used in any examples.\n"
15834  "\n"
15835  "\n"
15836  "\n"
15837  "SYNOPSIS:\n"
15838  "\n"
15839  "plclear()\n"
15840  "\n"
15841  ""},
15842  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15843  "Set color, cmap0\n"
15844  "\n"
15845  "DESCRIPTION:\n"
15846  "\n"
15847  " Sets the color index for cmap0 (see the PLplot documentation).\n"
15848  "\n"
15849  " Redacted form: plcol0(icol0)\n"
15850  "\n"
15851  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15852  "\n"
15853  "\n"
15854  "\n"
15855  "SYNOPSIS:\n"
15856  "\n"
15857  "plcol0(icol0)\n"
15858  "\n"
15859  "ARGUMENTS:\n"
15860  "\n"
15861  " icol0 (PLINT, input) : Integer representing the color. The\n"
15862  " defaults at present are (these may change):\n"
15863  " 0 black (default background)\n"
15864  " 1 red (default foreground)\n"
15865  " 2 yellow\n"
15866  " 3 green\n"
15867  " 4 aquamarine\n"
15868  " 5 pink\n"
15869  " 6 wheat\n"
15870  " 7 grey\n"
15871  " 8 brown\n"
15872  " 9 blue\n"
15873  " 10 BlueViolet\n"
15874  " 11 cyan\n"
15875  " 12 turquoise\n"
15876  " 13 magenta\n"
15877  " 14 salmon\n"
15878  " 15 white\n"
15879  "\n"
15880  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15881  " change an individual color in the cmap0 color palette.\n"
15882  "\n"
15883  ""},
15884  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15885  "Set color, cmap1\n"
15886  "\n"
15887  "DESCRIPTION:\n"
15888  "\n"
15889  " Sets the color for cmap1 (see the PLplot documentation).\n"
15890  "\n"
15891  " Redacted form: plcol1(col1)\n"
15892  "\n"
15893  " This function is used in examples 12 and 21.\n"
15894  "\n"
15895  "\n"
15896  "\n"
15897  "SYNOPSIS:\n"
15898  "\n"
15899  "plcol1(col1)\n"
15900  "\n"
15901  "ARGUMENTS:\n"
15902  "\n"
15903  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15904  " is mapped to color using the continuous cmap1 palette which by\n"
15905  " default ranges from blue to the background color to red. The\n"
15906  " cmap1 palette can also be straightforwardly changed by the user\n"
15907  " with plscmap1 or plscmap1l.\n"
15908  "\n"
15909  ""},
15910  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
15911  "Configure the transformation between continuous and broken-down time for the current stream\n"
15912  "\n"
15913  "DESCRIPTION:\n"
15914  "\n"
15915  " Configure the transformation between continuous and broken-down time\n"
15916  " for the current stream. This transformation is used by both plbtime\n"
15917  " and plctime.\n"
15918  "\n"
15919  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15920  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15921  " Perl/PDL: Not available?\n"
15922  "\n"
15923  "\n"
15924  " This function is used in example 29.\n"
15925  "\n"
15926  "\n"
15927  "\n"
15928  "SYNOPSIS:\n"
15929  "\n"
15930  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15931  "\n"
15932  "ARGUMENTS:\n"
15933  "\n"
15934  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15935  " As a special case, if\n"
15936  " scale is 0., then all other arguments are ignored, and the result (the\n"
15937  " default used by PLplot) is the equivalent of a call to\n"
15938  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15939  " That is, for this special case broken-down time is calculated with\n"
15940  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15941  " and the continuous time is defined as the number of seconds since\n"
15942  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15943  "\n"
15944  " offset1 (PLFLT, input) : If\n"
15945  " ifbtime_offset is true, the parameters\n"
15946  " offset1 and\n"
15947  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15948  " (with units in days) specify the epoch of the continuous time\n"
15949  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15950  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15951  " are used to specify the origin to allow users (by specifying\n"
15952  " offset1 as an integer that can be exactly represented by a\n"
15953  " floating-point variable and specifying\n"
15954  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15955  " the numerical errors of the continuous time representation.\n"
15956  "\n"
15957  " offset2 (PLFLT, input) : See documentation of\n"
15958  " offset1.\n"
15959  "\n"
15960  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15961  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15962  " calendar is used for broken-down time rather than the proleptic\n"
15963  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15964  " have been historically used to define UTC are inserted into the\n"
15965  " broken-down time. Other possibilities for additional control bits\n"
15966  " for ccontrol exist such as making the historical time corrections\n"
15967  " in the broken-down time corresponding to ET (ephemeris time) or\n"
15968  " making the (slightly non-constant) corrections from international\n"
15969  " atomic time (TAI) to what astronomers define as terrestrial time\n"
15970  " (TT). But those additional possibilities have not been\n"
15971  " implemented yet in the qsastime library (one of the PLplot utility\n"
15972  " libraries).\n"
15973  "\n"
15974  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15975  " epoch of the continuous time scale is specified by the user. If\n"
15976  " ifbtime_offset is false, then\n"
15977  " offset1 and\n"
15978  " offset2 are used to specify the epoch, and the following broken-down\n"
15979  " time parameters are completely ignored. If\n"
15980  " ifbtime_offset is true, then\n"
15981  " offset1 and\n"
15982  " offset2 are completely ignored, and the following broken-down time\n"
15983  " parameters are used to specify the epoch.\n"
15984  "\n"
15985  " year (PLINT, input) : Year of epoch.\n"
15986  "\n"
15987  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15988  " 11 (December).\n"
15989  "\n"
15990  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15991  "\n"
15992  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15993  "\n"
15994  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15995  "\n"
15996  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15997  "\n"
15998  ""},
15999  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
16000  "Contour plot\n"
16001  "\n"
16002  "DESCRIPTION:\n"
16003  "\n"
16004  " Draws a contour plot of the data in f[\n"
16005  " nx][\n"
16006  " ny], using the nlevel contour levels specified by clevel. Only the\n"
16007  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16008  " where all these index ranges are interpreted as one-based for\n"
16009  " historical reasons. A transformation routine pointed to by pltr with\n"
16010  " a generic pointer pltr_data for additional data required by the\n"
16011  " transformation routine is used to map indices within the matrix to the\n"
16012  " world coordinates.\n"
16013  "\n"
16014  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16015  " where (see above discussion) the pltr, pltr_data callback arguments\n"
16016  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16017  " vectors; or xg and yg matrices.\n"
16018  "\n"
16019  " This function is used in examples 9, 14, 16, and 22.\n"
16020  "\n"
16021  "\n"
16022  "\n"
16023  "SYNOPSIS:\n"
16024  "\n"
16025  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16026  "\n"
16027  "ARGUMENTS:\n"
16028  "\n"
16029  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16030  "\n"
16031  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16032  "\n"
16033  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16034  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16035  " zero-based for historical backwards-compatibility reasons.\n"
16036  "\n"
16037  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16038  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16039  " zero-based for historical backwards-compatibility reasons.\n"
16040  "\n"
16041  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16042  " which to draw contours.\n"
16043  "\n"
16044  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16045  "\n"
16046  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16047  " defines the transformation between the zero-based indices of the\n"
16048  " matrix f and the world coordinates.For the C case, transformation\n"
16049  " functions are provided in the PLplot library: pltr0 for the\n"
16050  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16051  " respectively defined by vectors and matrices. In addition, C\n"
16052  " callback routines for the transformation can be supplied by the\n"
16053  " user such as the mypltr function in examples/c/x09c.c which\n"
16054  " provides a general linear transformation between index coordinates\n"
16055  " and world coordinates.For languages other than C you should\n"
16056  " consult the PLplot documentation for the details concerning how\n"
16057  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16058  " general, a particular pattern of callback-associated arguments\n"
16059  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16060  " yg matrices are respectively interfaced to a linear-transformation\n"
16061  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16062  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16063  " the PLplot documentation) support native language callbacks for\n"
16064  " handling index to world-coordinate transformations. Examples of\n"
16065  " these various approaches are given in examples/<language>x09*,\n"
16066  " examples/<language>x16*, examples/<language>x20*,\n"
16067  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16068  " supported languages.\n"
16069  "\n"
16070  " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
16071  " pass information to pltr0, pltr1, pltr2, or whatever callback\n"
16072  " routine that is externally supplied.\n"
16073  "\n"
16074  ""},
16075  { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
16076  "Calculate continuous time from broken-down time for the current stream\n"
16077  "\n"
16078  "DESCRIPTION:\n"
16079  "\n"
16080  " Calculate continuous time, ctime, from broken-down time for the\n"
16081  " current stream. The broken-down\n"
16082  " time is specified by the following parameters: year, month, day, hour,\n"
16083  " min, and sec. This function is the inverse of plbtime.\n"
16084  "\n"
16085  " The PLplot definition of broken-down time is a calendar time that\n"
16086  " completely ignores all time zone offsets, i.e., it is the user's\n"
16087  " responsibility to apply those offsets (if so desired) before using the\n"
16088  " PLplot time API. By default broken-down time is defined using the\n"
16089  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16090  " continuous time is defined as the number of seconds since the Unix\n"
16091  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16092  " broken-down and continuous time are possible, see plconfigtime which\n"
16093  " specifies that transformation for the current stream.\n"
16094  "\n"
16095  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16096  " ctime)\n"
16097  " Perl/PDL: Not available?\n"
16098  "\n"
16099  "\n"
16100  " This function is used in example 29.\n"
16101  "\n"
16102  "\n"
16103  "\n"
16104  "SYNOPSIS:\n"
16105  "\n"
16106  "plctime(year, month, day, hour, min, sec, ctime)\n"
16107  "\n"
16108  "ARGUMENTS:\n"
16109  "\n"
16110  " year (PLINT, input) : Input year.\n"
16111  "\n"
16112  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16113  " (December).\n"
16114  "\n"
16115  " day (PLINT, input) : Input day in range from 1 to 31.\n"
16116  "\n"
16117  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16118  "\n"
16119  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16120  "\n"
16121  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16122  "\n"
16123  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continous\n"
16124  " time calculated from the broken-down time specified by the\n"
16125  " previous parameters.\n"
16126  "\n"
16127  ""},
16128  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
16129  "Copy state parameters from the reference stream to the current stream\n"
16130  "\n"
16131  "DESCRIPTION:\n"
16132  "\n"
16133  " Copies state parameters from the reference stream to the current\n"
16134  " stream. Tell driver interface to map device coordinates unless flags\n"
16135  " == 1.\n"
16136  "\n"
16137  " This function is used for making save files of selected plots (e.g.\n"
16138  " from the TK driver). After initializing, you can get a copy of the\n"
16139  " current plot to the specified device by switching to this stream and\n"
16140  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16141  " appropriate. The plot buffer must have previously been enabled (done\n"
16142  " automatically by some display drivers, such as X).\n"
16143  "\n"
16144  " Redacted form: plcpstrm(iplsr, flags)\n"
16145  "\n"
16146  " This function is used in example 1,20.\n"
16147  "\n"
16148  "\n"
16149  "\n"
16150  "SYNOPSIS:\n"
16151  "\n"
16152  "plcpstrm(iplsr, flags)\n"
16153  "\n"
16154  "ARGUMENTS:\n"
16155  "\n"
16156  " iplsr (PLINT, input) : Number of reference stream.\n"
16157  "\n"
16158  " flags (PLBOOL, input) : If flags is set to true the device\n"
16159  " coordinates are not copied from the reference to current stream.\n"
16160  "\n"
16161  ""},
16162  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
16163  "End plotting session\n"
16164  "\n"
16165  "DESCRIPTION:\n"
16166  "\n"
16167  " Ends a plotting session, tidies up all the output files, switches\n"
16168  " interactive devices back into text mode and frees up any memory that\n"
16169  " was allocated. Must be called before end of program.\n"
16170  "\n"
16171  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16172  " wait state after a call to plend or other functions which trigger the\n"
16173  " end of a plot page. To avoid this, use the plspause function.\n"
16174  "\n"
16175  " Redacted form: plend()\n"
16176  "\n"
16177  " This function is used in all of the examples.\n"
16178  "\n"
16179  "\n"
16180  "\n"
16181  "SYNOPSIS:\n"
16182  "\n"
16183  "plend()\n"
16184  "\n"
16185  ""},
16186  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
16187  "End plotting session for current stream\n"
16188  "\n"
16189  "DESCRIPTION:\n"
16190  "\n"
16191  " Ends a plotting session for the current output stream only. See\n"
16192  " plsstrm for more info.\n"
16193  "\n"
16194  " Redacted form: plend1()\n"
16195  "\n"
16196  " This function is used in examples 1 and 20.\n"
16197  "\n"
16198  "\n"
16199  "\n"
16200  "SYNOPSIS:\n"
16201  "\n"
16202  "plend1()\n"
16203  "\n"
16204  ""},
16205  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
16206  "Set up standard window and draw box\n"
16207  "\n"
16208  "DESCRIPTION:\n"
16209  "\n"
16210  " Sets up plotter environment for simple graphs by calling pladv and\n"
16211  " setting up viewport and window to sensible default values. plenv\n"
16212  " leaves a standard margin (left-hand margin of eight character heights,\n"
16213  " and a margin around the other three sides of five character heights)\n"
16214  " around most graphs for axis labels and a title. When these defaults\n"
16215  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16216  " plvasp for setting up the viewport, plwind for defining the window,\n"
16217  " and plbox for drawing the box.\n"
16218  "\n"
16219  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16220  "\n"
16221  " This function is used in example 1,3,9,13,14,19-22,29.\n"
16222  "\n"
16223  "\n"
16224  "\n"
16225  "SYNOPSIS:\n"
16226  "\n"
16227  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16228  "\n"
16229  "ARGUMENTS:\n"
16230  "\n"
16231  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16232  " world coordinates).\n"
16233  "\n"
16234  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16235  " world coordinates).\n"
16236  "\n"
16237  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16238  " coordinates).\n"
16239  "\n"
16240  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16241  " coordinates).\n"
16242  "\n"
16243  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16244  " scales will not be set, the user must set up the scale before\n"
16245  " calling plenv using plsvpa, plvasp or other.\n"
16246  " 0: the x and y axes are scaled independently to use as much of\n"
16247  " the screen as possible.\n"
16248  " 1: the scales of the x and y axes are made equal.\n"
16249  " 2: the axis of the x and y axes are made equal, and the plot\n"
16250  " box will be square.\n"
16251  "\n"
16252  "\n"
16253  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16254  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16255  " -1: draw box only.\n"
16256  " 0: draw box, ticks, and numeric tick labels.\n"
16257  " 1: also draw coordinate axes at x=0 and y=0.\n"
16258  " 2: also draw a grid at major tick positions in both\n"
16259  " coordinates.\n"
16260  " 3: also draw a grid at minor tick positions in both\n"
16261  " coordinates.\n"
16262  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16263  " have to be converted to logarithms separately.)\n"
16264  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16265  " have to be converted to logarithms separately.)\n"
16266  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16267  " have to be converted to logarithms separately.)\n"
16268  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16269  " have to be converted to logarithms separately.)\n"
16270  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16271  " have to be converted to logarithms separately.)\n"
16272  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16273  " have to be converted to logarithms separately.)\n"
16274  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16275  " have to be converted to logarithms separately.)\n"
16276  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16277  " have to be converted to logarithms separately.)\n"
16278  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16279  " and y data have to be converted to logarithms separately.)\n"
16280  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16281  " and y data have to be converted to logarithms separately.)\n"
16282  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16283  " and y data have to be converted to logarithms separately.)\n"
16284  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16285  " and y data have to be converted to logarithms separately.)\n"
16286  " 40: same as 0 except date / time x labels.\n"
16287  " 41: same as 1 except date / time x labels.\n"
16288  " 42: same as 2 except date / time x labels.\n"
16289  " 43: same as 3 except date / time x labels.\n"
16290  " 50: same as 0 except date / time y labels.\n"
16291  " 51: same as 1 except date / time y labels.\n"
16292  " 52: same as 2 except date / time y labels.\n"
16293  " 53: same as 3 except date / time y labels.\n"
16294  " 60: same as 0 except date / time x and y labels.\n"
16295  " 61: same as 1 except date / time x and y labels.\n"
16296  " 62: same as 2 except date / time x and y labels.\n"
16297  " 63: same as 3 except date / time x and y labels.\n"
16298  " 70: same as 0 except custom x and y labels.\n"
16299  " 71: same as 1 except custom x and y labels.\n"
16300  " 72: same as 2 except custom x and y labels.\n"
16301  " 73: same as 3 except custom x and y labels.\n"
16302  "\n"
16303  ""},
16304  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
16305  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16306  "\n"
16307  "DESCRIPTION:\n"
16308  "\n"
16309  " Sets up plotter environment for simple graphs by calling pladv and\n"
16310  " setting up viewport and window to sensible default values. plenv0\n"
16311  " leaves a standard margin (left-hand margin of eight character heights,\n"
16312  " and a margin around the other three sides of five character heights)\n"
16313  " around most graphs for axis labels and a title. When these defaults\n"
16314  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16315  " plvasp for setting up the viewport, plwind for defining the window,\n"
16316  " and plbox for drawing the box.\n"
16317  "\n"
16318  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16319  "\n"
16320  " This function is used in example 21.\n"
16321  "\n"
16322  "\n"
16323  "\n"
16324  "SYNOPSIS:\n"
16325  "\n"
16326  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16327  "\n"
16328  "ARGUMENTS:\n"
16329  "\n"
16330  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16331  " world coordinates).\n"
16332  "\n"
16333  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16334  " world coordinates).\n"
16335  "\n"
16336  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16337  " coordinates).\n"
16338  "\n"
16339  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16340  " coordinates).\n"
16341  "\n"
16342  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16343  " scales will not be set, the user must set up the scale before\n"
16344  " calling plenv0 using plsvpa, plvasp or other.\n"
16345  " 0: the x and y axes are scaled independently to use as much of\n"
16346  " the screen as possible.\n"
16347  " 1: the scales of the x and y axes are made equal.\n"
16348  " 2: the axis of the x and y axes are made equal, and the plot\n"
16349  " box will be square.\n"
16350  "\n"
16351  "\n"
16352  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16353  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16354  " -1: draw box only.\n"
16355  " 0: draw box, ticks, and numeric tick labels.\n"
16356  " 1: also draw coordinate axes at x=0 and y=0.\n"
16357  " 2: also draw a grid at major tick positions in both\n"
16358  " coordinates.\n"
16359  " 3: also draw a grid at minor tick positions in both\n"
16360  " coordinates.\n"
16361  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16362  " have to be converted to logarithms separately.)\n"
16363  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16364  " have to be converted to logarithms separately.)\n"
16365  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16366  " have to be converted to logarithms separately.)\n"
16367  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16368  " have to be converted to logarithms separately.)\n"
16369  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16370  " have to be converted to logarithms separately.)\n"
16371  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16372  " have to be converted to logarithms separately.)\n"
16373  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16374  " have to be converted to logarithms separately.)\n"
16375  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16376  " have to be converted to logarithms separately.)\n"
16377  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16378  " and y data have to be converted to logarithms separately.)\n"
16379  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16380  " and y data have to be converted to logarithms separately.)\n"
16381  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16382  " and y data have to be converted to logarithms separately.)\n"
16383  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16384  " and y data have to be converted to logarithms separately.)\n"
16385  " 40: same as 0 except date / time x labels.\n"
16386  " 41: same as 1 except date / time x labels.\n"
16387  " 42: same as 2 except date / time x labels.\n"
16388  " 43: same as 3 except date / time x labels.\n"
16389  " 50: same as 0 except date / time y labels.\n"
16390  " 51: same as 1 except date / time y labels.\n"
16391  " 52: same as 2 except date / time y labels.\n"
16392  " 53: same as 3 except date / time y labels.\n"
16393  " 60: same as 0 except date / time x and y labels.\n"
16394  " 61: same as 1 except date / time x and y labels.\n"
16395  " 62: same as 2 except date / time x and y labels.\n"
16396  " 63: same as 3 except date / time x and y labels.\n"
16397  " 70: same as 0 except custom x and y labels.\n"
16398  " 71: same as 1 except custom x and y labels.\n"
16399  " 72: same as 2 except custom x and y labels.\n"
16400  " 73: same as 3 except custom x and y labels.\n"
16401  "\n"
16402  ""},
16403  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
16404  "Eject current page\n"
16405  "\n"
16406  "DESCRIPTION:\n"
16407  "\n"
16408  " Clears the graphics screen of an interactive device, or ejects a page\n"
16409  " on a plotter. See plbop for more information.\n"
16410  "\n"
16411  " Redacted form: pleop()\n"
16412  "\n"
16413  " This function is used in example 2,14.\n"
16414  "\n"
16415  "\n"
16416  "\n"
16417  "SYNOPSIS:\n"
16418  "\n"
16419  "pleop()\n"
16420  "\n"
16421  ""},
16422  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
16423  "Draw error bars in x direction\n"
16424  "\n"
16425  "DESCRIPTION:\n"
16426  "\n"
16427  " Draws a set of n error bars in x direction, the i'th error bar\n"
16428  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16429  " of the error bars are of length equal to the minor tick length\n"
16430  " (settable using plsmin).\n"
16431  "\n"
16432  " Redacted form: General: plerrx(xmin, ymax, y)\n"
16433  " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
16434  "\n"
16435  "\n"
16436  " This function is used in example 29.\n"
16437  "\n"
16438  "\n"
16439  "\n"
16440  "SYNOPSIS:\n"
16441  "\n"
16442  "plerrx(n, xmin, xmax, y)\n"
16443  "\n"
16444  "ARGUMENTS:\n"
16445  "\n"
16446  " n (PLINT, input) : Number of error bars to draw.\n"
16447  "\n"
16448  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16449  " of the left-hand endpoints of the error bars.\n"
16450  "\n"
16451  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16452  " of the right-hand endpoints of the error bars.\n"
16453  "\n"
16454  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16455  " the error bars.\n"
16456  "\n"
16457  ""},
16458  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
16459  "Draw error bars in the y direction\n"
16460  "\n"
16461  "DESCRIPTION:\n"
16462  "\n"
16463  " Draws a set of n error bars in the y direction, the i'th error bar\n"
16464  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16465  " of the error bars are of length equal to the minor tick length\n"
16466  " (settable using plsmin).\n"
16467  "\n"
16468  " Redacted form: General: plerry(x, ymin, ymax)\n"
16469  " Perl/PDL: plerry(n, x, ymin, ymax)\n"
16470  "\n"
16471  "\n"
16472  " This function is used in example 29.\n"
16473  "\n"
16474  "\n"
16475  "\n"
16476  "SYNOPSIS:\n"
16477  "\n"
16478  "plerry(n, x, ymin, ymax)\n"
16479  "\n"
16480  "ARGUMENTS:\n"
16481  "\n"
16482  " n (PLINT, input) : Number of error bars to draw.\n"
16483  "\n"
16484  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16485  " the error bars.\n"
16486  "\n"
16487  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16488  " of the lower endpoints of the error bars.\n"
16489  "\n"
16490  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16491  " of the upper endpoints of the error bars.\n"
16492  "\n"
16493  ""},
16494  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16495  "Advance to the next family file on the next new page\n"
16496  "\n"
16497  "DESCRIPTION:\n"
16498  "\n"
16499  " Advance to the next family file on the next new page.\n"
16500  "\n"
16501  " Redacted form: plfamadv()\n"
16502  "\n"
16503  " This function is not used in any examples.\n"
16504  "\n"
16505  "\n"
16506  "\n"
16507  "SYNOPSIS:\n"
16508  "\n"
16509  "plfamadv()\n"
16510  "\n"
16511  ""},
16512  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16513  "Draw filled polygon\n"
16514  "\n"
16515  "DESCRIPTION:\n"
16516  "\n"
16517  " Fills the polygon defined by the n points (\n"
16518  " x[i],\n"
16519  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16520  " style is a solid fill. The routine will automatically close the\n"
16521  " polygon between the last and first vertices. If multiple closed\n"
16522  " polygons are passed in x and y then plfill will fill in between them.\n"
16523  "\n"
16524  " Redacted form: plfill(x,y)\n"
16525  "\n"
16526  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16527  "\n"
16528  "\n"
16529  "\n"
16530  "SYNOPSIS:\n"
16531  "\n"
16532  "plfill(n, x, y)\n"
16533  "\n"
16534  "ARGUMENTS:\n"
16535  "\n"
16536  " n (PLINT, input) : Number of vertices in polygon.\n"
16537  "\n"
16538  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16539  " vertices.\n"
16540  "\n"
16541  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16542  " vertices.\n"
16543  "\n"
16544  ""},
16545  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16546  "Draw filled polygon in 3D\n"
16547  "\n"
16548  "DESCRIPTION:\n"
16549  "\n"
16550  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16551  " vectors using the pattern defined by plpsty or plpat. The routine\n"
16552  " will automatically close the polygon between the last and first\n"
16553  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16554  " plfill3 will fill in between them.\n"
16555  "\n"
16556  " Redacted form: General: plfill3(x, y, z)\n"
16557  " Perl/PDL: plfill3(n, x, y, z)\n"
16558  "\n"
16559  "\n"
16560  " This function is used in example 15.\n"
16561  "\n"
16562  "\n"
16563  "\n"
16564  "SYNOPSIS:\n"
16565  "\n"
16566  "plfill3(n, x, y, z)\n"
16567  "\n"
16568  "ARGUMENTS:\n"
16569  "\n"
16570  " n (PLINT, input) : Number of vertices in polygon.\n"
16571  "\n"
16572  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16573  " vertices.\n"
16574  "\n"
16575  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16576  " vertices.\n"
16577  "\n"
16578  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16579  " vertices.\n"
16580  "\n"
16581  ""},
16582  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16583  "Draw linear gradient inside polygon\n"
16584  "\n"
16585  "DESCRIPTION:\n"
16586  "\n"
16587  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16588  " points (\n"
16589  " x[i],\n"
16590  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16591  " polygon coordinates and the gradient angle are all expressed in world\n"
16592  " coordinates. The angle from the x axis for both the rotated\n"
16593  " coordinate system and the gradient vector is specified by angle. The\n"
16594  " magnitude of the gradient vector is the difference between the maximum\n"
16595  " and minimum values of x for the vertices in the rotated coordinate\n"
16596  " system. The origin of the gradient vector can be interpreted as being\n"
16597  " anywhere on the line corresponding to the minimum x value for the\n"
16598  " vertices in the rotated coordinate system. The distance along the\n"
16599  " gradient vector is linearly transformed to the independent variable of\n"
16600  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16601  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16602  " color corresponding to the independent variable of cmap1. For more\n"
16603  " information about cmap1 (see the PLplot documentation).\n"
16604  "\n"
16605  " Redacted form: plgradient(x,y,angle)\n"
16606  "\n"
16607  " This function is used in examples 25 and 30.\n"
16608  "\n"
16609  "\n"
16610  "\n"
16611  "SYNOPSIS:\n"
16612  "\n"
16613  "plgradient(n, x, y, angle)\n"
16614  "\n"
16615  "ARGUMENTS:\n"
16616  "\n"
16617  " n (PLINT, input) : Number of vertices in polygon.\n"
16618  "\n"
16619  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16620  " vertices.\n"
16621  "\n"
16622  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16623  " vertices.\n"
16624  "\n"
16625  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16626  " axis.\n"
16627  "\n"
16628  ""},
16629  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16630  "Flushes the output stream\n"
16631  "\n"
16632  "DESCRIPTION:\n"
16633  "\n"
16634  " Flushes the output stream. Use sparingly, if at all.\n"
16635  "\n"
16636  " Redacted form: plflush()\n"
16637  "\n"
16638  " This function is used in examples 1 and 14.\n"
16639  "\n"
16640  "\n"
16641  "\n"
16642  "SYNOPSIS:\n"
16643  "\n"
16644  "plflush()\n"
16645  "\n"
16646  ""},
16647  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16648  "Set font\n"
16649  "\n"
16650  "DESCRIPTION:\n"
16651  "\n"
16652  " Sets the font used for subsequent text and symbols. For devices that\n"
16653  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16654  " fonts with extended character set are loaded (see plfontld). For\n"
16655  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16656  " this routine calls the plsfci routine with argument set up\n"
16657  " appropriately for the various cases below. However, this method of\n"
16658  " specifying the font for unicode-aware devices is deprecated, and the\n"
16659  " much more flexible method of calling plsfont directly is recommended\n"
16660  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16661  "\n"
16662  " Redacted form: plfont(ifont)\n"
16663  "\n"
16664  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16665  "\n"
16666  "\n"
16667  "\n"
16668  "SYNOPSIS:\n"
16669  "\n"
16670  "plfont(ifont)\n"
16671  "\n"
16672  "ARGUMENTS:\n"
16673  "\n"
16674  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16675  " (simplest and fastest)\n"
16676  " 2: Serif font\n"
16677  " 3: Italic font\n"
16678  " 4: Script font\n"
16679  "\n"
16680  ""},
16681  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16682  "Load Hershey fonts\n"
16683  "\n"
16684  "DESCRIPTION:\n"
16685  "\n"
16686  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16687  " be called before or after initializing PLplot. If not explicitly\n"
16688  " called before PLplot initialization, then by default that\n"
16689  " initialization loads Hershey fonts with the extended character set.\n"
16690  " This routine only has a practical effect for devices that still use\n"
16691  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16692  " system fonts instead of Hershey fonts).\n"
16693  "\n"
16694  " Redacted form: plfontld(fnt)\n"
16695  "\n"
16696  " This function is used in examples 1 and 7.\n"
16697  "\n"
16698  "\n"
16699  "\n"
16700  "SYNOPSIS:\n"
16701  "\n"
16702  "plfontld(fnt)\n"
16703  "\n"
16704  "ARGUMENTS:\n"
16705  "\n"
16706  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16707  " A zero value specifies Hershey fonts with the standard character\n"
16708  " set and a non-zero value (the default assumed if plfontld is never\n"
16709  " called) specifies Hershey fonts with the extended character set.\n"
16710  "\n"
16711  ""},
16712  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16713  "Get character default height and current (scaled) height\n"
16714  "\n"
16715  "DESCRIPTION:\n"
16716  "\n"
16717  " Get character default height and current (scaled) height.\n"
16718  "\n"
16719  " Redacted form: plgchr(p_def, p_ht)\n"
16720  "\n"
16721  " This function is used in example 23.\n"
16722  "\n"
16723  "\n"
16724  "\n"
16725  "SYNOPSIS:\n"
16726  "\n"
16727  "plgchr(p_def, p_ht)\n"
16728  "\n"
16729  "ARGUMENTS:\n"
16730  "\n"
16731  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16732  " character height (mm).\n"
16733  "\n"
16734  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16735  " character height (mm).\n"
16736  "\n"
16737  ""},
16738  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16739  "Returns 8-bit RGB values for given color index from cmap0\n"
16740  "\n"
16741  "DESCRIPTION:\n"
16742  "\n"
16743  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16744  " PLplot documentation). Values are negative if an invalid color id is\n"
16745  " given.\n"
16746  "\n"
16747  " Redacted form: plgcol0(icol0, r, g, b)\n"
16748  "\n"
16749  " This function is used in example 2.\n"
16750  "\n"
16751  "\n"
16752  "\n"
16753  "SYNOPSIS:\n"
16754  "\n"
16755  "plgcol0(icol0, r, g, b)\n"
16756  "\n"
16757  "ARGUMENTS:\n"
16758  "\n"
16759  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16760  "\n"
16761  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16762  " value.\n"
16763  "\n"
16764  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16765  " value.\n"
16766  "\n"
16767  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16768  " value.\n"
16769  "\n"
16770  ""},
16771  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16772  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16773  "\n"
16774  "DESCRIPTION:\n"
16775  "\n"
16776  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16777  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16778  " Values are negative if an invalid color id is given.\n"
16779  "\n"
16780  " Redacted form: plgcola(r, g, b)\n"
16781  "\n"
16782  " This function is used in example 30.\n"
16783  "\n"
16784  "\n"
16785  "\n"
16786  "SYNOPSIS:\n"
16787  "\n"
16788  "plgcol0a(icol0, r, g, b, alpha)\n"
16789  "\n"
16790  "ARGUMENTS:\n"
16791  "\n"
16792  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16793  "\n"
16794  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16795  " in the range from 0 to 255.\n"
16796  "\n"
16797  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16798  " in the range from 0 to 255.\n"
16799  "\n"
16800  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16801  " in the range from 0 to 255.\n"
16802  "\n"
16803  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16804  " transparency in the range from (0.0-1.0).\n"
16805  "\n"
16806  ""},
16807  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16808  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16809  "\n"
16810  "DESCRIPTION:\n"
16811  "\n"
16812  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16813  "\n"
16814  " Redacted form: plgcolbg(r, g, b)\n"
16815  "\n"
16816  " This function is used in example 31.\n"
16817  "\n"
16818  "\n"
16819  "\n"
16820  "SYNOPSIS:\n"
16821  "\n"
16822  "plgcolbg(r, g, b)\n"
16823  "\n"
16824  "ARGUMENTS:\n"
16825  "\n"
16826  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16827  " in the range from 0 to 255.\n"
16828  "\n"
16829  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16830  " in the range from 0 to 255.\n"
16831  "\n"
16832  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16833  " in the range from 0 to 255.\n"
16834  "\n"
16835  ""},
16836  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16837  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16838  "\n"
16839  "DESCRIPTION:\n"
16840  "\n"
16841  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16842  " alpha transparency value.\n"
16843  "\n"
16844  " This function is used in example 31.\n"
16845  "\n"
16846  "\n"
16847  "\n"
16848  "SYNOPSIS:\n"
16849  "\n"
16850  "plgcolbga(r, g, b, alpha)\n"
16851  "\n"
16852  "ARGUMENTS:\n"
16853  "\n"
16854  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16855  " in the range from 0 to 255.\n"
16856  "\n"
16857  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16858  " in the range from 0 to 255.\n"
16859  "\n"
16860  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16861  " in the range from 0 to 255.\n"
16862  "\n"
16863  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16864  " transparency in the range (0.0-1.0).\n"
16865  "\n"
16866  ""},
16867  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16868  "Get the current device-compression setting\n"
16869  "\n"
16870  "DESCRIPTION:\n"
16871  "\n"
16872  " Get the current device-compression setting. This parameter is only\n"
16873  " used for drivers that provide compression.\n"
16874  "\n"
16875  " Redacted form: plgcompression(compression)\n"
16876  "\n"
16877  " This function is used in example 31.\n"
16878  "\n"
16879  "\n"
16880  "\n"
16881  "SYNOPSIS:\n"
16882  "\n"
16883  "plgcompression(compression)\n"
16884  "\n"
16885  "ARGUMENTS:\n"
16886  "\n"
16887  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16888  " compression setting for the current device.\n"
16889  "\n"
16890  ""},
16891  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16892  "Get the current device (keyword) name\n"
16893  "\n"
16894  "DESCRIPTION:\n"
16895  "\n"
16896  " Get the current device (keyword) name. Note: you must have allocated\n"
16897  " space for this (80 characters is safe).\n"
16898  "\n"
16899  " Redacted form: plgdev(p_dev)\n"
16900  "\n"
16901  " This function is used in example 14.\n"
16902  "\n"
16903  "\n"
16904  "\n"
16905  "SYNOPSIS:\n"
16906  "\n"
16907  "plgdev(p_dev)\n"
16908  "\n"
16909  "ARGUMENTS:\n"
16910  "\n"
16911  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16912  " (with preallocated length of 80 characters or more) containing the\n"
16913  " device (keyword) name.\n"
16914  "\n"
16915  ""},
16916  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16917  "Get parameters that define current device-space window\n"
16918  "\n"
16919  "DESCRIPTION:\n"
16920  "\n"
16921  " Get relative margin width, aspect ratio, and relative justification\n"
16922  " that define current device-space window. If plsdidev has not been\n"
16923  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16924  " p_jy will all be 0.\n"
16925  "\n"
16926  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16927  "\n"
16928  " This function is used in example 31.\n"
16929  "\n"
16930  "\n"
16931  "\n"
16932  "SYNOPSIS:\n"
16933  "\n"
16934  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16935  "\n"
16936  "ARGUMENTS:\n"
16937  "\n"
16938  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16939  " margin width.\n"
16940  "\n"
16941  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16942  " ratio.\n"
16943  "\n"
16944  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16945  " justification in x.\n"
16946  "\n"
16947  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16948  " justification in y.\n"
16949  "\n"
16950  ""},
16951  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16952  "Get plot orientation\n"
16953  "\n"
16954  "DESCRIPTION:\n"
16955  "\n"
16956  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16957  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16958  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16959  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16960  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16961  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16962  " not been called the default value pointed to by p_rot will be 0.\n"
16963  "\n"
16964  " Redacted form: plgdiori(p_rot)\n"
16965  "\n"
16966  " This function is not used in any examples.\n"
16967  "\n"
16968  "\n"
16969  "\n"
16970  "SYNOPSIS:\n"
16971  "\n"
16972  "plgdiori(p_rot)\n"
16973  "\n"
16974  "ARGUMENTS:\n"
16975  "\n"
16976  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16977  " parameter.\n"
16978  "\n"
16979  ""},
16980  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16981  "Get parameters that define current plot-space window\n"
16982  "\n"
16983  "DESCRIPTION:\n"
16984  "\n"
16985  " Get relative minima and maxima that define current plot-space window.\n"
16986  " If plsdiplt has not been called the default values pointed to by\n"
16987  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16988  "\n"
16989  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16990  "\n"
16991  " This function is used in example 31.\n"
16992  "\n"
16993  "\n"
16994  "\n"
16995  "SYNOPSIS:\n"
16996  "\n"
16997  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16998  "\n"
16999  "ARGUMENTS:\n"
17000  "\n"
17001  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17002  " minimum in x.\n"
17003  "\n"
17004  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17005  " minimum in y.\n"
17006  "\n"
17007  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17008  " maximum in x.\n"
17009  "\n"
17010  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17011  " maximum in y.\n"
17012  "\n"
17013  ""},
17014  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
17015  "Get family file parameters\n"
17016  "\n"
17017  "DESCRIPTION:\n"
17018  "\n"
17019  " Gets information about current family file, if familying is enabled.\n"
17020  " See the PLplot documentation for more information.\n"
17021  "\n"
17022  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17023  "\n"
17024  " This function is used in examples 14 and 31.\n"
17025  "\n"
17026  "\n"
17027  "\n"
17028  "SYNOPSIS:\n"
17029  "\n"
17030  "plgfam(p_fam, p_num, p_bmax)\n"
17031  "\n"
17032  "ARGUMENTS:\n"
17033  "\n"
17034  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17035  " family flag value. If nonzero, familying is enabled for the\n"
17036  " current device.\n"
17037  "\n"
17038  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17039  " family file number.\n"
17040  "\n"
17041  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17042  " file size (in bytes) for a family file.\n"
17043  "\n"
17044  ""},
17045  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
17046  "Get FCI (font characterization integer)\n"
17047  "\n"
17048  "DESCRIPTION:\n"
17049  "\n"
17050  " Gets information about the current font using the FCI approach. See\n"
17051  " the PLplot documentation for more information.\n"
17052  "\n"
17053  " Redacted form: plgfci(p_fci)\n"
17054  "\n"
17055  " This function is used in example 23.\n"
17056  "\n"
17057  "\n"
17058  "\n"
17059  "SYNOPSIS:\n"
17060  "\n"
17061  "plgfci(p_fci)\n"
17062  "\n"
17063  "ARGUMENTS:\n"
17064  "\n"
17065  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17066  " FCI value.\n"
17067  "\n"
17068  ""},
17069  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
17070  "Get output file name\n"
17071  "\n"
17072  "DESCRIPTION:\n"
17073  "\n"
17074  " Gets the current output file name, if applicable.\n"
17075  "\n"
17076  " Redacted form: plgfnam(fnam)\n"
17077  "\n"
17078  " This function is used in example 31.\n"
17079  "\n"
17080  "\n"
17081  "\n"
17082  "SYNOPSIS:\n"
17083  "\n"
17084  "plgfnam(fnam)\n"
17085  "\n"
17086  "ARGUMENTS:\n"
17087  "\n"
17088  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17089  " (with preallocated length of 80 characters or more) containing the\n"
17090  " file name.\n"
17091  "\n"
17092  ""},
17093  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
17094  "Get family, style and weight of the current font\n"
17095  "\n"
17096  "DESCRIPTION:\n"
17097  "\n"
17098  " Gets information about current font. See the PLplot documentation for\n"
17099  " more information on font selection.\n"
17100  "\n"
17101  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17102  "\n"
17103  " This function is used in example 23.\n"
17104  "\n"
17105  "\n"
17106  "\n"
17107  "SYNOPSIS:\n"
17108  "\n"
17109  "plgfont(p_family, p_style, p_weight)\n"
17110  "\n"
17111  "ARGUMENTS:\n"
17112  "\n"
17113  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17114  " font family. The available values are given by the PL_FCI_*\n"
17115  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17116  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17117  " p_family is NULL then the font family is not returned.\n"
17118  "\n"
17119  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17120  " font style. The available values are given by the PL_FCI_*\n"
17121  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17122  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17123  " style is not returned.\n"
17124  "\n"
17125  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17126  " font weight. The available values are given by the PL_FCI_*\n"
17127  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17128  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17129  " returned.\n"
17130  "\n"
17131  ""},
17132  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
17133  "Get the (current) run level\n"
17134  "\n"
17135  "DESCRIPTION:\n"
17136  "\n"
17137  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17138  " 1, initialized\n"
17139  " 2, viewport defined\n"
17140  " 3, world coordinates defined\n"
17141  "\n"
17142  "\n"
17143  " Redacted form: plglevel(p_level)\n"
17144  "\n"
17145  " This function is used in example 31.\n"
17146  "\n"
17147  "\n"
17148  "\n"
17149  "SYNOPSIS:\n"
17150  "\n"
17151  "plglevel(p_level)\n"
17152  "\n"
17153  "ARGUMENTS:\n"
17154  "\n"
17155  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17156  " level.\n"
17157  "\n"
17158  ""},
17159  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
17160  "Get page parameters\n"
17161  "\n"
17162  "DESCRIPTION:\n"
17163  "\n"
17164  " Gets the current page configuration. The length and offset values are\n"
17165  " expressed in units that are specific to the current driver. For\n"
17166  " instance: screen drivers will usually interpret them as number of\n"
17167  " pixels, whereas printer drivers will usually use mm.\n"
17168  "\n"
17169  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17170  "\n"
17171  " This function is used in examples 14 and 31.\n"
17172  "\n"
17173  "\n"
17174  "\n"
17175  "SYNOPSIS:\n"
17176  "\n"
17177  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17178  "\n"
17179  "ARGUMENTS:\n"
17180  "\n"
17181  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17182  " pixels/inch (DPI) in x.\n"
17183  "\n"
17184  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17185  " pixels/inch (DPI) in y.\n"
17186  "\n"
17187  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17188  " length.\n"
17189  "\n"
17190  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17191  " length.\n"
17192  "\n"
17193  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17194  " offset.\n"
17195  "\n"
17196  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17197  " offset.\n"
17198  "\n"
17199  ""},
17200  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
17201  "Switch to graphics screen\n"
17202  "\n"
17203  "DESCRIPTION:\n"
17204  "\n"
17205  " Sets an interactive device to graphics mode, used in conjunction with\n"
17206  " pltext to allow graphics and text to be interspersed. On a device\n"
17207  " which supports separate text and graphics windows, this command causes\n"
17208  " control to be switched to the graphics window. If already in graphics\n"
17209  " mode, this command is ignored. It is also ignored on devices which\n"
17210  " only support a single window or use a different method for shifting\n"
17211  " focus. See also pltext.\n"
17212  "\n"
17213  " Redacted form: plgra()\n"
17214  "\n"
17215  " This function is used in example 1.\n"
17216  "\n"
17217  "\n"
17218  "\n"
17219  "SYNOPSIS:\n"
17220  "\n"
17221  "plgra()\n"
17222  "\n"
17223  ""},
17224  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
17225  "Grid data from irregularly sampled data\n"
17226  "\n"
17227  "DESCRIPTION:\n"
17228  "\n"
17229  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17230  " require data organized as a grid, i.e., with x sample point values\n"
17231  " independent of y coordinate and vice versa. This function takes\n"
17232  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17233  " vectors; reads the desired grid location from the input vectors\n"
17234  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17235  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17236  " interpolate the data to the grid is specified with the argument type\n"
17237  " which can have one parameter specified in argument data.\n"
17238  "\n"
17239  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17240  " Perl/PDL: Not available?\n"
17241  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17242  "\n"
17243  "\n"
17244  " This function is used in example 21.\n"
17245  "\n"
17246  "\n"
17247  "\n"
17248  "SYNOPSIS:\n"
17249  "\n"
17250  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17251  "\n"
17252  "ARGUMENTS:\n"
17253  "\n"
17254  " x (PLFLT_VECTOR, input) : The input x vector.\n"
17255  "\n"
17256  " y (PLFLT_VECTOR, input) : The input y vector.\n"
17257  "\n"
17258  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17259  " y[i], z[i] represents one data sample coordinate.\n"
17260  "\n"
17261  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17262  " vectors.\n"
17263  "\n"
17264  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17265  " in the x direction. Usually xg has nptsx equally spaced values\n"
17266  " from the minimum to the maximum values of the x input vector.\n"
17267  "\n"
17268  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17269  "\n"
17270  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17271  " in the y direction. Similar to the xg parameter.\n"
17272  "\n"
17273  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17274  "\n"
17275  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17276  " where data lies in the grid specified by xg and yg. Therefore the\n"
17277  " zg matrix must be dimensioned\n"
17278  " nptsx by\n"
17279  " nptsy.\n"
17280  "\n"
17281  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17282  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17283  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17284  " GRID_NNI: Natural Neighbors Interpolation\n"
17285  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17286  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17287  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17288  " Weighted\n"
17289  " For details of the algorithms read the source file plgridd.c.\n"
17290  "\n"
17291  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17292  " which can be specified through this argument. Currently, for\n"
17293  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17294  " use, the lower the value, the noisier (more local) the\n"
17295  " approximation is.\n"
17296  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17297  " range [1. .. 2.]. High values enable the usage of very thin\n"
17298  " triangles for interpolation, possibly resulting in error in\n"
17299  " the approximation.\n"
17300  " GRID_NNI, only weights greater than data will be accepted. If\n"
17301  " 0, all weights will be accepted.\n"
17302  "\n"
17303  ""},
17304  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
17305  "Get current subpage parameters\n"
17306  "\n"
17307  "DESCRIPTION:\n"
17308  "\n"
17309  " Gets the size of the current subpage in millimeters measured from the\n"
17310  " bottom left hand corner of the output device page or screen. Can be\n"
17311  " used in conjunction with plsvpa for setting the size of a viewport in\n"
17312  " absolute coordinates (millimeters).\n"
17313  "\n"
17314  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17315  "\n"
17316  " This function is used in example 23.\n"
17317  "\n"
17318  "\n"
17319  "\n"
17320  "SYNOPSIS:\n"
17321  "\n"
17322  "plgspa(xmin, xmax, ymin, ymax)\n"
17323  "\n"
17324  "ARGUMENTS:\n"
17325  "\n"
17326  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17327  " the left hand edge of the subpage in millimeters.\n"
17328  "\n"
17329  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17330  " the right hand edge of the subpage in millimeters.\n"
17331  "\n"
17332  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17333  " the bottom edge of the subpage in millimeters.\n"
17334  "\n"
17335  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17336  " the top edge of the subpage in millimeters.\n"
17337  "\n"
17338  ""},
17339  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
17340  "Get current stream number\n"
17341  "\n"
17342  "DESCRIPTION:\n"
17343  "\n"
17344  " Gets the number of the current output stream. See also plsstrm.\n"
17345  "\n"
17346  " Redacted form: plgstrm(p_strm)\n"
17347  "\n"
17348  " This function is used in example 1,20.\n"
17349  "\n"
17350  "\n"
17351  "\n"
17352  "SYNOPSIS:\n"
17353  "\n"
17354  "plgstrm(p_strm)\n"
17355  "\n"
17356  "ARGUMENTS:\n"
17357  "\n"
17358  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17359  " stream value.\n"
17360  "\n"
17361  ""},
17362  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
17363  "Get the current library version number\n"
17364  "\n"
17365  "DESCRIPTION:\n"
17366  "\n"
17367  " Get the current library version number. Note: you must have allocated\n"
17368  " space for this (80 characters is safe).\n"
17369  "\n"
17370  " Redacted form: plgver(p_ver)\n"
17371  "\n"
17372  " This function is used in example 1.\n"
17373  "\n"
17374  "\n"
17375  "\n"
17376  "SYNOPSIS:\n"
17377  "\n"
17378  "plgver(p_ver)\n"
17379  "\n"
17380  "ARGUMENTS:\n"
17381  "\n"
17382  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17383  " (with preallocated length of 80 characters or more) containing the\n"
17384  " PLplot version number.\n"
17385  "\n"
17386  ""},
17387  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
17388  "Get viewport limits in normalized device coordinates\n"
17389  "\n"
17390  "DESCRIPTION:\n"
17391  "\n"
17392  " Get viewport limits in normalized device coordinates.\n"
17393  "\n"
17394  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17395  " Perl/PDL: Not available?\n"
17396  "\n"
17397  "\n"
17398  " This function is used in example 31.\n"
17399  "\n"
17400  "\n"
17401  "\n"
17402  "SYNOPSIS:\n"
17403  "\n"
17404  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17405  "\n"
17406  "ARGUMENTS:\n"
17407  "\n"
17408  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17409  " viewport limit of the normalized device coordinate in x.\n"
17410  "\n"
17411  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17412  " viewport limit of the normalized device coordinate in x.\n"
17413  "\n"
17414  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17415  " viewport limit of the normalized device coordinate in y.\n"
17416  "\n"
17417  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17418  " viewport limit of the normalized device coordinate in y.\n"
17419  "\n"
17420  ""},
17421  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
17422  "Get viewport limits in world coordinates\n"
17423  "\n"
17424  "DESCRIPTION:\n"
17425  "\n"
17426  " Get viewport limits in world coordinates.\n"
17427  "\n"
17428  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17429  " Perl/PDL: Not available?\n"
17430  "\n"
17431  "\n"
17432  " This function is used in example 31.\n"
17433  "\n"
17434  "\n"
17435  "\n"
17436  "SYNOPSIS:\n"
17437  "\n"
17438  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17439  "\n"
17440  "ARGUMENTS:\n"
17441  "\n"
17442  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17443  " viewport limit of the world coordinate in x.\n"
17444  "\n"
17445  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17446  " viewport limit of the world coordinate in x.\n"
17447  "\n"
17448  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17449  " viewport limit of the world coordinate in y.\n"
17450  "\n"
17451  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17452  " viewport limit of the world coordinate in y.\n"
17453  "\n"
17454  ""},
17455  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
17456  "Get x axis parameters\n"
17457  "\n"
17458  "DESCRIPTION:\n"
17459  "\n"
17460  " Returns current values of the p_digmax and p_digits flags for the x\n"
17461  " axis. p_digits is updated after the plot is drawn, so this routine\n"
17462  " should only be called after the call to plbox (or plbox3) is complete.\n"
17463  " See the PLplot documentation for more information.\n"
17464  "\n"
17465  " Redacted form: plgxax(p_digmax, p_digits)\n"
17466  "\n"
17467  " This function is used in example 31.\n"
17468  "\n"
17469  "\n"
17470  "\n"
17471  "SYNOPSIS:\n"
17472  "\n"
17473  "plgxax(p_digmax, p_digits)\n"
17474  "\n"
17475  "ARGUMENTS:\n"
17476  "\n"
17477  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17478  " number of digits for the x axis. If nonzero, the printed label\n"
17479  " has been switched to a floating-point representation when the\n"
17480  " number of digits exceeds this value.\n"
17481  "\n"
17482  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17483  " number of digits for the numeric labels (x axis) from the last\n"
17484  " plot.\n"
17485  "\n"
17486  ""},
17487  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
17488  "Get y axis parameters\n"
17489  "\n"
17490  "DESCRIPTION:\n"
17491  "\n"
17492  " Identical to plgxax, except that arguments are flags for y axis. See\n"
17493  " the description of plgxax for more detail.\n"
17494  "\n"
17495  " Redacted form: plgyax(p_digmax, p_digits)\n"
17496  "\n"
17497  " This function is used in example 31.\n"
17498  "\n"
17499  "\n"
17500  "\n"
17501  "SYNOPSIS:\n"
17502  "\n"
17503  "plgyax(p_digmax, p_digits)\n"
17504  "\n"
17505  "ARGUMENTS:\n"
17506  "\n"
17507  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17508  " number of digits for the y axis. If nonzero, the printed label\n"
17509  " has been switched to a floating-point representation when the\n"
17510  " number of digits exceeds this value.\n"
17511  "\n"
17512  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17513  " number of digits for the numeric labels (y axis) from the last\n"
17514  " plot.\n"
17515  "\n"
17516  ""},
17517  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
17518  "Get z axis parameters\n"
17519  "\n"
17520  "DESCRIPTION:\n"
17521  "\n"
17522  " Identical to plgxax, except that arguments are flags for z axis. See\n"
17523  " the description of plgxax for more detail.\n"
17524  "\n"
17525  " Redacted form: plgzax(p_digmax, p_digits)\n"
17526  "\n"
17527  " This function is used in example 31.\n"
17528  "\n"
17529  "\n"
17530  "\n"
17531  "SYNOPSIS:\n"
17532  "\n"
17533  "plgzax(p_digmax, p_digits)\n"
17534  "\n"
17535  "ARGUMENTS:\n"
17536  "\n"
17537  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17538  " number of digits for the z axis. If nonzero, the printed label\n"
17539  " has been switched to a floating-point representation when the\n"
17540  " number of digits exceeds this value.\n"
17541  "\n"
17542  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17543  " number of digits for the numeric labels (z axis) from the last\n"
17544  " plot.\n"
17545  "\n"
17546  ""},
17547  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17548  "Plot a histogram from unbinned data\n"
17549  "\n"
17550  "DESCRIPTION:\n"
17551  "\n"
17552  " Plots a histogram from n data points stored in the data vector. This\n"
17553  " routine bins the data into nbin bins equally spaced between datmin and\n"
17554  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17555  " opt allows, among other things, the histogram either to be plotted in\n"
17556  " an existing window or causes plhist to call plenv with suitable limits\n"
17557  " before plotting the histogram.\n"
17558  "\n"
17559  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17560  "\n"
17561  " This function is used in example 5.\n"
17562  "\n"
17563  "\n"
17564  "\n"
17565  "SYNOPSIS:\n"
17566  "\n"
17567  "plhist(n, data, datmin, datmax, nbin, opt)\n"
17568  "\n"
17569  "ARGUMENTS:\n"
17570  "\n"
17571  " n (PLINT, input) : Number of data points.\n"
17572  "\n"
17573  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17574  " n data points.\n"
17575  "\n"
17576  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17577  "\n"
17578  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17579  "\n"
17580  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17581  " divide the interval xmin to xmax.\n"
17582  "\n"
17583  " opt (PLINT, input) : Is a combination of several flags:\n"
17584  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17585  " the histogram data, the outer bins are expanded to fill up the\n"
17586  " entire x-axis, data outside the given extremes are assigned to the\n"
17587  " outer bins and bins of zero height are simply drawn.\n"
17588  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17589  " to fit the histogram data, without this flag, plenv is called\n"
17590  " to set the world coordinates.\n"
17591  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17592  " extremes are not taken into account. This option should\n"
17593  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17594  " properly present the data.\n"
17595  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17596  " size as the ones inside.\n"
17597  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17598  " (there is a gap for such bins).\n"
17599  "\n"
17600  ""},
17601  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17602  "Convert HLS color to RGB\n"
17603  "\n"
17604  "DESCRIPTION:\n"
17605  "\n"
17606  " Convert HLS color coordinates to RGB.\n"
17607  "\n"
17608  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17609  " Perl/PDL: Not available? Implemented as plhls?\n"
17610  "\n"
17611  "\n"
17612  " This function is used in example 2.\n"
17613  "\n"
17614  "\n"
17615  "\n"
17616  "SYNOPSIS:\n"
17617  "\n"
17618  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17619  "\n"
17620  "ARGUMENTS:\n"
17621  "\n"
17622  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17623  " cylinder.\n"
17624  "\n"
17625  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17626  " the axis of the color cylinder.\n"
17627  "\n"
17628  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17629  " the radius of the color cylinder.\n"
17630  "\n"
17631  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17632  " (0.0-1.0) of the color.\n"
17633  "\n"
17634  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17635  " intensity (0.0-1.0) of the color.\n"
17636  "\n"
17637  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17638  " intensity (0.0-1.0) of the color.\n"
17639  "\n"
17640  ""},
17641  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17642  "Initialize PLplot\n"
17643  "\n"
17644  "DESCRIPTION:\n"
17645  "\n"
17646  " Initializing the plotting package. The program prompts for the device\n"
17647  " keyword or number of the desired output device. Hitting a RETURN in\n"
17648  " response to the prompt is the same as selecting the first device.\n"
17649  " plinit will issue no prompt if either the device was specified\n"
17650  " previously (via command line flag, the plsetopt function, or the\n"
17651  " plsdev function), or if only one device is enabled when PLplot is\n"
17652  " installed. If subpages have been specified, the output device is\n"
17653  " divided into nx by ny subpages, each of which may be used\n"
17654  " independently. If plinit is called again during a program, the\n"
17655  " previously opened file will be closed. The subroutine pladv is used\n"
17656  " to advance from one subpage to the next.\n"
17657  "\n"
17658  " Redacted form: plinit()\n"
17659  "\n"
17660  " This function is used in all of the examples.\n"
17661  "\n"
17662  "\n"
17663  "\n"
17664  "SYNOPSIS:\n"
17665  "\n"
17666  "plinit()\n"
17667  "\n"
17668  ""},
17669  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17670  "Draw a line between two points\n"
17671  "\n"
17672  "DESCRIPTION:\n"
17673  "\n"
17674  " Joins the point (\n"
17675  " x1,\n"
17676  " y1) to (\n"
17677  " x2,\n"
17678  " y2).\n"
17679  "\n"
17680  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17681  "\n"
17682  " This function is used in examples 3 and 14.\n"
17683  "\n"
17684  "\n"
17685  "\n"
17686  "SYNOPSIS:\n"
17687  "\n"
17688  "pljoin(x1, y1, x2, y2)\n"
17689  "\n"
17690  "ARGUMENTS:\n"
17691  "\n"
17692  " x1 (PLFLT, input) : x coordinate of first point.\n"
17693  "\n"
17694  " y1 (PLFLT, input) : y coordinate of first point.\n"
17695  "\n"
17696  " x2 (PLFLT, input) : x coordinate of second point.\n"
17697  "\n"
17698  " y2 (PLFLT, input) : y coordinate of second point.\n"
17699  "\n"
17700  ""},
17701  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17702  "Simple routine to write labels\n"
17703  "\n"
17704  "DESCRIPTION:\n"
17705  "\n"
17706  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17707  "\n"
17708  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17709  "\n"
17710  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17711  "\n"
17712  "\n"
17713  "\n"
17714  "SYNOPSIS:\n"
17715  "\n"
17716  "pllab(xlabel, ylabel, tlabel)\n"
17717  "\n"
17718  "ARGUMENTS:\n"
17719  "\n"
17720  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17721  " the label for the x axis.\n"
17722  "\n"
17723  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17724  " the label for the y axis.\n"
17725  "\n"
17726  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17727  " the title of the plot.\n"
17728  "\n"
17729  ""},
17730  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17731  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17732  "\n"
17733  "DESCRIPTION:\n"
17734  "\n"
17735  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17736  " line, and/or line of symbols for each annotated legend entry. (See\n"
17737  " plcolorbar for similar functionality for creating continuous color\n"
17738  " bars.) The arguments of pllegend provide control over the location\n"
17739  " and size of the legend as well as the location and characteristics of\n"
17740  " the elements (most of which are optional) within that legend. The\n"
17741  " resulting legend is clipped at the boundaries of the current subpage.\n"
17742  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17743  " defined in the documentation of the position parameter.)\n"
17744  "\n"
17745  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17746  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17747  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17748  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17749  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17750  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17751  "\n"
17752  " This function is used in examples 4, 26, and 33.\n"
17753  "\n"
17754  "\n"
17755  "\n"
17756  "SYNOPSIS:\n"
17757  "\n"
17758  "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"
17759  "\n"
17760  "ARGUMENTS:\n"
17761  "\n"
17762  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17763  " legend width in adopted coordinates. This quantity is calculated\n"
17764  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17765  " the routine depending on nlegend and nrow), and the length\n"
17766  " (calculated internally) of the longest text string.\n"
17767  "\n"
17768  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17769  " legend height in adopted coordinates. This quantity is calculated\n"
17770  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17771  " the routine depending on nlegend and nrow).\n"
17772  "\n"
17773  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17774  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17775  " on the left of the legend and the plotted area on the right.\n"
17776  " Otherwise, put the text area on the right of the legend and the\n"
17777  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17778  " plot a (semitransparent) background for the legend. If the\n"
17779  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17780  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17781  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17782  " plot the resulting array of legend entries in row-major order.\n"
17783  " Otherwise, plot the legend entries in column-major order.\n"
17784  "\n"
17785  " position (PLINT, input) : position contains bits which control the\n"
17786  " overall position of the legend and the definition of the adopted\n"
17787  " coordinates used for positions just like what is done for the\n"
17788  " position argument for plcolorbar. However, note that the defaults\n"
17789  " for the position bits (see below) are different than the\n"
17790  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17791  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17792  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17793  " the 16 possible standard positions (the 4 corners and centers of\n"
17794  " the 4 sides for both the inside and outside cases) of the legend\n"
17795  " relative to the adopted coordinate system. The corner positions\n"
17796  " are specified by the appropriate combination of two of the\n"
17797  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17798  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17799  " value of one of those bits. The adopted coordinates are\n"
17800  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17801  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17802  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17803  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17804  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17805  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17806  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17807  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17808  "\n"
17809  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17810  " coordinates from the specified standard position of the legend.\n"
17811  " For positive x, the direction of motion away from the standard\n"
17812  " position is inward/outward from the standard corner positions or\n"
17813  " standard left or right positions if the\n"
17814  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17815  " For the standard top or bottom positions, the direction of motion\n"
17816  " is toward positive X.\n"
17817  "\n"
17818  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17819  " coordinates from the specified standard position of the legend.\n"
17820  " For positive y, the direction of motion away from the standard\n"
17821  " position is inward/outward from the standard corner positions or\n"
17822  " standard top or bottom positions if the\n"
17823  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17824  " the standard left or right positions, the direction of motion is\n"
17825  " toward positive Y.\n"
17826  "\n"
17827  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17828  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17829  " symbols are drawn) of the legend.\n"
17830  "\n"
17831  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17832  " legend (PL_LEGEND_BACKGROUND).\n"
17833  "\n"
17834  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17835  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17836  "\n"
17837  " bb_style (PLINT, input) : The pllsty style number for the\n"
17838  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17839  "\n"
17840  " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17841  " the legend (PL_LEGEND_BACKGROUND).\n"
17842  "\n"
17843  " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17844  " for the legend (PL_LEGEND_BACKGROUND).\n"
17845  "\n"
17846  " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17847  " vertical height of the legend in adopted coordinates is calculated\n"
17848  " internally from nlegend, text_scale (see below), and text_spacing\n"
17849  " (see below).\n"
17850  "\n"
17851  " opt_array (PLINT_VECTOR, input) : A vector of\n"
17852  " nlegend values of options to control each individual plotted area\n"
17853  " corresponding to a legend entry. If the\n"
17854  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17855  " area. If the\n"
17856  " PL_LEGEND_COLOR_BOX,\n"
17857  " PL_LEGEND_LINE, and/or\n"
17858  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17859  " entry is plotted with a colored box; a line; and/or a line of\n"
17860  " symbols.\n"
17861  "\n"
17862  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17863  " area in units of character width. N.B. The total horizontal\n"
17864  " width of the legend in adopted coordinates is calculated\n"
17865  " internally from\n"
17866  " plot_width (see above),\n"
17867  " text_offset, and length (calculated internally) of the longest text\n"
17868  " string.\n"
17869  "\n"
17870  " text_scale (PLFLT, input) : Character height scale for text\n"
17871  " annotations. N.B. The total vertical height of the legend in\n"
17872  " adopted coordinates is calculated internally from\n"
17873  " nlegend (see above),\n"
17874  " text_scale, and\n"
17875  " text_spacing (see below).\n"
17876  "\n"
17877  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17878  " character height from one legend entry to the next. N.B. The\n"
17879  " total vertical height of the legend in adopted coordinates is\n"
17880  " calculated internally from\n"
17881  " nlegend (see above),\n"
17882  " text_scale (see above), and\n"
17883  " text_spacing.\n"
17884  "\n"
17885  " text_justification (PLFLT, input) : Justification parameter used\n"
17886  " for text justification. The most common values of\n"
17887  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17888  " is left justified, centred, or right justified within the text\n"
17889  " area, but other values are allowed as well.\n"
17890  "\n"
17891  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17892  " nlegend cmap0 text colors.\n"
17893  "\n"
17894  " text (PLCHAR_MATRIX, input) : A vector of\n"
17895  " nlegend UTF-8 character strings containing the legend annotations.\n"
17896  "\n"
17897  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17898  " nlegend cmap0 colors for the discrete colored boxes (\n"
17899  " PL_LEGEND_COLOR_BOX).\n"
17900  "\n"
17901  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17902  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17903  " PL_LEGEND_COLOR_BOX).\n"
17904  "\n"
17905  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17906  " nlegend scales (units of fraction of character height) for the height\n"
17907  " of the discrete colored boxes (\n"
17908  " PL_LEGEND_COLOR_BOX).\n"
17909  "\n"
17910  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17911  " nlegend line widths for the patterns specified by box_patterns (\n"
17912  " PL_LEGEND_COLOR_BOX).\n"
17913  "\n"
17914  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17915  " nlegend cmap0 line colors (\n"
17916  " PL_LEGEND_LINE).\n"
17917  "\n"
17918  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17919  " nlegend line styles (plsty indices) (\n"
17920  " PL_LEGEND_LINE).\n"
17921  "\n"
17922  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17923  " nlegend line widths (\n"
17924  " PL_LEGEND_LINE).\n"
17925  "\n"
17926  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17927  " nlegend cmap0 symbol colors (\n"
17928  " PL_LEGEND_SYMBOL).\n"
17929  "\n"
17930  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17931  " nlegend scale values for the symbol height (\n"
17932  " PL_LEGEND_SYMBOL).\n"
17933  "\n"
17934  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17935  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17936  " area (\n"
17937  " PL_LEGEND_SYMBOL).\n"
17938  "\n"
17939  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17940  " nlegend UTF-8 character strings containing the legend symbols. (\n"
17941  " PL_LEGEND_SYMBOL).\n"
17942  "\n"
17943  ""},
17944  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
17945  "Plot color bar for image, shade or gradient plots\n"
17946  "\n"
17947  "DESCRIPTION:\n"
17948  "\n"
17949  " Routine for creating a continuous color bar for image, shade, or\n"
17950  " gradient plots. (See pllegend for similar functionality for creating\n"
17951  " legends with discrete elements). The arguments of plcolorbar provide\n"
17952  " control over the location and size of the color bar as well as the\n"
17953  " location and characteristics of the elements (most of which are\n"
17954  " optional) within that color bar. The resulting color bar is clipped\n"
17955  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17956  " system used for some of the parameters is defined in the documentation\n"
17957  " of the position parameter.)\n"
17958  "\n"
17959  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17960  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17961  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17962  " labels, axis_opts, ticks, sub_ticks, values)\n"
17963  "\n"
17964  " This function is used in examples 16 and 33.\n"
17965  "\n"
17966  "\n"
17967  "\n"
17968  "SYNOPSIS:\n"
17969  "\n"
17970  "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"
17971  "\n"
17972  "ARGUMENTS:\n"
17973  "\n"
17974  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17975  " labelled and decorated color bar width in adopted coordinates.\n"
17976  "\n"
17977  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17978  " labelled and decorated color bar height in adopted coordinates.\n"
17979  "\n"
17980  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17981  " color bar. The orientation (direction of the maximum value) of\n"
17982  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17983  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17984  " specified, the default orientation is toward the top if the\n"
17985  " colorbar is placed on the left or right of the viewport or toward\n"
17986  " the right if the colorbar is placed on the top or bottom of the\n"
17987  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17988  " (semitransparent) background for the color bar. If the\n"
17989  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17990  " color bar. The type of color bar must be specified with one of\n"
17991  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17992  " more than one of those bits is set only the first one in the above\n"
17993  " list is honored. The position of the (optional) label/title can be\n"
17994  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17995  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17996  " will be drawn. If more than one of this list of bits is specified,\n"
17997  " only the first one on the list is honored. End-caps for the color\n"
17998  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17999  " If a particular color bar cap option is not specified then no cap\n"
18000  " will be drawn for that end. As a special case for\n"
18001  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18002  " specified. If this option is provided then any tick marks and tick\n"
18003  " labels will be placed at the breaks between shaded segments. TODO:\n"
18004  " This should be expanded to support custom placement of tick marks\n"
18005  " and tick labels at custom value locations for any color bar type.\n"
18006  "\n"
18007  " position (PLINT, input) : position contains bits which control the\n"
18008  " overall position of the color bar and the definition of the\n"
18009  " adopted coordinates used for positions just like what is done for\n"
18010  " the position argument for pllegend. However, note that the\n"
18011  " defaults for the position bits (see below) are different than the\n"
18012  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18013  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18014  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18015  " the 16 possible standard positions (the 4 corners and centers of\n"
18016  " the 4 sides for both the inside and outside cases) of the color\n"
18017  " bar relative to the adopted coordinate system. The corner\n"
18018  " positions are specified by the appropriate combination of two of\n"
18019  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18020  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18021  " value of one of those bits. The adopted coordinates are\n"
18022  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18023  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18024  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18025  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18026  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18027  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18028  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18029  " PL_POSITION_VIEWPORT.\n"
18030  "\n"
18031  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18032  " coordinates from the specified standard position of the color bar.\n"
18033  " For positive x, the direction of motion away from the standard\n"
18034  " position is inward/outward from the standard corner positions or\n"
18035  " standard left or right positions if the\n"
18036  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18037  " For the standard top or bottom positions, the direction of motion\n"
18038  " is toward positive X.\n"
18039  "\n"
18040  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18041  " coordinates from the specified standard position of the color bar.\n"
18042  " For positive y, the direction of motion away from the standard\n"
18043  " position is inward/outward from the standard corner positions or\n"
18044  " standard top or bottom positions if the\n"
18045  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18046  " For the standard left or right positions, the direction of motion\n"
18047  " is toward positive Y.\n"
18048  "\n"
18049  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18050  " the X direction in adopted coordinates.\n"
18051  "\n"
18052  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18053  " the Y direction in adopted coordinates.\n"
18054  "\n"
18055  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18056  " color bar (PL_COLORBAR_BACKGROUND).\n"
18057  "\n"
18058  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18059  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18060  "\n"
18061  " bb_style (PLINT, input) : The pllsty style number for the\n"
18062  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18063  "\n"
18064  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18065  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18066  "\n"
18067  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18068  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18069  "\n"
18070  " cont_color (PLINT, input) : The cmap0 contour color for\n"
18071  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18072  " it will be interpreted according to the design of plshades.\n"
18073  "\n"
18074  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18075  " plots. This is passed directly to plshades, so it will be\n"
18076  " interpreted according to the design of plshades.\n"
18077  "\n"
18078  " n_labels (PLINT, input) : Number of labels to place around the\n"
18079  " color bar.\n"
18080  "\n"
18081  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18082  " n_labels labels.\n"
18083  "\n"
18084  " labels (PLCHAR_MATRIX, input) : A vector of\n"
18085  " n_labels UTF-8 character strings containing the labels for the color\n"
18086  " bar. Ignored if no label position is specified with one of the\n"
18087  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18088  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18089  " corresponding label_opts field.\n"
18090  "\n"
18091  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18092  " value must be greater than 0. It is typically 1 (numerical axis\n"
18093  " labels are provided for one of the long edges of the color bar),\n"
18094  " but it can be larger if multiple numerical axis labels for the\n"
18095  " long edges of the color bar are desired.\n"
18096  "\n"
18097  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18098  " n_axes ascii character strings containing options (interpreted as for\n"
18099  " plbox) for the color bar's axis definitions.\n"
18100  "\n"
18101  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18102  " spacing of the major tick marks (interpreted as for plbox) for the\n"
18103  " color bar's axis definitions.\n"
18104  "\n"
18105  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18106  " number of subticks (interpreted as for plbox) for the color bar's\n"
18107  " axis definitions.\n"
18108  "\n"
18109  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18110  " elements in each of the n_axes rows of the values matrix.\n"
18111  "\n"
18112  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18113  " values for the data range represented by the color bar. For a row\n"
18114  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18115  " elements in the row is specified by n_values[i_axis]. For\n"
18116  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18117  " is 2, and the corresponding row elements of the values matrix are\n"
18118  " the minimum and maximum value represented by the colorbar. For\n"
18119  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18120  " of the values matrix is interpreted the same as the nlevel and\n"
18121  " clevel arguments of plshades.\n"
18122  "\n"
18123  ""},
18124  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
18125  "Sets the 3D position of the light source\n"
18126  "\n"
18127  "DESCRIPTION:\n"
18128  "\n"
18129  " Sets the 3D position of the light source for use with plsurf3d and\n"
18130  " plsurf3dl\n"
18131  "\n"
18132  " Redacted form: pllightsource(x, y, z)\n"
18133  "\n"
18134  " This function is used in example 8.\n"
18135  "\n"
18136  "\n"
18137  "\n"
18138  "SYNOPSIS:\n"
18139  "\n"
18140  "pllightsource(x, y, z)\n"
18141  "\n"
18142  "ARGUMENTS:\n"
18143  "\n"
18144  " x (PLFLT, input) : X-coordinate of the light source.\n"
18145  "\n"
18146  " y (PLFLT, input) : Y-coordinate of the light source.\n"
18147  "\n"
18148  " z (PLFLT, input) : Z-coordinate of the light source.\n"
18149  "\n"
18150  ""},
18151  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
18152  "Draw a line\n"
18153  "\n"
18154  "DESCRIPTION:\n"
18155  "\n"
18156  " Draws line defined by n points in x and y.\n"
18157  "\n"
18158  " Redacted form: plline(x, y)\n"
18159  "\n"
18160  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18161  " 25-27, and 29.\n"
18162  "\n"
18163  "\n"
18164  "\n"
18165  "SYNOPSIS:\n"
18166  "\n"
18167  "plline(n, x, y)\n"
18168  "\n"
18169  "ARGUMENTS:\n"
18170  "\n"
18171  " n (PLINT, input) : Number of points defining line.\n"
18172  "\n"
18173  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18174  " points.\n"
18175  "\n"
18176  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18177  " points.\n"
18178  "\n"
18179  ""},
18180  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
18181  "Draw a line in 3 space\n"
18182  "\n"
18183  "DESCRIPTION:\n"
18184  "\n"
18185  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18186  " first set up the viewport, the 2d viewing window (in world\n"
18187  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18188  " more info.\n"
18189  "\n"
18190  " Redacted form: plline3(x, y, z)\n"
18191  "\n"
18192  " This function is used in example 18.\n"
18193  "\n"
18194  "\n"
18195  "\n"
18196  "SYNOPSIS:\n"
18197  "\n"
18198  "plline3(n, x, y, z)\n"
18199  "\n"
18200  "ARGUMENTS:\n"
18201  "\n"
18202  " n (PLINT, input) : Number of points defining line.\n"
18203  "\n"
18204  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18205  " points.\n"
18206  "\n"
18207  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18208  " points.\n"
18209  "\n"
18210  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18211  " points.\n"
18212  "\n"
18213  ""},
18214  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
18215  "Select line style\n"
18216  "\n"
18217  "DESCRIPTION:\n"
18218  "\n"
18219  " This sets the line style according to one of eight predefined patterns\n"
18220  " (also see plstyl).\n"
18221  "\n"
18222  " Redacted form: pllsty(lin)\n"
18223  "\n"
18224  " This function is used in examples 9, 12, 22, and 25.\n"
18225  "\n"
18226  "\n"
18227  "\n"
18228  "SYNOPSIS:\n"
18229  "\n"
18230  "pllsty(lin)\n"
18231  "\n"
18232  "ARGUMENTS:\n"
18233  "\n"
18234  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18235  " a continuous line, line style 2 is a line with short dashes and\n"
18236  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18237  " 4 has long dashes and short gaps and so on.\n"
18238  "\n"
18239  ""},
18240  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
18241  "Plot surface mesh\n"
18242  "\n"
18243  "DESCRIPTION:\n"
18244  "\n"
18245  " Plots a surface mesh within the environment set up by plw3d. The\n"
18246  " surface is defined by the matrix z[\n"
18247  " nx][\n"
18248  " ny] , the point z[i][j] being the value of the function at (\n"
18249  " x[i],\n"
18250  " y[j]). Note that the points in vectors x and y do not need to be\n"
18251  " equally spaced, but must be stored in ascending order. The parameter\n"
18252  " opt controls the way in which the surface is displayed. For further\n"
18253  " details see the PLplot documentation.\n"
18254  "\n"
18255  " Redacted form: plmesh(x, y, z, opt)\n"
18256  "\n"
18257  " This function is used in example 11.\n"
18258  "\n"
18259  "\n"
18260  "\n"
18261  "SYNOPSIS:\n"
18262  "\n"
18263  "plmesh(x, y, z, nx, ny, opt)\n"
18264  "\n"
18265  "ARGUMENTS:\n"
18266  "\n"
18267  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18268  " which the function is evaluated.\n"
18269  "\n"
18270  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18271  " which the function is evaluated.\n"
18272  "\n"
18273  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18274  " plot. Should have dimensions of\n"
18275  " nx by\n"
18276  " ny.\n"
18277  "\n"
18278  " nx (PLINT, input) : Number of x values at which function has been\n"
18279  " evaluated.\n"
18280  "\n"
18281  " ny (PLINT, input) : Number of y values at which function has been\n"
18282  " evaluated.\n"
18283  "\n"
18284  " opt (PLINT, input) : Determines the way in which the surface is\n"
18285  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18286  " function of x for each value of y[j] .\n"
18287  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18288  " for each value of x[i] .\n"
18289  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18290  " at which function is defined.\n"
18291  "\n"
18292  ""},
18293  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
18294  "Magnitude colored plot surface mesh with contour\n"
18295  "\n"
18296  "DESCRIPTION:\n"
18297  "\n"
18298  " A more powerful form of plmesh: the surface mesh can be colored\n"
18299  " accordingly to the current z value being plotted, a contour plot can\n"
18300  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18301  " plotted function border and the base XY plane.\n"
18302  "\n"
18303  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18304  "\n"
18305  " This function is used in example 11.\n"
18306  "\n"
18307  "\n"
18308  "\n"
18309  "SYNOPSIS:\n"
18310  "\n"
18311  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18312  "\n"
18313  "ARGUMENTS:\n"
18314  "\n"
18315  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18316  " which the function is evaluated.\n"
18317  "\n"
18318  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18319  " which the function is evaluated.\n"
18320  "\n"
18321  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18322  " plot. Should have dimensions of\n"
18323  " nx by\n"
18324  " ny.\n"
18325  "\n"
18326  " nx (PLINT, input) : Number of x values at which function is\n"
18327  " evaluated.\n"
18328  "\n"
18329  " ny (PLINT, input) : Number of y values at which function is\n"
18330  " evaluated.\n"
18331  "\n"
18332  " opt (PLINT, input) : Determines the way in which the surface is\n"
18333  " represented. To specify more than one option just add the options,\n"
18334  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18335  " showing z as a function of x for each value of y[j] .\n"
18336  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18337  " for each value of x[i] .\n"
18338  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18339  " at which function is defined.\n"
18340  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18341  " the z value being plotted. The color is used from the current\n"
18342  " cmap1.\n"
18343  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18344  " using parameters\n"
18345  " nlevel and\n"
18346  " clevel.\n"
18347  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18348  " the borders of the plotted function.\n"
18349  "\n"
18350  "\n"
18351  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18352  " levels.\n"
18353  "\n"
18354  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18355  "\n"
18356  ""},
18357  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
18358  "Creates a new stream and makes it the default\n"
18359  "\n"
18360  "DESCRIPTION:\n"
18361  "\n"
18362  " Creates a new stream and makes it the default. Differs from using\n"
18363  " plsstrm, in that a free stream number is found, and returned.\n"
18364  " Unfortunately, I have to start at stream 1 and work upward, since\n"
18365  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18366  " that no initial, library-opening call is required. So stream 0 must\n"
18367  " be preallocated, and there is no simple way of determining whether it\n"
18368  " is already in use or not.\n"
18369  "\n"
18370  " Redacted form: plmkstrm(p_strm)\n"
18371  "\n"
18372  " This function is used in examples 1 and 20.\n"
18373  "\n"
18374  "\n"
18375  "\n"
18376  "SYNOPSIS:\n"
18377  "\n"
18378  "plmkstrm(p_strm)\n"
18379  "\n"
18380  "ARGUMENTS:\n"
18381  "\n"
18382  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18383  " number of the created stream.\n"
18384  "\n"
18385  ""},
18386  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
18387  "Write text relative to viewport boundaries\n"
18388  "\n"
18389  "DESCRIPTION:\n"
18390  "\n"
18391  " Writes text at a specified position relative to the viewport\n"
18392  " boundaries. Text may be written inside or outside the viewport, but\n"
18393  " is clipped at the subpage boundaries. The reference point of a string\n"
18394  " lies along a line passing through the string at half the height of a\n"
18395  " capital letter. The position of the reference point along this line\n"
18396  " is determined by just, and the position of the reference point\n"
18397  " relative to the viewport is set by disp and pos.\n"
18398  "\n"
18399  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18400  " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
18401  "\n"
18402  "\n"
18403  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18404  " 26.\n"
18405  "\n"
18406  "\n"
18407  "\n"
18408  "SYNOPSIS:\n"
18409  "\n"
18410  "plmtex(side, disp, pos, just, text)\n"
18411  "\n"
18412  "ARGUMENTS:\n"
18413  "\n"
18414  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18415  " the side of the viewport along which the text is to be written.\n"
18416  " The string must be one of: b: Bottom of viewport, text written\n"
18417  " parallel to edge.\n"
18418  " bv: Bottom of viewport, text written at right angles to edge.\n"
18419  " l: Left of viewport, text written parallel to edge.\n"
18420  " lv: Left of viewport, text written at right angles to edge.\n"
18421  " r: Right of viewport, text written parallel to edge.\n"
18422  " rv: Right of viewport, text written at right angles to edge.\n"
18423  " t: Top of viewport, text written parallel to edge.\n"
18424  " tv: Top of viewport, text written at right angles to edge.\n"
18425  "\n"
18426  "\n"
18427  " disp (PLFLT, input) : Position of the reference point of string,\n"
18428  " measured outwards from the specified viewport edge in units of the\n"
18429  " current character height. Use negative disp to write within the\n"
18430  " viewport.\n"
18431  "\n"
18432  " pos (PLFLT, input) : Position of the reference point of string\n"
18433  " along the specified edge, expressed as a fraction of the length of\n"
18434  " the edge.\n"
18435  "\n"
18436  " just (PLFLT, input) : Specifies the position of the string relative\n"
18437  " to its reference point. If just=0. , the reference point is at\n"
18438  " the left and if just=1. , it is at the right of the string. Other\n"
18439  " values of just give intermediate justifications.\n"
18440  "\n"
18441  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18442  " written out.\n"
18443  "\n"
18444  ""},
18445  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
18446  "Write text relative to viewport boundaries in 3D plots\n"
18447  "\n"
18448  "DESCRIPTION:\n"
18449  "\n"
18450  " Writes text at a specified position relative to the viewport\n"
18451  " boundaries. Text may be written inside or outside the viewport, but\n"
18452  " is clipped at the subpage boundaries. The reference point of a string\n"
18453  " lies along a line passing through the string at half the height of a\n"
18454  " capital letter. The position of the reference point along this line\n"
18455  " is determined by just, and the position of the reference point\n"
18456  " relative to the viewport is set by disp and pos.\n"
18457  "\n"
18458  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18459  "\n"
18460  " This function is used in example 28.\n"
18461  "\n"
18462  "\n"
18463  "\n"
18464  "SYNOPSIS:\n"
18465  "\n"
18466  "plmtex3(side, disp, pos, just, text)\n"
18467  "\n"
18468  "ARGUMENTS:\n"
18469  "\n"
18470  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18471  " the side of the viewport along which the text is to be written.\n"
18472  " The string should contain one or more of the following characters:\n"
18473  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18474  " only label the X axis, not both the X and Y axes. x: Label the X\n"
18475  " axis.\n"
18476  " y: Label the Y axis.\n"
18477  " z: Label the Z axis.\n"
18478  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18479  " For X it is the axis that starts at y-min. For Y it is the\n"
18480  " axis that starts at x-min.\n"
18481  " s: Label the secondary axis.\n"
18482  " v: Draw the text perpendicular to the axis.\n"
18483  "\n"
18484  "\n"
18485  " disp (PLFLT, input) : Position of the reference point of string,\n"
18486  " measured outwards from the specified viewport edge in units of the\n"
18487  " current character height. Use negative disp to write within the\n"
18488  " viewport.\n"
18489  "\n"
18490  " pos (PLFLT, input) : Position of the reference point of string\n"
18491  " along the specified edge, expressed as a fraction of the length of\n"
18492  " the edge.\n"
18493  "\n"
18494  " just (PLFLT, input) : Specifies the position of the string relative\n"
18495  " to its reference point. If just=0. , the reference point is at\n"
18496  " the left and if just=1. , it is at the right of the string. Other\n"
18497  " values of just give intermediate justifications.\n"
18498  "\n"
18499  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18500  " written out.\n"
18501  "\n"
18502  ""},
18503  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
18504  "Plot 3-d surface plot\n"
18505  "\n"
18506  "DESCRIPTION:\n"
18507  "\n"
18508  " Plots a three-dimensional surface plot within the environment set up\n"
18509  " by plw3d. The surface is defined by the matrix z[\n"
18510  " nx][\n"
18511  " ny] , the point z[i][j] being the value of the function at (\n"
18512  " x[i],\n"
18513  " y[j]). Note that the points in vectors x and y do not need to be\n"
18514  " equally spaced, but must be stored in ascending order. The parameter\n"
18515  " opt controls the way in which the surface is displayed. For further\n"
18516  " details see the PLplot documentation. The only difference between\n"
18517  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18518  " while plot3d only draws the surface as viewed from the top.\n"
18519  "\n"
18520  " Redacted form: plot3d(x, y, z, opt, side)\n"
18521  "\n"
18522  " This function is used in examples 11 and 21.\n"
18523  "\n"
18524  "\n"
18525  "\n"
18526  "SYNOPSIS:\n"
18527  "\n"
18528  "plot3d(x, y, z, nx, ny, opt, side)\n"
18529  "\n"
18530  "ARGUMENTS:\n"
18531  "\n"
18532  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18533  " which the function is evaluated.\n"
18534  "\n"
18535  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18536  " which the function is evaluated.\n"
18537  "\n"
18538  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18539  " plot. Should have dimensions of\n"
18540  " nx by\n"
18541  " ny.\n"
18542  "\n"
18543  " nx (PLINT, input) : Number of x values at which function is\n"
18544  " evaluated.\n"
18545  "\n"
18546  " ny (PLINT, input) : Number of y values at which function is\n"
18547  " evaluated.\n"
18548  "\n"
18549  " opt (PLINT, input) : Determines the way in which the surface is\n"
18550  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18551  " function of x for each value of y[j] .\n"
18552  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18553  " for each value of x[i] .\n"
18554  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18555  " at which function is defined.\n"
18556  "\n"
18557  "\n"
18558  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18559  " should be draw on the figure. If side is true sides are drawn,\n"
18560  " otherwise no sides are drawn.\n"
18561  "\n"
18562  ""},
18563  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18564  "Magnitude colored plot surface with contour\n"
18565  "\n"
18566  "DESCRIPTION:\n"
18567  "\n"
18568  " Aside from dropping the\n"
18569  " side functionality this is a more powerful form of plot3d: the surface\n"
18570  " mesh can be colored accordingly to the current z value being plotted,\n"
18571  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18572  " drawn between the plotted function border and the base XY plane. The\n"
18573  " arguments are identical to those of plmeshc. The only difference\n"
18574  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18575  " the surface, while plot3dc only draws the surface as viewed from the\n"
18576  " top.\n"
18577  "\n"
18578  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18579  " Perl/PDL: Not available?\n"
18580  "\n"
18581  "\n"
18582  " This function is used in example 21.\n"
18583  "\n"
18584  "\n"
18585  "\n"
18586  "SYNOPSIS:\n"
18587  "\n"
18588  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18589  "\n"
18590  "ARGUMENTS:\n"
18591  "\n"
18592  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18593  " which the function is evaluated.\n"
18594  "\n"
18595  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18596  " which the function is evaluated.\n"
18597  "\n"
18598  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18599  " plot. Should have dimensions of\n"
18600  " nx by\n"
18601  " ny.\n"
18602  "\n"
18603  " nx (PLINT, input) : Number of x values at which function is\n"
18604  " evaluated.\n"
18605  "\n"
18606  " ny (PLINT, input) : Number of y values at which function is\n"
18607  " evaluated.\n"
18608  "\n"
18609  " opt (PLINT, input) : Determines the way in which the surface is\n"
18610  " represented. To specify more than one option just add the options,\n"
18611  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18612  " showing z as a function of x for each value of y[j] .\n"
18613  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18614  " for each value of x[i] .\n"
18615  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18616  " at which function is defined.\n"
18617  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18618  " the z value being plotted. The color is used from the current\n"
18619  " cmap1.\n"
18620  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18621  " using parameters\n"
18622  " nlevel and\n"
18623  " clevel.\n"
18624  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18625  " the borders of the plotted function.\n"
18626  "\n"
18627  "\n"
18628  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18629  " levels.\n"
18630  "\n"
18631  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18632  "\n"
18633  ""},
18634  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18635  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18636  "\n"
18637  "DESCRIPTION:\n"
18638  "\n"
18639  " When the implementation is completed this variant of plot3dc (see that\n"
18640  " function's documentation for more details) should be suitable for the\n"
18641  " case where the area of the x, y coordinate grid where z is defined can\n"
18642  " be non-rectangular. The implementation is incomplete so the last 4\n"
18643  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18644  " indexymax; are currently ignored and the functionality is otherwise\n"
18645  " identical to that of plot3dc.\n"
18646  "\n"
18647  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18648  " indexymin, indexymax)\n"
18649  " Perl/PDL: Not available?\n"
18650  "\n"
18651  "\n"
18652  " This function is not used in any example.\n"
18653  "\n"
18654  "\n"
18655  "\n"
18656  "SYNOPSIS:\n"
18657  "\n"
18658  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18659  "\n"
18660  "ARGUMENTS:\n"
18661  "\n"
18662  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18663  " which the function is evaluated.\n"
18664  "\n"
18665  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18666  " which the function is evaluated.\n"
18667  "\n"
18668  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18669  " plot. Should have dimensions of\n"
18670  " nx by\n"
18671  " ny.\n"
18672  "\n"
18673  " nx (PLINT, input) : Number of x values at which the function is\n"
18674  " evaluated.\n"
18675  "\n"
18676  " ny (PLINT, input) : Number of y values at which the function is\n"
18677  " evaluated.\n"
18678  "\n"
18679  " opt (PLINT, input) : Determines the way in which the surface is\n"
18680  " represented. To specify more than one option just add the options,\n"
18681  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18682  " showing z as a function of x for each value of y[j] .\n"
18683  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18684  " for each value of x[i] .\n"
18685  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18686  " at which function is defined.\n"
18687  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18688  " the z value being plotted. The color is used from the current\n"
18689  " cmap1.\n"
18690  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18691  " using parameters\n"
18692  " nlevel and\n"
18693  " clevel.\n"
18694  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18695  " the borders of the plotted function.\n"
18696  "\n"
18697  "\n"
18698  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18699  " levels.\n"
18700  "\n"
18701  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18702  "\n"
18703  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18704  " corresponds to the first x index where z is defined.\n"
18705  "\n"
18706  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18707  " which corresponds (by convention) to one more than the last x\n"
18708  " index value where z is defined.\n"
18709  "\n"
18710  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18711  " values which all must be ≥ 0. These values are the first y index\n"
18712  " where z is defined for a particular x index in the range from\n"
18713  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18714  " indexxmax.\n"
18715  "\n"
18716  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18717  " values which all must be ≤ ny. These values correspond (by\n"
18718  " convention) to one more than the last y index where z is defined\n"
18719  " for a particular x index in the range from indexxmin to indexxmax\n"
18720  " - 1. The dimension of indexymax is indexxmax.\n"
18721  "\n"
18722  ""},
18723  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18724  "Plot shaded 3-d surface plot\n"
18725  "\n"
18726  "DESCRIPTION:\n"
18727  "\n"
18728  " Plots a three-dimensional shaded surface plot within the environment\n"
18729  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18730  " z[\n"
18731  " nx][\n"
18732  " ny], the point z[i][j] being the value of the function at (\n"
18733  " x[i],\n"
18734  " y[j]). Note that the points in vectors x and y do not need to be\n"
18735  " equally spaced, but must be stored in ascending order. For further\n"
18736  " details see the PLplot documentation.\n"
18737  "\n"
18738  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18739  "\n"
18740  " This function is not used in any examples.\n"
18741  "\n"
18742  "\n"
18743  "\n"
18744  "SYNOPSIS:\n"
18745  "\n"
18746  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18747  "\n"
18748  "ARGUMENTS:\n"
18749  "\n"
18750  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18751  " which the function is evaluated.\n"
18752  "\n"
18753  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18754  " which the function is evaluated.\n"
18755  "\n"
18756  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18757  " plot. Should have dimensions of\n"
18758  " nx by\n"
18759  " ny.\n"
18760  "\n"
18761  " nx (PLINT, input) : Number of x values at which function is\n"
18762  " evaluated.\n"
18763  "\n"
18764  " ny (PLINT, input) : Number of y values at which function is\n"
18765  " evaluated.\n"
18766  "\n"
18767  " opt (PLINT, input) : Determines the way in which the surface is\n"
18768  " represented. To specify more than one option just add the options,\n"
18769  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18770  " connecting points at which function is defined.\n"
18771  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18772  " using parameters\n"
18773  " nlevel and\n"
18774  " clevel.\n"
18775  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18776  " using parameters\n"
18777  " nlevel and\n"
18778  " clevel.\n"
18779  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18780  " the borders of the plotted function.\n"
18781  " opt=MAG_COLOR : the surface is colored according to the value\n"
18782  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18783  " according to the intensity of the reflected light in the\n"
18784  " surface from a light source whose position is set using\n"
18785  " pllightsource.\n"
18786  "\n"
18787  "\n"
18788  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18789  " levels.\n"
18790  "\n"
18791  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18792  "\n"
18793  ""},
18794  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18795  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18796  "\n"
18797  "DESCRIPTION:\n"
18798  "\n"
18799  " This variant of plsurf3d (see that function's documentation for more\n"
18800  " details) should be suitable for the case where the area of the x, y\n"
18801  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18802  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18803  " indexymin, and indexymax.\n"
18804  "\n"
18805  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18806  " indexymax)\n"
18807  "\n"
18808  " This function is used in example 8.\n"
18809  "\n"
18810  "\n"
18811  "\n"
18812  "SYNOPSIS:\n"
18813  "\n"
18814  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18815  "\n"
18816  "ARGUMENTS:\n"
18817  "\n"
18818  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18819  " which the function is evaluated.\n"
18820  "\n"
18821  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18822  " which the function is evaluated.\n"
18823  "\n"
18824  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18825  " plot. Should have dimensions of\n"
18826  " nx by\n"
18827  " ny.\n"
18828  "\n"
18829  " nx (PLINT, input) : Number of x values at which function is\n"
18830  " evaluated.\n"
18831  "\n"
18832  " ny (PLINT, input) : Number of y values at which function is\n"
18833  " evaluated.\n"
18834  "\n"
18835  " opt (PLINT, input) : Determines the way in which the surface is\n"
18836  " represented. To specify more than one option just add the options,\n"
18837  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18838  " connecting points at which function is defined.\n"
18839  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18840  " using parameters\n"
18841  " nlevel and\n"
18842  " clevel.\n"
18843  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18844  " using parameters\n"
18845  " nlevel and\n"
18846  " clevel.\n"
18847  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18848  " the borders of the plotted function.\n"
18849  " opt=MAG_COLOR : the surface is colored according to the value\n"
18850  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18851  " according to the intensity of the reflected light in the\n"
18852  " surface from a light source whose position is set using\n"
18853  " pllightsource.\n"
18854  "\n"
18855  "\n"
18856  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18857  " levels.\n"
18858  "\n"
18859  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18860  "\n"
18861  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18862  " corresponds to the first x index where z is defined.\n"
18863  "\n"
18864  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18865  " which corresponds (by convention) to one more than the last x\n"
18866  " index value where z is defined.\n"
18867  "\n"
18868  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18869  " values which all must be ≥ 0. These values are the first y index\n"
18870  " where z is defined for a particular x index in the range from\n"
18871  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18872  " indexxmax.\n"
18873  "\n"
18874  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18875  " values which all must be ≤ ny. These values correspond (by\n"
18876  " convention) to one more than the last y index where z is defined\n"
18877  " for a particular x index in the range from indexxmin to indexxmax\n"
18878  " - 1. The dimension of indexymax is indexxmax.\n"
18879  "\n"
18880  ""},
18881  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
18882  "Parse command-line arguments\n"
18883  "\n"
18884  "DESCRIPTION:\n"
18885  "\n"
18886  " Parse command-line arguments.\n"
18887  "\n"
18888  " plparseopts removes all recognized flags (decreasing argc\n"
18889  " accordingly), so that invalid input may be readily detected. It can\n"
18890  " also be used to process user command line flags. The user can merge\n"
18891  " an option table of type PLOptionTable into the internal option table\n"
18892  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18893  " the external table(s) be parsed by calling plClearOpts before\n"
18894  " plMergeOpts.\n"
18895  "\n"
18896  " The default action taken by plparseopts is as follows:\n"
18897  " Returns with an error if an unrecognized option or badly formed\n"
18898  " option-value pair are encountered. \n"
18899  " Returns immediately (return code 0) when the first non-option command\n"
18900  " line argument is found.\n"
18901  " Returns with the return code of the option handler, if one was called.\n"
18902  "\n"
18903  " Deletes command line arguments from argv list as they are found, and\n"
18904  " decrements argc accordingly.\n"
18905  " Does not show \"invisible\" options in usage or help messages.\n"
18906  " Assumes the program name is contained in argv[0].\n"
18907  "\n"
18908  " These behaviors may be controlled through the\n"
18909  " mode argument.\n"
18910  "\n"
18911  " Redacted form: General: plparseopts(argv, mode)\n"
18912  " Perl/PDL: Not available?\n"
18913  "\n"
18914  "\n"
18915  " This function is used in all of the examples.\n"
18916  "\n"
18917  "\n"
18918  "\n"
18919  "SYNOPSIS:\n"
18920  "\n"
18921  "PLINT plparseopts(p_argc, argv, mode)\n"
18922  "\n"
18923  "ARGUMENTS:\n"
18924  "\n"
18925  " p_argc (int *, input/output) : Number of arguments.\n"
18926  "\n"
18927  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18928  " strings containing *p_argc command-line arguments.\n"
18929  "\n"
18930  " mode (PLINT, input) : Parsing mode with the following\n"
18931  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18932  " and all error messages enabled, including program exit when an\n"
18933  " error occurs. Anything on the command line that isn't recognized\n"
18934  " as a valid option or option argument is flagged as an error.\n"
18935  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18936  " of errors.\n"
18937  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18938  " arguments.\n"
18939  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18940  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18941  " pointer to the program name.\n"
18942  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18943  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18944  " unrecognized arguments.\n"
18945  "\n"
18946  ""},
18947  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
18948  "Set area line fill pattern\n"
18949  "\n"
18950  "DESCRIPTION:\n"
18951  "\n"
18952  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18953  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18954  " inclinations and spacings. The arguments to this routine are the\n"
18955  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18956  " elements) specifying the inclinations in tenths of a degree and the\n"
18957  " spacing in micrometers. (See also plpsty)\n"
18958  "\n"
18959  " Redacted form: General: plpat(inc, del)\n"
18960  " Perl/PDL: plpat(nlin, inc, del)\n"
18961  "\n"
18962  "\n"
18963  " This function is used in example 15.\n"
18964  "\n"
18965  "\n"
18966  "\n"
18967  "SYNOPSIS:\n"
18968  "\n"
18969  "plpat(nlin, inc, del)\n"
18970  "\n"
18971  "ARGUMENTS:\n"
18972  "\n"
18973  " nlin (PLINT, input) : Number of sets of lines making up the\n"
18974  " pattern, either 1 or 2.\n"
18975  "\n"
18976  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18977  " inclination in tenths of a degree. (Should be between -900 and\n"
18978  " 900).\n"
18979  "\n"
18980  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18981  " spacing in micrometers between the lines making up the pattern.\n"
18982  "\n"
18983  ""},
18984  { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
18985  "Draw a line between two points, accounting for coordinate transforms\n"
18986  "\n"
18987  "DESCRIPTION:\n"
18988  "\n"
18989  " Joins the point (\n"
18990  " x1,\n"
18991  " y1) to (\n"
18992  " x2,\n"
18993  " y2) . If a global coordinate transform is defined then the line is\n"
18994  " broken in to n segments to approximate the path. If no transform is\n"
18995  " defined then this simply acts like a call to pljoin.\n"
18996  "\n"
18997  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18998  "\n"
18999  " This function is used in example 22.\n"
19000  "\n"
19001  "\n"
19002  "\n"
19003  "SYNOPSIS:\n"
19004  "\n"
19005  "plpath(n, x1, y1, x2, y2)\n"
19006  "\n"
19007  "ARGUMENTS:\n"
19008  "\n"
19009  " n (PLINT, input) : number of points to use to approximate the path.\n"
19010  "\n"
19011  " x1 (PLFLT, input) : x coordinate of first point.\n"
19012  "\n"
19013  " y1 (PLFLT, input) : y coordinate of first point.\n"
19014  "\n"
19015  " x2 (PLFLT, input) : x coordinate of second point.\n"
19016  "\n"
19017  " y2 (PLFLT, input) : y coordinate of second point.\n"
19018  "\n"
19019  ""},
19020  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
19021  "Plot a glyph at the specified points\n"
19022  "\n"
19023  "DESCRIPTION:\n"
19024  "\n"
19025  " Plot a glyph at the specified points. (This function is largely\n"
19026  " superseded by plstring which gives access to many[!] more glyphs.)\n"
19027  " code=-1 means try to just draw a point. Right now it's just a move\n"
19028  " and a draw at the same place. Not ideal, since a sufficiently\n"
19029  " intelligent output device may optimize it away, or there may be faster\n"
19030  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19031  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19032  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19033  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19034  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19035  "\n"
19036  " Redacted form: plpoin(x, y, code)\n"
19037  "\n"
19038  " This function is used in examples 1, 6, 14, and 29.\n"
19039  "\n"
19040  "\n"
19041  "\n"
19042  "SYNOPSIS:\n"
19043  "\n"
19044  "plpoin(n, x, y, code)\n"
19045  "\n"
19046  "ARGUMENTS:\n"
19047  "\n"
19048  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19049  "\n"
19050  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19051  " points.\n"
19052  "\n"
19053  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19054  " points.\n"
19055  "\n"
19056  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19057  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19058  " each of the n points.\n"
19059  "\n"
19060  ""},
19061  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
19062  "Plot a glyph at the specified 3D points\n"
19063  "\n"
19064  "DESCRIPTION:\n"
19065  "\n"
19066  " Plot a glyph at the specified 3D points. (This function is largely\n"
19067  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19068  " Set up the call to this function similar to what is done for plline3.\n"
19069  " code=-1 means try to just draw a point. Right now it's just a move\n"
19070  " and a draw at the same place. Not ideal, since a sufficiently\n"
19071  " intelligent output device may optimize it away, or there may be faster\n"
19072  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19073  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19074  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19075  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19076  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19077  "\n"
19078  " Redacted form: plpoin3(x, y, z, code)\n"
19079  "\n"
19080  " This function is not used in any example.\n"
19081  "\n"
19082  "\n"
19083  "\n"
19084  "SYNOPSIS:\n"
19085  "\n"
19086  "plpoin3(n, x, y, z, code)\n"
19087  "\n"
19088  "ARGUMENTS:\n"
19089  "\n"
19090  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19091  "\n"
19092  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19093  " points.\n"
19094  "\n"
19095  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19096  " points.\n"
19097  "\n"
19098  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19099  " points.\n"
19100  "\n"
19101  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19102  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19103  " each of the n points.\n"
19104  "\n"
19105  ""},
19106  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
19107  "Draw a polygon in 3 space\n"
19108  "\n"
19109  "DESCRIPTION:\n"
19110  "\n"
19111  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19112  " like plline3, but differs from that function in that plpoly3 attempts\n"
19113  " to determine if the polygon is viewable depending on the order of the\n"
19114  " points within the vector and the value of ifcc. If the back of\n"
19115  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19116  " you want, then use plline3 instead.\n"
19117  "\n"
19118  " The points are assumed to be in a plane, and the directionality of the\n"
19119  " plane is determined from the first three points. Additional points do\n"
19120  " not have to lie on the plane defined by the first three, but if they\n"
19121  " do not, then the determination of visibility obviously can't be 100%\n"
19122  " accurate... So if you're 3 space polygons are too far from planar,\n"
19123  " consider breaking them into smaller polygons. 3 points define a plane\n"
19124  " :-).\n"
19125  "\n"
19126  " Bugs: If one of the first two segments is of zero length, or if they\n"
19127  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19128  " being correct. Avoid such situations :-). See x18c.c for an example\n"
19129  " of this problem. (Search for 20.1).\n"
19130  "\n"
19131  " Redacted form: plpoly3(x, y, z, code)\n"
19132  "\n"
19133  " This function is used in example 18.\n"
19134  "\n"
19135  "\n"
19136  "\n"
19137  "SYNOPSIS:\n"
19138  "\n"
19139  "plpoly3(n, x, y, z, draw, ifcc)\n"
19140  "\n"
19141  "ARGUMENTS:\n"
19142  "\n"
19143  " n (PLINT, input) : Number of points defining line.\n"
19144  "\n"
19145  " x (PLFLT_VECTOR, input) : A vector containing\n"
19146  " n x coordinates of points.\n"
19147  "\n"
19148  " y (PLFLT_VECTOR, input) : A vector containing\n"
19149  " n y coordinates of points.\n"
19150  "\n"
19151  " z (PLFLT_VECTOR, input) : A vector containing\n"
19152  " n z coordinates of points.\n"
19153  "\n"
19154  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19155  " n-1 Boolean values which control drawing the segments of the polygon.\n"
19156  " If draw[i] is true, then the polygon segment from index [i] to\n"
19157  " [i+1] is drawn, otherwise, not.\n"
19158  "\n"
19159  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19160  " polygon is determined by assuming the points are laid out in a\n"
19161  " counter-clockwise order. Otherwise, the directionality of the\n"
19162  " polygon is determined by assuming the points are laid out in a\n"
19163  " clockwise order.\n"
19164  "\n"
19165  ""},
19166  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
19167  "Set precision in numeric labels\n"
19168  "\n"
19169  "DESCRIPTION:\n"
19170  "\n"
19171  " Sets the number of places after the decimal point in numeric labels.\n"
19172  "\n"
19173  " Redacted form: plprec(setp, prec)\n"
19174  "\n"
19175  " This function is used in example 29.\n"
19176  "\n"
19177  "\n"
19178  "\n"
19179  "SYNOPSIS:\n"
19180  "\n"
19181  "plprec(setp, prec)\n"
19182  "\n"
19183  "ARGUMENTS:\n"
19184  "\n"
19185  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19186  " automatically determines the number of places to use after the\n"
19187  " decimal point in numeric labels (like those used to label axes).\n"
19188  " If setp is 1 then prec sets the number of places.\n"
19189  "\n"
19190  " prec (PLINT, input) : The number of characters to draw after the\n"
19191  " decimal point in numeric labels.\n"
19192  "\n"
19193  ""},
19194  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
19195  "Select area fill pattern\n"
19196  "\n"
19197  "DESCRIPTION:\n"
19198  "\n"
19199  " If\n"
19200  " patt is zero or less use either a hardware solid fill if the drivers\n"
19201  " have that capability (virtually all do) or fall back to a software\n"
19202  " emulation of a solid fill using the eighth area line fill pattern. If\n"
19203  " 0 <\n"
19204  " patt <= 8, then select one of eight predefined area line fill patterns\n"
19205  " to use (see plpat if you desire other patterns).\n"
19206  "\n"
19207  " Redacted form: plpsty(patt)\n"
19208  "\n"
19209  " This function is used in examples 12, 13, 15, 16, and 25.\n"
19210  "\n"
19211  "\n"
19212  "\n"
19213  "SYNOPSIS:\n"
19214  "\n"
19215  "plpsty(patt)\n"
19216  "\n"
19217  "ARGUMENTS:\n"
19218  "\n"
19219  " patt (PLINT, input) : The desired pattern index. If\n"
19220  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19221  " above) used. For\n"
19222  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19223  " line fill capability itself (most deliberately do not so that line\n"
19224  " fill patterns look identical for those drivers), the patterns\n"
19225  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19226  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19227  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19228  " (8) lines at both 45 degrees and -45 degrees.\n"
19229  "\n"
19230  ""},
19231  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
19232  "Write text inside the viewport\n"
19233  "\n"
19234  "DESCRIPTION:\n"
19235  "\n"
19236  " Writes text at a specified position and inclination within the\n"
19237  " viewport. Text is clipped at the viewport boundaries. The reference\n"
19238  " point of a string lies along a line passing through the string at half\n"
19239  " the height of a capital letter. The position of the reference point\n"
19240  " along this line is determined by just, the reference point is placed\n"
19241  " at world coordinates (\n"
19242  " x,\n"
19243  " y) within the viewport. The inclination of the string is specified\n"
19244  " in terms of differences of world coordinates making it easy to write\n"
19245  " text parallel to a line in a graph.\n"
19246  "\n"
19247  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19248  "\n"
19249  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19250  "\n"
19251  "\n"
19252  "\n"
19253  "SYNOPSIS:\n"
19254  "\n"
19255  "plptex(x, y, dx, dy, just, text)\n"
19256  "\n"
19257  "ARGUMENTS:\n"
19258  "\n"
19259  " x (PLFLT, input) : x coordinate of reference point of string.\n"
19260  "\n"
19261  " y (PLFLT, input) : y coordinate of reference point of string.\n"
19262  "\n"
19263  " dx (PLFLT, input) : Together with dy, this specifies the\n"
19264  " inclination of the string. The baseline of the string is parallel\n"
19265  " to a line joining (\n"
19266  " x,\n"
19267  " y) to (\n"
19268  " x+\n"
19269  " dx,\n"
19270  " y+\n"
19271  " dy) .\n"
19272  "\n"
19273  " dy (PLFLT, input) : Together with dx, this specifies the\n"
19274  " inclination of the string.\n"
19275  "\n"
19276  " just (PLFLT, input) : Specifies the position of the string relative\n"
19277  " to its reference point. If just=0. , the reference point is at\n"
19278  " the left and if just=1. , it is at the right of the string. Other\n"
19279  " values of just give intermediate justifications.\n"
19280  "\n"
19281  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19282  " written out.\n"
19283  "\n"
19284  ""},
19285  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
19286  "Write text inside the viewport of a 3D plot\n"
19287  "\n"
19288  "DESCRIPTION:\n"
19289  "\n"
19290  " Writes text at a specified position and inclination and with a\n"
19291  " specified shear within the viewport. Text is clipped at the viewport\n"
19292  " boundaries. The reference point of a string lies along a line passing\n"
19293  " through the string at half the height of a capital letter. The\n"
19294  " position of the reference point along this line is determined by just,\n"
19295  " and the reference point is placed at world coordinates (\n"
19296  " wx,\n"
19297  " wy,\n"
19298  " wz) within the viewport. The inclination and shear of the string is\n"
19299  " specified in terms of differences of world coordinates making it easy\n"
19300  " to write text parallel to a line in a graph.\n"
19301  "\n"
19302  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19303  "\n"
19304  " This function is used in example 28.\n"
19305  "\n"
19306  "\n"
19307  "\n"
19308  "SYNOPSIS:\n"
19309  "\n"
19310  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19311  "\n"
19312  "ARGUMENTS:\n"
19313  "\n"
19314  " wx (PLFLT, input) : x world coordinate of reference point of\n"
19315  " string.\n"
19316  "\n"
19317  " wy (PLFLT, input) : y world coordinate of reference point of\n"
19318  " string.\n"
19319  "\n"
19320  " wz (PLFLT, input) : z world coordinate of reference point of\n"
19321  " string.\n"
19322  "\n"
19323  " dx (PLFLT, input) : Together with dy and\n"
19324  " dz , this specifies the inclination of the string. The baseline of\n"
19325  " the string is parallel to a line joining (\n"
19326  " x,\n"
19327  " y,\n"
19328  " z) to (\n"
19329  " x+\n"
19330  " dx,\n"
19331  " y+\n"
19332  " dy,\n"
19333  " z+\n"
19334  " dz) .\n"
19335  "\n"
19336  " dy (PLFLT, input) : Together with dx and\n"
19337  " dz, this specifies the inclination of the string.\n"
19338  "\n"
19339  " dz (PLFLT, input) : Together with dx and\n"
19340  " dy, this specifies the inclination of the string.\n"
19341  "\n"
19342  " sx (PLFLT, input) : Together with sy and\n"
19343  " sz , this specifies the shear of the string. The string is sheared so\n"
19344  " that the characters are vertically parallel to a line joining (\n"
19345  " x,\n"
19346  " y,\n"
19347  " z) to (\n"
19348  " x+\n"
19349  " sx,\n"
19350  " y+\n"
19351  " sy,\n"
19352  " z+\n"
19353  " sz) . If sx =\n"
19354  " sy =\n"
19355  " sz = 0.) then the text is not sheared.\n"
19356  "\n"
19357  " sy (PLFLT, input) : Together with sx and\n"
19358  " sz, this specifies shear of the string.\n"
19359  "\n"
19360  " sz (PLFLT, input) : Together with sx and\n"
19361  " sy, this specifies shear of the string.\n"
19362  "\n"
19363  " just (PLFLT, input) : Specifies the position of the string relative\n"
19364  " to its reference point. If just=0. , the reference point is at\n"
19365  " the left and if just=1. , it is at the right of the string. Other\n"
19366  " values of just give intermediate justifications.\n"
19367  "\n"
19368  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19369  " written out.\n"
19370  "\n"
19371  ""},
19372  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
19373  "Random number generator returning a real random number in the range [0,1]\n"
19374  "\n"
19375  "DESCRIPTION:\n"
19376  "\n"
19377  " Random number generator returning a real random number in the range\n"
19378  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19379  " / compilers provide their own random number generator, and so this is\n"
19380  " provided purely for convenience and to give a consistent random number\n"
19381  " generator across all languages supported by PLplot. This is\n"
19382  " particularly useful for comparing results from the test suite of\n"
19383  " examples.\n"
19384  "\n"
19385  " Redacted form: plrandd()\n"
19386  "\n"
19387  " This function is used in examples 17 and 21.\n"
19388  "\n"
19389  "\n"
19390  "\n"
19391  "SYNOPSIS:\n"
19392  "\n"
19393  "plrandd()\n"
19394  "\n"
19395  ""},
19396  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
19397  "Replays contents of plot buffer to current device/file\n"
19398  "\n"
19399  "DESCRIPTION:\n"
19400  "\n"
19401  " Replays contents of plot buffer to current device/file.\n"
19402  "\n"
19403  " Redacted form: plreplot()\n"
19404  "\n"
19405  " This function is used in example 1,20.\n"
19406  "\n"
19407  "\n"
19408  "\n"
19409  "SYNOPSIS:\n"
19410  "\n"
19411  "plreplot()\n"
19412  "\n"
19413  ""},
19414  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
19415  "Convert RGB color to HLS\n"
19416  "\n"
19417  "DESCRIPTION:\n"
19418  "\n"
19419  " Convert RGB color coordinates to HLS\n"
19420  "\n"
19421  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19422  " Perl/PDL: Not available? Implemented as plrgb/plrgb1?\n"
19423  "\n"
19424  "\n"
19425  " This function is used in example 2.\n"
19426  "\n"
19427  "\n"
19428  "\n"
19429  "SYNOPSIS:\n"
19430  "\n"
19431  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19432  "\n"
19433  "ARGUMENTS:\n"
19434  "\n"
19435  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19436  "\n"
19437  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19438  "\n"
19439  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19440  "\n"
19441  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19442  " degrees (0.0-360.0) on the color cylinder.\n"
19443  "\n"
19444  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19445  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19446  " cylinder.\n"
19447  "\n"
19448  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19449  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19450  " cylinder.\n"
19451  "\n"
19452  ""},
19453  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
19454  "Set character size\n"
19455  "\n"
19456  "DESCRIPTION:\n"
19457  "\n"
19458  " This sets up the size of all subsequent characters drawn. The actual\n"
19459  " height of a character is the product of the default character size and\n"
19460  " a scaling factor.\n"
19461  "\n"
19462  " Redacted form: plschr(def, scale)\n"
19463  "\n"
19464  " This function is used in examples 2, 13, 23, and 24.\n"
19465  "\n"
19466  "\n"
19467  "\n"
19468  "SYNOPSIS:\n"
19469  "\n"
19470  "plschr(def, scale)\n"
19471  "\n"
19472  "ARGUMENTS:\n"
19473  "\n"
19474  " def (PLFLT, input) : The default height of a character in\n"
19475  " millimeters, should be set to zero if the default height is to\n"
19476  " remain unchanged. For rasterized drivers the dx and dy values\n"
19477  " specified in plspage are used to convert from mm to pixels (note\n"
19478  " the different unit systems used). This dpi aware scaling is not\n"
19479  " implemented for all drivers yet.\n"
19480  "\n"
19481  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19482  " actual character height.\n"
19483  "\n"
19484  ""},
19485  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
19486  "Set cmap0 colors by 8-bit RGB values\n"
19487  "\n"
19488  "DESCRIPTION:\n"
19489  "\n"
19490  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19491  " documentation). This sets the entire color map -- only as many colors\n"
19492  " as specified will be allocated.\n"
19493  "\n"
19494  " Redacted form: plscmap0(r, g, b)\n"
19495  "\n"
19496  " This function is used in examples 2 and 24.\n"
19497  "\n"
19498  "\n"
19499  "\n"
19500  "SYNOPSIS:\n"
19501  "\n"
19502  "plscmap0(r, g, b, ncol0)\n"
19503  "\n"
19504  "ARGUMENTS:\n"
19505  "\n"
19506  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19507  " integers (0-255) representing the degree of red in the color.\n"
19508  "\n"
19509  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19510  " integers (0-255) representing the degree of green in the color.\n"
19511  "\n"
19512  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19513  " integers (0-255) representing the degree of blue in the color.\n"
19514  "\n"
19515  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19516  "\n"
19517  ""},
19518  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
19519  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19520  "\n"
19521  "DESCRIPTION:\n"
19522  "\n"
19523  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19524  " and PLFLT alpha transparency value. This sets the entire color map --\n"
19525  " only as many colors as specified will be allocated.\n"
19526  "\n"
19527  " Redacted form: plscmap0a(r, g, b, alpha)\n"
19528  "\n"
19529  " This function is used in examples 30.\n"
19530  "\n"
19531  "\n"
19532  "\n"
19533  "SYNOPSIS:\n"
19534  "\n"
19535  "plscmap0a(r, g, b, alpha, ncol0)\n"
19536  "\n"
19537  "ARGUMENTS:\n"
19538  "\n"
19539  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19540  " integers (0-255) representing the degree of red in the color.\n"
19541  "\n"
19542  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19543  " integers (0-255) representing the degree of green in the color.\n"
19544  "\n"
19545  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19546  " integers (0-255) representing the degree of blue in the color.\n"
19547  "\n"
19548  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19549  " representing the alpha transparency of the color.\n"
19550  "\n"
19551  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19552  " vectors.\n"
19553  "\n"
19554  ""},
19555  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
19556  "Set number of colors in cmap0\n"
19557  "\n"
19558  "DESCRIPTION:\n"
19559  "\n"
19560  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19561  " (or reallocate) cmap0, and fill with default values for those colors\n"
19562  " not previously allocated. The first 16 default colors are given in\n"
19563  " the plcol0 documentation. For larger indices the default color is\n"
19564  " red.\n"
19565  "\n"
19566  " The drivers are not guaranteed to support more than 16 colors.\n"
19567  "\n"
19568  " Redacted form: plscmap0n(ncol0)\n"
19569  "\n"
19570  " This function is used in examples 15, 16, and 24.\n"
19571  "\n"
19572  "\n"
19573  "\n"
19574  "SYNOPSIS:\n"
19575  "\n"
19576  "plscmap0n(ncol0)\n"
19577  "\n"
19578  "ARGUMENTS:\n"
19579  "\n"
19580  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19581  " the cmap0 palette. If this number is zero or less, then the value\n"
19582  " from the previous call to plscmap0n is used and if there is no\n"
19583  " previous call, then a default value is used.\n"
19584  "\n"
19585  ""},
19586  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19587  "Set opaque RGB cmap1 colors values\n"
19588  "\n"
19589  "DESCRIPTION:\n"
19590  "\n"
19591  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19592  " vector values. This function also sets the number of cmap1 colors.\n"
19593  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19594  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19595  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19596  " to\n"
19597  " ncol1-1. So in order for this continuous color model to work\n"
19598  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19599  " that these RGB vectors are continuous functions of their integer\n"
19600  " indices.\n"
19601  "\n"
19602  " Redacted form: plscmap1(r, g, b)\n"
19603  "\n"
19604  " This function is used in example 31.\n"
19605  "\n"
19606  "\n"
19607  "\n"
19608  "SYNOPSIS:\n"
19609  "\n"
19610  "plscmap1(r, g, b, ncol1)\n"
19611  "\n"
19612  "ARGUMENTS:\n"
19613  "\n"
19614  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19615  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19616  " color as a continuous function of the integer index of the vector.\n"
19617  "\n"
19618  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19619  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19620  " color as a continuous function of the integer index of the vector.\n"
19621  "\n"
19622  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19623  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19624  " color as a continuous function of the integer index of the vector.\n"
19625  "\n"
19626  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19627  "\n"
19628  ""},
19629  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19630  "Set semitransparent cmap1 RGBA colors.\n"
19631  "\n"
19632  "DESCRIPTION:\n"
19633  "\n"
19634  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19635  " RGBA vector values. This function also sets the number of cmap1\n"
19636  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19637  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19638  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19639  " vectors in the range from 0 to\n"
19640  " ncol1-1. So in order for this continuous color model to work\n"
19641  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19642  " that these RGBA vectors are continuous functions of their integer\n"
19643  " indices.\n"
19644  "\n"
19645  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19646  "\n"
19647  " This function is used in example 31.\n"
19648  "\n"
19649  "\n"
19650  "\n"
19651  "SYNOPSIS:\n"
19652  "\n"
19653  "plscmap1a(r, g, b, alpha, ncol1)\n"
19654  "\n"
19655  "ARGUMENTS:\n"
19656  "\n"
19657  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19658  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19659  " color as a continuous function of the integer index of the vector.\n"
19660  "\n"
19661  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19662  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19663  " color as a continuous function of the integer index of the vector.\n"
19664  "\n"
19665  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19666  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19667  " color as a continuous function of the integer index of the vector.\n"
19668  "\n"
19669  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19670  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19671  " completely transparent and 1.0 corresponds to completely opaque)\n"
19672  " the alpha transparency of the color as a continuous function of\n"
19673  " the integer index of the vector.\n"
19674  "\n"
19675  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19676  " vectors.\n"
19677  "\n"
19678  ""},
19679  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19680  "Set cmap1 colors using a piece-wise linear relationship\n"
19681  "\n"
19682  "DESCRIPTION:\n"
19683  "\n"
19684  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19685  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19686  " (see the PLplot documentation). May be called at any time.\n"
19687  "\n"
19688  " The idea here is to specify a number of control points that define the\n"
19689  " mapping between input cmap1 intensity indices and HLS (or RGB).\n"
19690  " Between these points, linear interpolation is used which gives a\n"
19691  " smooth variation of color with intensity index. Any number of control\n"
19692  " points may be specified, located at arbitrary positions, although\n"
19693  " typically 2 - 4 are enough. Another way of stating this is that we are\n"
19694  " traversing a given number of lines through HLS (or RGB) space as we\n"
19695  " move through cmap1 intensity indices. The control points at the\n"
19696  " minimum and maximum position (0 and 1) must always be specified. By\n"
19697  " adding more control points you can get more variation. One good\n"
19698  " technique for plotting functions that vary about some expected average\n"
19699  " is to use an additional 2 control points in the center (position ~=\n"
19700  " 0.5) that are the same lightness as the background (typically white\n"
19701  " for paper output, black for crt), and same hue as the boundary control\n"
19702  " points. This allows the highs and lows to be very easily\n"
19703  " distinguished.\n"
19704  "\n"
19705  " Each control point must specify the cmap1 intensity index and the\n"
19706  " associated three coordinates in HLS or RGB space. The first point\n"
19707  " must correspond to position = 0, and the last to position = 1.\n"
19708  "\n"
19709  " The default behaviour is for the hue to be linearly interpolated\n"
19710  " between the control points. Since the hue lies in the range [0, 360]\n"
19711  " this corresponds to interpolation around the \"front\" of the color\n"
19712  " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19713  " alternative interpolation is used between control points i and i+1. If\n"
19714  " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n"
19715  " - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n"
19716  " this as interpolation around the \"back\" or \"reverse\" of the color\n"
19717  " wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19718  " alt_hue_path[] = false for every control point.\n"
19719  "\n"
19720  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19721  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19722  " 240]truegreen-yellow-red-magenta-blue[240\n"
19723  " 120]trueblue-magenta-red-yellow-green\n"
19724  "\n"
19725  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19726  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19727  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19728  "\n"
19729  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19730  " alt_hue_path)\n"
19731  "\n"
19732  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19733  "\n"
19734  "\n"
19735  "\n"
19736  "SYNOPSIS:\n"
19737  "\n"
19738  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19739  "\n"
19740  "ARGUMENTS:\n"
19741  "\n"
19742  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19743  "\n"
19744  " npts (PLINT, input) : number of control points\n"
19745  "\n"
19746  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19747  " intensity index (0.0-1.0) in ascending order for each control\n"
19748  " point.\n"
19749  "\n"
19750  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19751  " coordinate (H or R) for each control point.\n"
19752  "\n"
19753  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19754  " coordinate (L or G) for each control point.\n"
19755  "\n"
19756  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19757  " coordinate (S or B) for each control point.\n"
19758  "\n"
19759  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19760  " npts - 1 elements) containing the alternative interpolation method\n"
19761  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19762  " refers to the interpolation interval between the i and i + 1\n"
19763  " control points).\n"
19764  "\n"
19765  ""},
19766  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19767  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19768  "\n"
19769  "DESCRIPTION:\n"
19770  "\n"
19771  " This is a variant of plscmap1l that supports alpha channel\n"
19772  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19773  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19774  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19775  " transparency value (0.0-1.0). It may be called at any time.\n"
19776  "\n"
19777  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19778  " alpha, alt_hue_path)\n"
19779  "\n"
19780  " This function is used in example 30.\n"
19781  "\n"
19782  "\n"
19783  "\n"
19784  "SYNOPSIS:\n"
19785  "\n"
19786  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19787  "\n"
19788  "ARGUMENTS:\n"
19789  "\n"
19790  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19791  "\n"
19792  " npts (PLINT, input) : number of control points.\n"
19793  "\n"
19794  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19795  " intensity index (0.0-1.0) in ascending order for each control\n"
19796  " point.\n"
19797  "\n"
19798  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19799  " coordinate (H or R) for each control point.\n"
19800  "\n"
19801  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19802  " coordinate (L or G) for each control point.\n"
19803  "\n"
19804  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19805  " coordinate (S or B) for each control point.\n"
19806  "\n"
19807  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19808  " transparency value (0.0-1.0) for each control point.\n"
19809  "\n"
19810  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19811  " npts - 1 elements) containing the alternative interpolation method\n"
19812  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19813  " refers to the interpolation interval between the i and i + 1\n"
19814  " control points).\n"
19815  "\n"
19816  ""},
19817  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19818  "Set number of colors in cmap1\n"
19819  "\n"
19820  "DESCRIPTION:\n"
19821  "\n"
19822  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19823  " values if this is the first allocation (see the PLplot documentation).\n"
19824  "\n"
19825  " Redacted form: plscmap1n(ncol1)\n"
19826  "\n"
19827  " This function is used in examples 8, 11, 20, and 21.\n"
19828  "\n"
19829  "\n"
19830  "\n"
19831  "SYNOPSIS:\n"
19832  "\n"
19833  "plscmap1n(ncol1)\n"
19834  "\n"
19835  "ARGUMENTS:\n"
19836  "\n"
19837  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19838  " the cmap1 palette. If this number is zero or less, then the value\n"
19839  " from the previous call to plscmap1n is used and if there is no\n"
19840  " previous call, then a default value is used.\n"
19841  "\n"
19842  ""},
19843  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
19844  "Set the cmap1 argument range for continuous color plots\n"
19845  "\n"
19846  "DESCRIPTION:\n"
19847  "\n"
19848  " Set the cmap1 argument range for continuous color plots that\n"
19849  " corresponds to the range of data values. The maximum range\n"
19850  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19851  " the cmap1 argument range that is specified with this routine, the\n"
19852  " smaller the subset of the cmap1 color palette that is used to\n"
19853  " represent the continuous data being plotted. If\n"
19854  " min_color is greater than\n"
19855  " max_color or\n"
19856  " max_color is greater than 1.0 or\n"
19857  " min_color is less than 0.0 then no change is made to the cmap1\n"
19858  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19859  "\n"
19860  " Redacted form: plscmap1_range(min_color, max_color)\n"
19861  "\n"
19862  " This function is currently used in example 33.\n"
19863  "\n"
19864  "\n"
19865  "\n"
19866  "SYNOPSIS:\n"
19867  "\n"
19868  "plscmap1_range(min_color, max_color)\n"
19869  "\n"
19870  "ARGUMENTS:\n"
19871  "\n"
19872  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19873  " than 0.0, then 0.0 is used instead.\n"
19874  "\n"
19875  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19876  " than 1.0, then 1.0 is used instead.\n"
19877  "\n"
19878  ""},
19879  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
19880  "Get the cmap1 argument range for continuous color plots\n"
19881  "\n"
19882  "DESCRIPTION:\n"
19883  "\n"
19884  " Get the cmap1 argument range for continuous color plots. (Use\n"
19885  " plscmap1_range to set the cmap1 argument range.)\n"
19886  "\n"
19887  " Redacted form: plgcmap1_range(min_color, max_color)\n"
19888  "\n"
19889  " This function is currently not used in any example.\n"
19890  "\n"
19891  "\n"
19892  "\n"
19893  "SYNOPSIS:\n"
19894  "\n"
19895  "plgcmap1_range(min_color, max_color)\n"
19896  "\n"
19897  "ARGUMENTS:\n"
19898  "\n"
19899  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19900  " minimum cmap1 argument.\n"
19901  "\n"
19902  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19903  " maximum cmap1 argument.\n"
19904  "\n"
19905  ""},
19906  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
19907  "Set 8-bit RGB values for given cmap0 color index\n"
19908  "\n"
19909  "DESCRIPTION:\n"
19910  "\n"
19911  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19912  " index. Overwrites the previous color value for the given index and,\n"
19913  " thus, does not result in any additional allocation of space for\n"
19914  " colors.\n"
19915  "\n"
19916  " Redacted form: plscol0(icol0, r, g, b)\n"
19917  "\n"
19918  " This function is used in any example 31.\n"
19919  "\n"
19920  "\n"
19921  "\n"
19922  "SYNOPSIS:\n"
19923  "\n"
19924  "plscol0(icol0, r, g, b)\n"
19925  "\n"
19926  "ARGUMENTS:\n"
19927  "\n"
19928  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19929  " number of colors (which is set by default, by plscmap0n, or even\n"
19930  " by plscmap0).\n"
19931  "\n"
19932  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19933  " degree of red in the color.\n"
19934  "\n"
19935  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19936  " degree of green in the color.\n"
19937  "\n"
19938  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19939  " degree of blue in the color.\n"
19940  "\n"
19941  ""},
19942  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
19943  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19944  "\n"
19945  "DESCRIPTION:\n"
19946  "\n"
19947  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19948  " (see the PLplot documentation) index. Overwrites the previous color\n"
19949  " value for the given index and, thus, does not result in any additional\n"
19950  " allocation of space for colors.\n"
19951  "\n"
19952  " This function is used in example 30.\n"
19953  "\n"
19954  "\n"
19955  "\n"
19956  "SYNOPSIS:\n"
19957  "\n"
19958  "plscol0a(icol0, r, g, b, alpha)\n"
19959  "\n"
19960  "ARGUMENTS:\n"
19961  "\n"
19962  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19963  " number of colors (which is set by default, by plscmap0n, or even\n"
19964  " by plscmap0).\n"
19965  "\n"
19966  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19967  " degree of red in the color.\n"
19968  "\n"
19969  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19970  " degree of green in the color.\n"
19971  "\n"
19972  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19973  " degree of blue in the color.\n"
19974  "\n"
19975  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19976  " (0.0-1.0).\n"
19977  "\n"
19978  ""},
19979  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
19980  "Set the background color by 8-bit RGB value\n"
19981  "\n"
19982  "DESCRIPTION:\n"
19983  "\n"
19984  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19985  " the PLplot documentation).\n"
19986  "\n"
19987  " Redacted form: plscolbg(r, g, b)\n"
19988  "\n"
19989  " This function is used in examples 15 and 31.\n"
19990  "\n"
19991  "\n"
19992  "\n"
19993  "SYNOPSIS:\n"
19994  "\n"
19995  "plscolbg(r, g, b)\n"
19996  "\n"
19997  "ARGUMENTS:\n"
19998  "\n"
19999  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20000  " degree of red in the color.\n"
20001  "\n"
20002  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20003  " degree of green in the color.\n"
20004  "\n"
20005  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20006  " degree of blue in the color.\n"
20007  "\n"
20008  ""},
20009  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
20010  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20011  "\n"
20012  "DESCRIPTION:\n"
20013  "\n"
20014  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20015  " PLFLT alpha transparency value (see the PLplot documentation).\n"
20016  "\n"
20017  " This function is used in example 31.\n"
20018  "\n"
20019  "\n"
20020  "\n"
20021  "SYNOPSIS:\n"
20022  "\n"
20023  "plscolbga(r, g, b, alpha)\n"
20024  "\n"
20025  "ARGUMENTS:\n"
20026  "\n"
20027  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20028  " degree of red in the color.\n"
20029  "\n"
20030  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20031  " degree of green in the color.\n"
20032  "\n"
20033  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20034  " degree of blue in the color.\n"
20035  "\n"
20036  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20037  " (0.0-1.0).\n"
20038  "\n"
20039  ""},
20040  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
20041  "Used to globally turn color output on/off\n"
20042  "\n"
20043  "DESCRIPTION:\n"
20044  "\n"
20045  " Used to globally turn color output on/off for those drivers/devices\n"
20046  " that support it.\n"
20047  "\n"
20048  " Redacted form: plscolor(color)\n"
20049  "\n"
20050  " This function is used in example 31.\n"
20051  "\n"
20052  "\n"
20053  "\n"
20054  "SYNOPSIS:\n"
20055  "\n"
20056  "plscolor(color)\n"
20057  "\n"
20058  "ARGUMENTS:\n"
20059  "\n"
20060  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20061  " turned off. If non-zero, color is turned on.\n"
20062  "\n"
20063  ""},
20064  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
20065  "Set device-compression level\n"
20066  "\n"
20067  "DESCRIPTION:\n"
20068  "\n"
20069  " Set device-compression level. Only used for drivers that provide\n"
20070  " compression. This function, if used, should be invoked before a call\n"
20071  " to plinit.\n"
20072  "\n"
20073  " Redacted form: plscompression(compression)\n"
20074  "\n"
20075  " This function is used in example 31.\n"
20076  "\n"
20077  "\n"
20078  "\n"
20079  "SYNOPSIS:\n"
20080  "\n"
20081  "plscompression(compression)\n"
20082  "\n"
20083  "ARGUMENTS:\n"
20084  "\n"
20085  " compression (PLINT, input) : The desired compression level. This is\n"
20086  " a device-dependent value. Currently only the jpeg and png devices\n"
20087  " use these values. For jpeg value is the jpeg quality which should\n"
20088  " normally be in the range 0-95. Higher values denote higher quality\n"
20089  " and hence larger image sizes. For png values are in the range -1\n"
20090  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20091  " A value of -1 denotes the default zlib compression level. Values\n"
20092  " in the range 10-99 are divided by 10 and then used as the zlib\n"
20093  " compression level. Higher compression levels correspond to greater\n"
20094  " compression and small file sizes at the expense of more\n"
20095  " computation.\n"
20096  "\n"
20097  ""},
20098  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
20099  "Set the device (keyword) name\n"
20100  "\n"
20101  "DESCRIPTION:\n"
20102  "\n"
20103  " Set the device (keyword) name.\n"
20104  "\n"
20105  " Redacted form: plsdev(devname)\n"
20106  "\n"
20107  " This function is used in examples 1, 14, and 20.\n"
20108  "\n"
20109  "\n"
20110  "\n"
20111  "SYNOPSIS:\n"
20112  "\n"
20113  "plsdev(devname)\n"
20114  "\n"
20115  "ARGUMENTS:\n"
20116  "\n"
20117  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20118  " containing the device name keyword of the required output device.\n"
20119  " If\n"
20120  " devname is NULL or if the first character of the string is a ``?'',\n"
20121  " the normal (prompted) start up is used.\n"
20122  "\n"
20123  ""},
20124  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
20125  "Set parameters that define current device-space window\n"
20126  "\n"
20127  "DESCRIPTION:\n"
20128  "\n"
20129  " Set relative margin width, aspect ratio, and relative justification\n"
20130  " that define current device-space window. If you want to just use the\n"
20131  " previous value for any of these, just pass in the magic value\n"
20132  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20133  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20134  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20135  " to a device-specific value.\n"
20136  "\n"
20137  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20138  "\n"
20139  " This function is used in example 31.\n"
20140  "\n"
20141  "\n"
20142  "\n"
20143  "SYNOPSIS:\n"
20144  "\n"
20145  "plsdidev(mar, aspect, jx, jy)\n"
20146  "\n"
20147  "ARGUMENTS:\n"
20148  "\n"
20149  " mar (PLFLT, input) : Relative margin width.\n"
20150  "\n"
20151  " aspect (PLFLT, input) : Aspect ratio.\n"
20152  "\n"
20153  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20154  " the range -0.5 to 0.5.\n"
20155  "\n"
20156  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20157  " the range -0.5 to 0.5.\n"
20158  "\n"
20159  ""},
20160  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
20161  "Set up transformation from metafile coordinates\n"
20162  "\n"
20163  "DESCRIPTION:\n"
20164  "\n"
20165  " Set up transformation from metafile coordinates. The size of the plot\n"
20166  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20167  " general-purpose facility just yet (not sure why the user would need\n"
20168  " it, for one).\n"
20169  "\n"
20170  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20171  " dimypmm)\n"
20172  "\n"
20173  " This function is not used in any examples.\n"
20174  "\n"
20175  "\n"
20176  "\n"
20177  "SYNOPSIS:\n"
20178  "\n"
20179  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20180  "\n"
20181  "ARGUMENTS:\n"
20182  "\n"
20183  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20184  "\n"
20185  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20186  "\n"
20187  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20188  "\n"
20189  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20190  "\n"
20191  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20192  "\n"
20193  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20194  "\n"
20195  ""},
20196  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
20197  "Set plot orientation\n"
20198  "\n"
20199  "DESCRIPTION:\n"
20200  "\n"
20201  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20202  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20203  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20204  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20205  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20206  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20207  " not called the default value of rot is 0.\n"
20208  "\n"
20209  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20210  " probably want to change the aspect ratio to a value suitable for the\n"
20211  " plot orientation using a call to plsdidev or the command-line options\n"
20212  " -a or -freeaspect. For more documentation of those options see the\n"
20213  " PLplot documentation. Such command-line options can be set internally\n"
20214  " using plsetopt or set directly using the command line and parsed using\n"
20215  " a call to plparseopts.\n"
20216  "\n"
20217  " Redacted form: plsdiori(rot)\n"
20218  "\n"
20219  " This function is not used in any examples.\n"
20220  "\n"
20221  "\n"
20222  "\n"
20223  "SYNOPSIS:\n"
20224  "\n"
20225  "plsdiori(rot)\n"
20226  "\n"
20227  "ARGUMENTS:\n"
20228  "\n"
20229  " rot (PLFLT, input) : Plot orientation parameter.\n"
20230  "\n"
20231  ""},
20232  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
20233  "Set parameters that define current plot-space window\n"
20234  "\n"
20235  "DESCRIPTION:\n"
20236  "\n"
20237  " Set relative minima and maxima that define the current plot-space\n"
20238  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20239  " xmax, and ymax are 0., 0., 1., and 1.\n"
20240  "\n"
20241  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20242  "\n"
20243  " This function is used in example 31.\n"
20244  "\n"
20245  "\n"
20246  "\n"
20247  "SYNOPSIS:\n"
20248  "\n"
20249  "plsdiplt(xmin, ymin, xmax, ymax)\n"
20250  "\n"
20251  "ARGUMENTS:\n"
20252  "\n"
20253  " xmin (PLFLT, input) : Relative minimum in x.\n"
20254  "\n"
20255  " ymin (PLFLT, input) : Relative minimum in y.\n"
20256  "\n"
20257  " xmax (PLFLT, input) : Relative maximum in x.\n"
20258  "\n"
20259  " ymax (PLFLT, input) : Relative maximum in y.\n"
20260  "\n"
20261  ""},
20262  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
20263  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20264  "\n"
20265  "DESCRIPTION:\n"
20266  "\n"
20267  " Set relative minima and maxima incrementally (zoom mode) that define\n"
20268  " the current plot-space window. This function has the same effect as\n"
20269  " plsdiplt if that function has not been previously called. Otherwise,\n"
20270  " this function implements zoom mode using the transformation min_used =\n"
20271  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20272  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20273  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20274  "\n"
20275  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20276  "\n"
20277  " This function is used in example 31.\n"
20278  "\n"
20279  "\n"
20280  "\n"
20281  "SYNOPSIS:\n"
20282  "\n"
20283  "plsdiplz(xmin, ymin, xmax, ymax)\n"
20284  "\n"
20285  "ARGUMENTS:\n"
20286  "\n"
20287  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20288  "\n"
20289  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20290  "\n"
20291  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20292  "\n"
20293  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20294  "\n"
20295  ""},
20296  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
20297  "Set seed for internal random number generator.\n"
20298  "\n"
20299  "DESCRIPTION:\n"
20300  "\n"
20301  " Set the seed for the internal random number generator. See plrandd for\n"
20302  " further details.\n"
20303  "\n"
20304  " Redacted form: plseed(seed)\n"
20305  "\n"
20306  " This function is used in example 21.\n"
20307  "\n"
20308  "\n"
20309  "\n"
20310  "SYNOPSIS:\n"
20311  "\n"
20312  "plseed(seed)\n"
20313  "\n"
20314  "ARGUMENTS:\n"
20315  "\n"
20316  " seed (unsigned int, input) : Seed for random number generator.\n"
20317  "\n"
20318  ""},
20319  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
20320  "Set the escape character for text strings\n"
20321  "\n"
20322  "DESCRIPTION:\n"
20323  "\n"
20324  " Set the escape character for text strings. From C (in contrast to\n"
20325  " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
20326  " selected characters are allowed to prevent the user from shooting\n"
20327  " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
20328  " with C's use of backslash as a character escape). Here are the\n"
20329  " allowed escape characters and their corresponding decimal ASCII\n"
20330  " values: !, ASCII 33\n"
20331  " #, ASCII 35\n"
20332  " $, ASCII 36\n"
20333  " %, ASCII 37\n"
20334  " &, ASCII 38\n"
20335  " *, ASCII 42\n"
20336  " @, ASCII 64\n"
20337  " ^, ASCII 94\n"
20338  " ~, ASCII 126\n"
20339  "\n"
20340  "\n"
20341  " Redacted form: General: plsesc(esc)\n"
20342  " Perl/PDL: Not available?\n"
20343  "\n"
20344  "\n"
20345  " This function is used in example 29.\n"
20346  "\n"
20347  "\n"
20348  "\n"
20349  "SYNOPSIS:\n"
20350  "\n"
20351  "plsesc(esc)\n"
20352  "\n"
20353  "ARGUMENTS:\n"
20354  "\n"
20355  " esc (char, input) : Escape character.\n"
20356  "\n"
20357  ""},
20358  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
20359  "Set any command-line option\n"
20360  "\n"
20361  "DESCRIPTION:\n"
20362  "\n"
20363  " Set any command-line option internally from a program before it\n"
20364  " invokes plinit. opt is the name of the command-line option and optarg\n"
20365  " is the corresponding command-line option argument.\n"
20366  "\n"
20367  " This function returns 0 on success.\n"
20368  "\n"
20369  " Redacted form: plsetopt(opt, optarg)\n"
20370  "\n"
20371  " This function is used in example 14.\n"
20372  "\n"
20373  "\n"
20374  "\n"
20375  "SYNOPSIS:\n"
20376  "\n"
20377  "PLINT plsetopt(opt, optarg)\n"
20378  "\n"
20379  "ARGUMENTS:\n"
20380  "\n"
20381  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20382  " the command-line option.\n"
20383  "\n"
20384  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20385  " containing the argument of the command-line option.\n"
20386  "\n"
20387  ""},
20388  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
20389  "Set family file parameters\n"
20390  "\n"
20391  "DESCRIPTION:\n"
20392  "\n"
20393  " Sets variables dealing with output file familying. Does nothing if\n"
20394  " familying not supported by the driver. This routine, if used, must be\n"
20395  " called before initializing PLplot. See the PLplot documentation for\n"
20396  " more information.\n"
20397  "\n"
20398  " Redacted form: plsfam(fam, num, bmax)\n"
20399  "\n"
20400  " This function is used in examples 14 and 31.\n"
20401  "\n"
20402  "\n"
20403  "\n"
20404  "SYNOPSIS:\n"
20405  "\n"
20406  "plsfam(fam, num, bmax)\n"
20407  "\n"
20408  "ARGUMENTS:\n"
20409  "\n"
20410  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20411  " is enabled.\n"
20412  "\n"
20413  " num (PLINT, input) : Current family file number.\n"
20414  "\n"
20415  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20416  " file.\n"
20417  "\n"
20418  ""},
20419  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
20420  "Set FCI (font characterization integer)\n"
20421  "\n"
20422  "DESCRIPTION:\n"
20423  "\n"
20424  " Sets font characteristics to be used at the start of the next string\n"
20425  " using the FCI approach. See the PLplot documentation for more\n"
20426  " information. Note, plsfont (which calls plsfci internally) provides a\n"
20427  " more user-friendly API for setting the font characterisitics.\n"
20428  "\n"
20429  " Redacted form: General: plsfci(fci)\n"
20430  " Perl/PDL: Not available?\n"
20431  "\n"
20432  "\n"
20433  " This function is used in example 23.\n"
20434  "\n"
20435  "\n"
20436  "\n"
20437  "SYNOPSIS:\n"
20438  "\n"
20439  "plsfci(fci)\n"
20440  "\n"
20441  "ARGUMENTS:\n"
20442  "\n"
20443  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20444  " of FCI.\n"
20445  "\n"
20446  ""},
20447  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
20448  "Set output file name\n"
20449  "\n"
20450  "DESCRIPTION:\n"
20451  "\n"
20452  " Sets the current output file name, if applicable. If the file name\n"
20453  " has not been specified and is required by the driver, the user will be\n"
20454  " prompted for it. If using the X-windows output driver, this sets the\n"
20455  " display name. This routine, if used, must be called before\n"
20456  " initializing PLplot.\n"
20457  "\n"
20458  " Redacted form: plsfnam(fnam)\n"
20459  "\n"
20460  " This function is used in examples 1 and 20.\n"
20461  "\n"
20462  "\n"
20463  "\n"
20464  "SYNOPSIS:\n"
20465  "\n"
20466  "plsfnam(fnam)\n"
20467  "\n"
20468  "ARGUMENTS:\n"
20469  "\n"
20470  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20471  " the file name.\n"
20472  "\n"
20473  ""},
20474  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
20475  "Set family, style and weight of the current font\n"
20476  "\n"
20477  "DESCRIPTION:\n"
20478  "\n"
20479  " Sets the current font. See the PLplot documentation for more\n"
20480  " information on font selection.\n"
20481  "\n"
20482  " Redacted form: plsfont(family, style, weight)\n"
20483  "\n"
20484  " This function is used in example 23.\n"
20485  "\n"
20486  "\n"
20487  "\n"
20488  "SYNOPSIS:\n"
20489  "\n"
20490  "plsfont(family, style, weight)\n"
20491  "\n"
20492  "ARGUMENTS:\n"
20493  "\n"
20494  " family (PLINT, input) : Font family to select for the current font.\n"
20495  " The available values are given by the PL_FCI_* constants in\n"
20496  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20497  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20498  " signifies that the font family should not be altered.\n"
20499  "\n"
20500  " style (PLINT, input) : Font style to select for the current font.\n"
20501  " The available values are given by the PL_FCI_* constants in\n"
20502  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20503  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20504  " should not be altered.\n"
20505  "\n"
20506  " weight (PLINT, input) : Font weight to select for the current font.\n"
20507  " The available values are given by the PL_FCI_* constants in\n"
20508  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20509  " negative value signifies that the font weight should not be\n"
20510  " altered.\n"
20511  "\n"
20512  ""},
20513  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
20514  "Shade regions on the basis of value\n"
20515  "\n"
20516  "DESCRIPTION:\n"
20517  "\n"
20518  " Shade regions on the basis of value. This is the high-level routine\n"
20519  " for making continuous color shaded plots with cmap1 while plshade\n"
20520  " should be used to plot individual shaded regions using either cmap0 or\n"
20521  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20522  " our supported languages.\n"
20523  "\n"
20524  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20525  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20526  " pltr_data)\n"
20527  " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
20528  " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
20529  " pltr_data)\n"
20530  "\n"
20531  "\n"
20532  " This function is used in examples 16, 21, and 22.\n"
20533  "\n"
20534  "\n"
20535  "\n"
20536  "SYNOPSIS:\n"
20537  "\n"
20538  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20539  "\n"
20540  "ARGUMENTS:\n"
20541  "\n"
20542  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20543  " plot. Should have dimensions of\n"
20544  " nx by\n"
20545  " ny.\n"
20546  "\n"
20547  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20548  "\n"
20549  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20550  "\n"
20551  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20552  " the region that should be plotted in the shade plot. This\n"
20553  " function accepts x and y coordinates as input arguments and must\n"
20554  " return 1 if the point is to be included in the shade plot and 0\n"
20555  " otherwise. If you want to plot the entire shade plot (the usual\n"
20556  " case), this argument should be set to NULL.\n"
20557  "\n"
20558  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20559  " pltr below for how these arguments are used (only for the special case\n"
20560  " when the callback function\n"
20561  " pltr is not supplied).\n"
20562  "\n"
20563  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20564  " corresponding to the edges of each shaded region that will be\n"
20565  " plotted by this function. To work properly the levels should be\n"
20566  " monotonic.\n"
20567  "\n"
20568  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20569  " of shade edge values in clevel).\n"
20570  "\n"
20571  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20572  " pattern.\n"
20573  "\n"
20574  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20575  " contours defining edges of shaded regions. The pen color is only\n"
20576  " temporary set for the contour drawing. Set this value to zero or\n"
20577  " less if no shade edge contours are wanted.\n"
20578  "\n"
20579  " cont_width (PLFLT, input) : Defines line width used for contours\n"
20580  " defining edges of shaded regions. This value may not be honored\n"
20581  " by all drivers. The pen width is only temporary set for the\n"
20582  " contour drawing. Set this value to zero or less if no shade edge\n"
20583  " contours are wanted.\n"
20584  "\n"
20585  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20586  " region. Use plfill for this purpose.\n"
20587  "\n"
20588  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20589  " map to rectangles after coordinate transformation with pltrl.\n"
20590  " Otherwise, set rectangular to false. If rectangular is set to\n"
20591  " true, plshade tries to save time by filling large rectangles.\n"
20592  " This optimization fails if the coordinate transformation distorts\n"
20593  " the shape of rectangles. For example a plot in polar coordinates\n"
20594  " has to have rectangular set to false.\n"
20595  "\n"
20596  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20597  " defines the transformation between the zero-based indices of the\n"
20598  " matrix a and world coordinates. If\n"
20599  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20600  " indices of a are mapped to the range\n"
20601  " xmin through\n"
20602  " xmax and the y indices of a are mapped to the range\n"
20603  " ymin through\n"
20604  " ymax.For the C case, transformation functions are provided in the\n"
20605  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20606  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20607  " matrices. In addition, C callback routines for the transformation\n"
20608  " can be supplied by the user such as the mypltr function in\n"
20609  " examples/c/x09c.c which provides a general linear transformation\n"
20610  " between index coordinates and world coordinates.For languages\n"
20611  " other than C you should consult the PLplot documentation for the\n"
20612  " details concerning how PLTRANSFORM_callback arguments are\n"
20613  " interfaced. However, in general, a particular pattern of\n"
20614  " callback-associated arguments such as a tr vector with 6 elements;\n"
20615  " xg and yg vectors; or xg and yg matrices are respectively\n"
20616  " interfaced to a linear-transformation routine similar to the above\n"
20617  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20618  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20619  " support native language callbacks for handling index to\n"
20620  " world-coordinate transformations. Examples of these various\n"
20621  " approaches are given in examples/<language>x09*,\n"
20622  " examples/<language>x16*, examples/<language>x20*,\n"
20623  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20624  " supported languages.\n"
20625  "\n"
20626  " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
20627  " pass information to pltr0, pltr1, pltr2, or whatever routine that\n"
20628  " is externally supplied.\n"
20629  "\n"
20630  ""},
20631  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20632  "Shade individual region on the basis of value\n"
20633  "\n"
20634  "DESCRIPTION:\n"
20635  "\n"
20636  " Shade individual region on the basis of value. Use plshades if you\n"
20637  " want to shade a number of contiguous regions using continuous colors.\n"
20638  " In particular the edge contours are treated properly in plshades. If\n"
20639  " you attempt to do contiguous regions with plshade the contours at the\n"
20640  " edge of the shade are partially obliterated by subsequent plots of\n"
20641  " contiguous shaded regions.\n"
20642  "\n"
20643  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20644  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20645  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20646  "\n"
20647  "\n"
20648  " This function is used in example 15.\n"
20649  "\n"
20650  "\n"
20651  "\n"
20652  "SYNOPSIS:\n"
20653  "\n"
20654  "plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20655  "\n"
20656  "ARGUMENTS:\n"
20657  "\n"
20658  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20659  " plot. Should have dimensions of\n"
20660  " nx by\n"
20661  " ny.\n"
20662  "\n"
20663  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20664  "\n"
20665  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20666  "\n"
20667  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20668  " the region that should be plotted in the shade plot. This\n"
20669  " function accepts x and y coordinates as input arguments and must\n"
20670  " return 1 if the point is to be included in the shade plot and 0\n"
20671  " otherwise. If you want to plot the entire shade plot (the usual\n"
20672  " case), this argument should be set to NULL.\n"
20673  "\n"
20674  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20675  " pltr below for how these arguments are used (only for the special case\n"
20676  " when the callback function\n"
20677  " pltr is not supplied).\n"
20678  "\n"
20679  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20680  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20681  "\n"
20682  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20683  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20684  "\n"
20685  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20686  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20687  " then sh_color is interpreted as a cmap1 argument in the range\n"
20688  " (0.0-1.0).\n"
20689  "\n"
20690  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20691  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20692  "\n"
20693  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20694  "\n"
20695  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20696  " boundary of shaded region. The min values are used for the\n"
20697  " shade_min boundary, and the max values are used on the shade_max\n"
20698  " boundary. Set color and width to zero for no plotted boundaries.\n"
20699  "\n"
20700  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20701  " boundary of shaded region. The min values are used for the\n"
20702  " shade_min boundary, and the max values are used on the shade_max\n"
20703  " boundary. Set color and width to zero for no plotted boundaries.\n"
20704  "\n"
20705  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20706  " boundary of shaded region. The min values are used for the\n"
20707  " shade_min boundary, and the max values are used on the shade_max\n"
20708  " boundary. Set color and width to zero for no plotted boundaries.\n"
20709  "\n"
20710  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20711  " boundary of shaded region. The min values are used for the\n"
20712  " shade_min boundary, and the max values are used on the shade_max\n"
20713  " boundary. Set color and width to zero for no plotted boundaries.\n"
20714  "\n"
20715  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20716  " Use plfill. Future version of PLplot may have other fill\n"
20717  " routines.\n"
20718  "\n"
20719  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20720  " map to rectangles after coordinate transformation with pltrl.\n"
20721  " Otherwise, set rectangular to false. If rectangular is set to\n"
20722  " true, plshade tries to save time by filling large rectangles.\n"
20723  " This optimization fails if the coordinate transformation distorts\n"
20724  " the shape of rectangles. For example a plot in polar coordinates\n"
20725  " has to have rectangular set to false.\n"
20726  "\n"
20727  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20728  " defines the transformation between the zero-based indices of the\n"
20729  " matrix a and world coordinates. If\n"
20730  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20731  " indices of a are mapped to the range\n"
20732  " xmin through\n"
20733  " xmax and the y indices of a are mapped to the range\n"
20734  " ymin through\n"
20735  " ymax.For the C case, transformation functions are provided in the\n"
20736  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20737  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20738  " matrices. In addition, C callback routines for the transformation\n"
20739  " can be supplied by the user such as the mypltr function in\n"
20740  " examples/c/x09c.c which provides a general linear transformation\n"
20741  " between index coordinates and world coordinates.For languages\n"
20742  " other than C you should consult the PLplot documentation for the\n"
20743  " details concerning how PLTRANSFORM_callback arguments are\n"
20744  " interfaced. However, in general, a particular pattern of\n"
20745  " callback-associated arguments such as a tr vector with 6 elements;\n"
20746  " xg and yg vectors; or xg and yg matrices are respectively\n"
20747  " interfaced to a linear-transformation routine similar to the above\n"
20748  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20749  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20750  " support native language callbacks for handling index to\n"
20751  " world-coordinate transformations. Examples of these various\n"
20752  " approaches are given in examples/<language>x09*,\n"
20753  " examples/<language>x16*, examples/<language>x20*,\n"
20754  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20755  " supported languages.\n"
20756  "\n"
20757  " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
20758  " pass information to pltr0, pltr1, pltr2, or whatever routine that\n"
20759  " is externally supplied.\n"
20760  "\n"
20761  ""},
20762  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20763  "Assign a function to use for generating custom axis labels\n"
20764  "\n"
20765  "DESCRIPTION:\n"
20766  "\n"
20767  " This function allows a user to provide their own function to provide\n"
20768  " axis label text. The user function is given the numeric value for a\n"
20769  " point on an axis and returns a string label to correspond with that\n"
20770  " value. Custom axis labels can be enabled by passing appropriate\n"
20771  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20772  "\n"
20773  " This function is used in example 19.\n"
20774  "\n"
20775  "\n"
20776  "\n"
20777  "SYNOPSIS:\n"
20778  "\n"
20779  "plslabelfunc(label_func, label_data)\n"
20780  "\n"
20781  "ARGUMENTS:\n"
20782  "\n"
20783  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20784  " label function. In order to reset to the default labelling, set\n"
20785  " this to NULL. The labelling function parameters are, in order:\n"
20786  " axis: This indicates which axis a label is being requested for.\n"
20787  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20788  "\n"
20789  " value: This is the value along the axis which is being labelled.\n"
20790  "\n"
20791  " label_text: The string representation of the label value.\n"
20792  "\n"
20793  " length: The maximum length in characters allowed for label_text.\n"
20794  "\n"
20795  "\n"
20796  " label_data (PL_GENERIC_POINTER, input) : This parameter may be used\n"
20797  " to pass data to the label_func function.\n"
20798  "\n"
20799  ""},
20800  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20801  "Set length of major ticks\n"
20802  "\n"
20803  "DESCRIPTION:\n"
20804  "\n"
20805  " This sets up the length of the major ticks. The actual length is the\n"
20806  " product of the default length and a scaling factor as for character\n"
20807  " height.\n"
20808  "\n"
20809  " Redacted form: plsmaj(def, scale)\n"
20810  "\n"
20811  " This function is used in example 29.\n"
20812  "\n"
20813  "\n"
20814  "\n"
20815  "SYNOPSIS:\n"
20816  "\n"
20817  "plsmaj(def, scale)\n"
20818  "\n"
20819  "ARGUMENTS:\n"
20820  "\n"
20821  " def (PLFLT, input) : The default length of a major tick in\n"
20822  " millimeters, should be set to zero if the default length is to\n"
20823  " remain unchanged.\n"
20824  "\n"
20825  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20826  " actual tick length.\n"
20827  "\n"
20828  ""},
20829  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20830  "Set the memory area to be plotted (RGB)\n"
20831  "\n"
20832  "DESCRIPTION:\n"
20833  "\n"
20834  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20835  " the dev member of the stream structure. Also set the number of pixels\n"
20836  " in the memory passed in\n"
20837  " plotmem, which is a block of memory\n"
20838  " maxy by\n"
20839  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20840  "\n"
20841  " This memory will have to be freed by the user!\n"
20842  "\n"
20843  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20844  "\n"
20845  " This function is not used in any examples.\n"
20846  "\n"
20847  "\n"
20848  "\n"
20849  "SYNOPSIS:\n"
20850  "\n"
20851  "plsmem(maxx, maxy, plotmem)\n"
20852  "\n"
20853  "ARGUMENTS:\n"
20854  "\n"
20855  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20856  "\n"
20857  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20858  "\n"
20859  " plotmem (PL_NC_GENERIC_POINTER, input) : Pointer to the beginning\n"
20860  " of a user-supplied writeable memory area.\n"
20861  "\n"
20862  ""},
20863  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
20864  "Set the memory area to be plotted (RGBA)\n"
20865  "\n"
20866  "DESCRIPTION:\n"
20867  "\n"
20868  " Set the memory area to be plotted (with the memcairo driver) as the\n"
20869  " dev member of the stream structure. Also set the number of pixels in\n"
20870  " the memory passed in\n"
20871  " plotmem, which is a block of memory\n"
20872  " maxy by\n"
20873  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20874  "\n"
20875  " This memory will have to be freed by the user!\n"
20876  "\n"
20877  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20878  "\n"
20879  " This function is not used in any examples.\n"
20880  "\n"
20881  "\n"
20882  "\n"
20883  "SYNOPSIS:\n"
20884  "\n"
20885  "plsmema(maxx, maxy, plotmem)\n"
20886  "\n"
20887  "ARGUMENTS:\n"
20888  "\n"
20889  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20890  "\n"
20891  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20892  "\n"
20893  " plotmem (PL_NC_GENERIC_POINTER, input) : Pointer to the beginning\n"
20894  " of a user-supplied writeable memory area.\n"
20895  "\n"
20896  ""},
20897  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
20898  "Set length of minor ticks\n"
20899  "\n"
20900  "DESCRIPTION:\n"
20901  "\n"
20902  " This sets up the length of the minor ticks and the length of the\n"
20903  " terminals on error bars. The actual length is the product of the\n"
20904  " default length and a scaling factor as for character height.\n"
20905  "\n"
20906  " Redacted form: plsmin(def, scale)\n"
20907  "\n"
20908  " This function is used in example 29.\n"
20909  "\n"
20910  "\n"
20911  "\n"
20912  "SYNOPSIS:\n"
20913  "\n"
20914  "plsmin(def, scale)\n"
20915  "\n"
20916  "ARGUMENTS:\n"
20917  "\n"
20918  " def (PLFLT, input) : The default length of a minor tick in\n"
20919  " millimeters, should be set to zero if the default length is to\n"
20920  " remain unchanged.\n"
20921  "\n"
20922  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20923  " actual tick length.\n"
20924  "\n"
20925  ""},
20926  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
20927  "Set orientation\n"
20928  "\n"
20929  "DESCRIPTION:\n"
20930  "\n"
20931  " Set integer plot orientation parameter. This function is identical to\n"
20932  " plsdiori except for the type of the argument, and should be used in\n"
20933  " the same way. See the documentation of plsdiori for details.\n"
20934  "\n"
20935  " Redacted form: plsori(ori)\n"
20936  "\n"
20937  " This function is used in example 3.\n"
20938  "\n"
20939  "\n"
20940  "\n"
20941  "SYNOPSIS:\n"
20942  "\n"
20943  "plsori(ori)\n"
20944  "\n"
20945  "ARGUMENTS:\n"
20946  "\n"
20947  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20948  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20949  " angle.\n"
20950  "\n"
20951  ""},
20952  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
20953  "Set page parameters\n"
20954  "\n"
20955  "DESCRIPTION:\n"
20956  "\n"
20957  " Sets the page configuration (optional). If an individual parameter is\n"
20958  " zero then that parameter value is not updated. Not all parameters are\n"
20959  " recognized by all drivers and the interpretation is device-dependent.\n"
20960  " The X-window driver uses the length and offset parameters to determine\n"
20961  " the window size and location. The length and offset values are\n"
20962  " expressed in units that are specific to the current driver. For\n"
20963  " instance: screen drivers will usually interpret them as number of\n"
20964  " pixels, whereas printer drivers will usually use mm.\n"
20965  "\n"
20966  " This routine, if used, must be called before initializing PLplot. It\n"
20967  " may be called at later times for interactive drivers to change only\n"
20968  " the dpi for subsequent redraws which you can force via a call to\n"
20969  " plreplot. If this function is not called then the page size defaults\n"
20970  " to landscape A4 for drivers which use real world page sizes and 744\n"
20971  " pixels wide by 538 pixels high for raster drivers. The default value\n"
20972  " for dx and dy is 90 pixels per inch for raster drivers.\n"
20973  "\n"
20974  "\n"
20975  "\n"
20976  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20977  "\n"
20978  " This function is used in examples 14 and 31.\n"
20979  "\n"
20980  "\n"
20981  "\n"
20982  "SYNOPSIS:\n"
20983  "\n"
20984  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20985  "\n"
20986  "ARGUMENTS:\n"
20987  "\n"
20988  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20989  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20990  " (e.g. mm).\n"
20991  "\n"
20992  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20993  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20994  " (e.g. mm).\n"
20995  "\n"
20996  " xleng (PLINT, input) : Page length, x.\n"
20997  "\n"
20998  " yleng (PLINT, input) : Page length, y.\n"
20999  "\n"
21000  " xoff (PLINT, input) : Page offset, x.\n"
21001  "\n"
21002  " yoff (PLINT, input) : Page offset, y.\n"
21003  "\n"
21004  ""},
21005  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
21006  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21007  "\n"
21008  "DESCRIPTION:\n"
21009  "\n"
21010  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21011  "\n"
21012  " Redacted form: plspal0(filename)\n"
21013  "\n"
21014  " This function is in example 16.\n"
21015  "\n"
21016  "\n"
21017  "\n"
21018  "SYNOPSIS:\n"
21019  "\n"
21020  "plspal0(filename)\n"
21021  "\n"
21022  "ARGUMENTS:\n"
21023  "\n"
21024  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21025  " containing the name of the cmap0*.pal file. If this string is\n"
21026  " empty, use the default cmap0*.pal file.\n"
21027  "\n"
21028  ""},
21029  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
21030  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21031  "\n"
21032  "DESCRIPTION:\n"
21033  "\n"
21034  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21035  "\n"
21036  " Redacted form: plspal1(filename, interpolate)\n"
21037  "\n"
21038  " This function is used in example 16.\n"
21039  "\n"
21040  "\n"
21041  "\n"
21042  "SYNOPSIS:\n"
21043  "\n"
21044  "plspal1(filename, interpolate)\n"
21045  "\n"
21046  "ARGUMENTS:\n"
21047  "\n"
21048  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21049  " containing the name of the cmap1*.pal file. If this string is\n"
21050  " empty, use the default cmap1*.pal file.\n"
21051  "\n"
21052  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21053  " columns containing the intensity index, r, g, b, alpha and\n"
21054  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21055  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21056  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21057  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21058  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21059  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21060  " are used instead to set the cmap1 palette directly with a call to\n"
21061  " plscmap1a.\n"
21062  "\n"
21063  ""},
21064  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
21065  "Set the pause (on end-of-page) status\n"
21066  "\n"
21067  "DESCRIPTION:\n"
21068  "\n"
21069  " Set the pause (on end-of-page) status.\n"
21070  "\n"
21071  " Redacted form: plspause(pause)\n"
21072  "\n"
21073  " This function is in examples 14,20.\n"
21074  "\n"
21075  "\n"
21076  "\n"
21077  "SYNOPSIS:\n"
21078  "\n"
21079  "plspause(pause)\n"
21080  "\n"
21081  "ARGUMENTS:\n"
21082  "\n"
21083  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21084  " end-of-page for those drivers which support this. Otherwise there\n"
21085  " is no pause.\n"
21086  "\n"
21087  ""},
21088  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
21089  "Set current output stream\n"
21090  "\n"
21091  "DESCRIPTION:\n"
21092  "\n"
21093  " Sets the number of the current output stream. The stream number\n"
21094  " defaults to 0 unless changed by this routine. The first use of this\n"
21095  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21096  "\n"
21097  " Redacted form: plsstrm(strm)\n"
21098  "\n"
21099  " This function is examples 1,14,20.\n"
21100  "\n"
21101  "\n"
21102  "\n"
21103  "SYNOPSIS:\n"
21104  "\n"
21105  "plsstrm(strm)\n"
21106  "\n"
21107  "ARGUMENTS:\n"
21108  "\n"
21109  " strm (PLINT, input) : The current stream number.\n"
21110  "\n"
21111  ""},
21112  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
21113  "Set the number of subpages in x and y\n"
21114  "\n"
21115  "DESCRIPTION:\n"
21116  "\n"
21117  " Set the number of subpages in x and y.\n"
21118  "\n"
21119  " Redacted form: plssub(nx, ny)\n"
21120  "\n"
21121  " This function is examples 1,2,14,21,25,27.\n"
21122  "\n"
21123  "\n"
21124  "\n"
21125  "SYNOPSIS:\n"
21126  "\n"
21127  "plssub(nx, ny)\n"
21128  "\n"
21129  "ARGUMENTS:\n"
21130  "\n"
21131  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21132  " of window columns).\n"
21133  "\n"
21134  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21135  " of window rows).\n"
21136  "\n"
21137  ""},
21138  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
21139  "Set symbol size\n"
21140  "\n"
21141  "DESCRIPTION:\n"
21142  "\n"
21143  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21144  " plsym. The actual height of a symbol is the product of the default\n"
21145  " symbol size and a scaling factor as for the character height.\n"
21146  "\n"
21147  " Redacted form: plssym(def, scale)\n"
21148  "\n"
21149  " This function is used in example 29.\n"
21150  "\n"
21151  "\n"
21152  "\n"
21153  "SYNOPSIS:\n"
21154  "\n"
21155  "plssym(def, scale)\n"
21156  "\n"
21157  "ARGUMENTS:\n"
21158  "\n"
21159  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21160  " should be set to zero if the default height is to remain\n"
21161  " unchanged.\n"
21162  "\n"
21163  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21164  " actual symbol height.\n"
21165  "\n"
21166  ""},
21167  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
21168  "Initialization\n"
21169  "\n"
21170  "DESCRIPTION:\n"
21171  "\n"
21172  " Initializing the plotting package. The program prompts for the device\n"
21173  " keyword or number of the desired output device. Hitting a RETURN in\n"
21174  " response to the prompt is the same as selecting the first device. If\n"
21175  " only one device is enabled when PLplot is installed, plstar will issue\n"
21176  " no prompt. The output device is divided into nx by ny subpages, each\n"
21177  " of which may be used independently. The subroutine pladv is used to\n"
21178  " advance from one subpage to the next.\n"
21179  "\n"
21180  " Redacted form: plstar(nx, ny)\n"
21181  "\n"
21182  " This function is used in example 1.\n"
21183  "\n"
21184  "\n"
21185  "\n"
21186  "SYNOPSIS:\n"
21187  "\n"
21188  "plstar(nx, ny)\n"
21189  "\n"
21190  "ARGUMENTS:\n"
21191  "\n"
21192  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21193  " x direction.\n"
21194  "\n"
21195  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21196  " y direction.\n"
21197  "\n"
21198  ""},
21199  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
21200  "Initialization\n"
21201  "\n"
21202  "DESCRIPTION:\n"
21203  "\n"
21204  " Alternative to plstar for initializing the plotting package. The\n"
21205  " device name keyword for the desired output device must be supplied as\n"
21206  " an argument. These keywords are the same as those printed out by\n"
21207  " plstar. If the requested device is not available, or if the input\n"
21208  " string is empty or begins with ``?'', the prompted start up of plstar\n"
21209  " is used. This routine also divides the output device page into nx by\n"
21210  " ny subpages, each of which may be used independently. The subroutine\n"
21211  " pladv is used to advance from one subpage to the next.\n"
21212  "\n"
21213  " Redacted form: General: plstart(devname, nx, ny)\n"
21214  " Perl/PDL: plstart(nx, ny, devname)\n"
21215  "\n"
21216  "\n"
21217  " This function is not used in any examples.\n"
21218  "\n"
21219  "\n"
21220  "\n"
21221  "SYNOPSIS:\n"
21222  "\n"
21223  "plstart(devname, nx, ny)\n"
21224  "\n"
21225  "ARGUMENTS:\n"
21226  "\n"
21227  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21228  " containing the device name keyword of the required output device.\n"
21229  " If\n"
21230  " devname is NULL or if the first character of the string is a ``?'',\n"
21231  " the normal (prompted) start up is used.\n"
21232  "\n"
21233  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21234  " x direction.\n"
21235  "\n"
21236  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21237  " y direction.\n"
21238  "\n"
21239  ""},
21240  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
21241  "Set a global coordinate transform function\n"
21242  "\n"
21243  "DESCRIPTION:\n"
21244  "\n"
21245  " This function can be used to define a coordinate transformation which\n"
21246  " affects all elements drawn within the current plot window. The\n"
21247  " coordinate_transform callback function is similar to that provided for\n"
21248  " the plmap and plmeridians functions. The coordinate_transform_data\n"
21249  " parameter may be used to pass extra data to coordinate_transform.\n"
21250  "\n"
21251  " Redacted form: General: plstransform(coordinate_transform,\n"
21252  " coordinate_transform_data)\n"
21253  "\n"
21254  "\n"
21255  " This function is used in examples 19 and 22.\n"
21256  "\n"
21257  "\n"
21258  "\n"
21259  "SYNOPSIS:\n"
21260  "\n"
21261  "plstransform(coordinate_transform, coordinate_transform_data)\n"
21262  "\n"
21263  "ARGUMENTS:\n"
21264  "\n"
21265  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21266  " function that defines the transformation from the input (x, y)\n"
21267  " world coordinates to new PLplot world coordinates. If\n"
21268  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21269  " case), then no transform is applied.\n"
21270  "\n"
21271  " coordinate_transform_data (PL_GENERIC_POINTER, input) : Optional\n"
21272  " extra data for\n"
21273  " coordinate_transform.\n"
21274  "\n"
21275  ""},
21276  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
21277  "Plot a glyph at the specified points\n"
21278  "\n"
21279  "DESCRIPTION:\n"
21280  "\n"
21281  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21282  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21283  " is specified with a PLplot user string. Note that the user string is\n"
21284  " not actually limited to one glyph so it is possible (but not normally\n"
21285  " useful) to plot more than one glyph at the specified points with this\n"
21286  " function. As with plmtex and plptex, the user string can contain FCI\n"
21287  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21288  " else PLplot escapes for Hershey or unicode text to determine the\n"
21289  " glyph.\n"
21290  "\n"
21291  " Redacted form: plstring(x, y, string)\n"
21292  "\n"
21293  " This function is used in examples 4, 21 and 26.\n"
21294  "\n"
21295  "\n"
21296  "\n"
21297  "SYNOPSIS:\n"
21298  "\n"
21299  "plstring(n, x, y, string)\n"
21300  "\n"
21301  "ARGUMENTS:\n"
21302  "\n"
21303  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21304  "\n"
21305  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21306  " the points.\n"
21307  "\n"
21308  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21309  " the points.\n"
21310  "\n"
21311  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21312  " the glyph(s) to be plotted at each of the n points.\n"
21313  "\n"
21314  ""},
21315  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
21316  "Plot a glyph at the specified 3D points\n"
21317  "\n"
21318  "DESCRIPTION:\n"
21319  "\n"
21320  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21321  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21322  " this function similar to what is done for plline3. The glyph is\n"
21323  " specified with a PLplot user string. Note that the user string is not\n"
21324  " actually limited to one glyph so it is possible (but not normally\n"
21325  " useful) to plot more than one glyph at the specified points with this\n"
21326  " function. As with plmtex and plptex, the user string can contain FCI\n"
21327  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21328  " else PLplot escapes for Hershey or unicode text to determine the\n"
21329  " glyph.\n"
21330  "\n"
21331  " Redacted form: plstring3(x, y, z, string)\n"
21332  "\n"
21333  " This function is used in example 18.\n"
21334  "\n"
21335  "\n"
21336  "\n"
21337  "SYNOPSIS:\n"
21338  "\n"
21339  "plstring3(n, x, y, z, string)\n"
21340  "\n"
21341  "ARGUMENTS:\n"
21342  "\n"
21343  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21344  "\n"
21345  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21346  " the points.\n"
21347  "\n"
21348  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21349  " the points.\n"
21350  "\n"
21351  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21352  " the points.\n"
21353  "\n"
21354  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21355  " the glyph(s) to be plotted at each of the n points. points.\n"
21356  "\n"
21357  ""},
21358  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
21359  "Add a point to a strip chart\n"
21360  "\n"
21361  "DESCRIPTION:\n"
21362  "\n"
21363  " Add a point to a given pen of a given strip chart. There is no need\n"
21364  " for all pens to have the same number of points or to be equally\n"
21365  " sampled in the x coordinate. Allocates memory and rescales as\n"
21366  " necessary.\n"
21367  "\n"
21368  " Redacted form: plstripa(id, pen, x, y)\n"
21369  "\n"
21370  " This function is used in example 17.\n"
21371  "\n"
21372  "\n"
21373  "\n"
21374  "SYNOPSIS:\n"
21375  "\n"
21376  "plstripa(id, pen, x, y)\n"
21377  "\n"
21378  "ARGUMENTS:\n"
21379  "\n"
21380  " id (PLINT, input) : Identification number of the strip chart (set\n"
21381  " up in plstripc).\n"
21382  "\n"
21383  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21384  "\n"
21385  " x (PLFLT, input) : X coordinate of point to plot.\n"
21386  "\n"
21387  " y (PLFLT, input) : Y coordinate of point to plot.\n"
21388  "\n"
21389  ""},
21390  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
21391  "Create a 4-pen strip chart\n"
21392  "\n"
21393  "DESCRIPTION:\n"
21394  "\n"
21395  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21396  "\n"
21397  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21398  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21399  " styline, legline, labx, laby, labz)\n"
21400  " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
21401  " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
21402  " ypsec, legline, labx, laby, labtop)\n"
21403  "\n"
21404  "\n"
21405  " This function is used in example 17.\n"
21406  "\n"
21407  "\n"
21408  "\n"
21409  "SYNOPSIS:\n"
21410  "\n"
21411  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21412  "\n"
21413  "ARGUMENTS:\n"
21414  "\n"
21415  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21416  " number of the strip chart to use on plstripa and plstripd.\n"
21417  "\n"
21418  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21419  " the x-axis specification as in plbox.\n"
21420  "\n"
21421  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21422  " the y-axis specification as in plbox.\n"
21423  "\n"
21424  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21425  " change as data are added.\n"
21426  "\n"
21427  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21428  " change as data are added.\n"
21429  "\n"
21430  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21431  " is multiplied by the factor (1 +\n"
21432  " xjump) .\n"
21433  "\n"
21434  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21435  " change as data are added.\n"
21436  "\n"
21437  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21438  " change as data are added.\n"
21439  "\n"
21440  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21441  "\n"
21442  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21443  "\n"
21444  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21445  " true, otherwise not.\n"
21446  "\n"
21447  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21448  " otherwise slide display.\n"
21449  "\n"
21450  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21451  "\n"
21452  " collab (PLINT, input) : Legend color index (cmap0).\n"
21453  "\n"
21454  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21455  " indices for the 4 pens.\n"
21456  "\n"
21457  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21458  " indices for the 4 pens.\n"
21459  "\n"
21460  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21461  " strings containing legends for the 4 pens.\n"
21462  "\n"
21463  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21464  " the label for the x axis.\n"
21465  "\n"
21466  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21467  " the label for the y axis.\n"
21468  "\n"
21469  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21470  " the plot title.\n"
21471  "\n"
21472  ""},
21473  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
21474  "Deletes and releases memory used by a strip chart\n"
21475  "\n"
21476  "DESCRIPTION:\n"
21477  "\n"
21478  " Deletes and releases memory used by a strip chart.\n"
21479  "\n"
21480  " Redacted form: plstripd(id)\n"
21481  "\n"
21482  " This function is used in example 17.\n"
21483  "\n"
21484  "\n"
21485  "\n"
21486  "SYNOPSIS:\n"
21487  "\n"
21488  "plstripd(id)\n"
21489  "\n"
21490  "ARGUMENTS:\n"
21491  "\n"
21492  " id (PLINT, input) : Identification number of strip chart to delete.\n"
21493  "\n"
21494  ""},
21495  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
21496  "Set line style\n"
21497  "\n"
21498  "DESCRIPTION:\n"
21499  "\n"
21500  " This sets up the line style for all lines subsequently drawn. A line\n"
21501  " consists of segments in which the pen is alternately down and up. The\n"
21502  " lengths of these segments are passed in the vectors mark and space\n"
21503  " respectively. The number of mark-space pairs is specified by nms. In\n"
21504  " order to return the line style to the default continuous line, plstyl\n"
21505  " should be called with nms =0 .(see also pllsty)\n"
21506  "\n"
21507  " Redacted form: plstyl(mark, space)\n"
21508  "\n"
21509  " This function is used in examples 1, 9, and 14.\n"
21510  "\n"
21511  "\n"
21512  "\n"
21513  "SYNOPSIS:\n"
21514  "\n"
21515  "plstyl(nms, mark, space)\n"
21516  "\n"
21517  "ARGUMENTS:\n"
21518  "\n"
21519  " nms (PLINT, input) : The number of mark and space elements in a\n"
21520  " line. Thus a simple broken line can be obtained by setting nms=1\n"
21521  " . A continuous line is specified by setting nms=0 .\n"
21522  "\n"
21523  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21524  " segments during which the pen is down, measured in micrometers.\n"
21525  "\n"
21526  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21527  " the segments during which the pen is up, measured in micrometers.\n"
21528  "\n"
21529  ""},
21530  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
21531  "Set arrow style for vector plots\n"
21532  "\n"
21533  "DESCRIPTION:\n"
21534  "\n"
21535  " Set the style for the arrow used by plvect to plot vectors.\n"
21536  "\n"
21537  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21538  "\n"
21539  " This function is used in example 22.\n"
21540  "\n"
21541  "\n"
21542  "\n"
21543  "SYNOPSIS:\n"
21544  "\n"
21545  "plsvect(arrowx, arrowy, npts, fill)\n"
21546  "\n"
21547  "ARGUMENTS:\n"
21548  "\n"
21549  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21550  " the x and y points which make up the arrow. The arrow is plotted\n"
21551  " by joining these points to form a polygon. The scaling assumes\n"
21552  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21553  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21554  " will be reset to its default.\n"
21555  "\n"
21556  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21557  " arrowy.\n"
21558  "\n"
21559  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21560  " fill is false then the arrow is open.\n"
21561  "\n"
21562  ""},
21563  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
21564  "Specify viewport in absolute coordinates\n"
21565  "\n"
21566  "DESCRIPTION:\n"
21567  "\n"
21568  " Alternate routine to plvpor for setting up the viewport. This routine\n"
21569  " should be used only if the viewport is required to have a definite\n"
21570  " size in millimeters. The routine plgspa is useful for finding out the\n"
21571  " size of the current subpage.\n"
21572  "\n"
21573  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21574  "\n"
21575  " This function is used in example 10.\n"
21576  "\n"
21577  "\n"
21578  "\n"
21579  "SYNOPSIS:\n"
21580  "\n"
21581  "plsvpa(xmin, xmax, ymin, ymax)\n"
21582  "\n"
21583  "ARGUMENTS:\n"
21584  "\n"
21585  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21586  " viewport from the left-hand edge of the subpage in millimeters.\n"
21587  "\n"
21588  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21589  " viewport from the left-hand edge of the subpage in millimeters.\n"
21590  "\n"
21591  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21592  " viewport from the bottom edge of the subpage in millimeters.\n"
21593  "\n"
21594  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21595  " from the bottom edge of the subpage in millimeters.\n"
21596  "\n"
21597  ""},
21598  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
21599  "Set x axis parameters\n"
21600  "\n"
21601  "DESCRIPTION:\n"
21602  "\n"
21603  " Sets values of the digmax and digits flags for the x axis. See the\n"
21604  " PLplot documentation for more information.\n"
21605  "\n"
21606  " Redacted form: plsxax(digmax, digits)\n"
21607  "\n"
21608  " This function is used in example 31.\n"
21609  "\n"
21610  "\n"
21611  "\n"
21612  "SYNOPSIS:\n"
21613  "\n"
21614  "plsxax(digmax, digits)\n"
21615  "\n"
21616  "ARGUMENTS:\n"
21617  "\n"
21618  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21619  " digits for the x axis. If nonzero, the printed label will be\n"
21620  " switched to a floating-point representation when the number of\n"
21621  " digits exceeds digmax.\n"
21622  "\n"
21623  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21624  " its value here has no effect since it is set only by plbox or\n"
21625  " plbox3. However, the user may obtain its value after a call to\n"
21626  " either of these functions by calling plgxax.\n"
21627  "\n"
21628  ""},
21629  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
21630  "Set y axis parameters\n"
21631  "\n"
21632  "DESCRIPTION:\n"
21633  "\n"
21634  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21635  " the description of plsxax for more detail.\n"
21636  "\n"
21637  " Redacted form: plsyax(digmax, digits)\n"
21638  "\n"
21639  " This function is used in examples 1, 14, and 31.\n"
21640  "\n"
21641  "\n"
21642  "\n"
21643  "SYNOPSIS:\n"
21644  "\n"
21645  "plsyax(digmax, digits)\n"
21646  "\n"
21647  "ARGUMENTS:\n"
21648  "\n"
21649  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21650  " digits for the y axis. If nonzero, the printed label will be\n"
21651  " switched to a floating-point representation when the number of\n"
21652  " digits exceeds digmax.\n"
21653  "\n"
21654  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21655  " its value here has no effect since it is set only by plbox or\n"
21656  " plbox3. However, the user may obtain its value after a call to\n"
21657  " either of these functions by calling plgyax.\n"
21658  "\n"
21659  ""},
21660  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
21661  "Plot a glyph at the specified points\n"
21662  "\n"
21663  "DESCRIPTION:\n"
21664  "\n"
21665  " Plot a glyph at the specified points. (This function is largely\n"
21666  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21667  "\n"
21668  " Redacted form: plsym(x, y, code)\n"
21669  "\n"
21670  " This function is used in example 7.\n"
21671  "\n"
21672  "\n"
21673  "\n"
21674  "SYNOPSIS:\n"
21675  "\n"
21676  "plsym(n, x, y, code)\n"
21677  "\n"
21678  "ARGUMENTS:\n"
21679  "\n"
21680  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21681  "\n"
21682  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21683  " the points.\n"
21684  "\n"
21685  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21686  " the points.\n"
21687  "\n"
21688  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21689  " to be plotted at each of the n points.\n"
21690  "\n"
21691  ""},
21692  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21693  "Set z axis parameters\n"
21694  "\n"
21695  "DESCRIPTION:\n"
21696  "\n"
21697  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21698  " the description of plsxax for more detail.\n"
21699  "\n"
21700  " Redacted form: plszax(digmax, digits)\n"
21701  "\n"
21702  " This function is used in example 31.\n"
21703  "\n"
21704  "\n"
21705  "\n"
21706  "SYNOPSIS:\n"
21707  "\n"
21708  "plszax(digmax, digits)\n"
21709  "\n"
21710  "ARGUMENTS:\n"
21711  "\n"
21712  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21713  " digits for the z axis. If nonzero, the printed label will be\n"
21714  " switched to a floating-point representation when the number of\n"
21715  " digits exceeds digmax.\n"
21716  "\n"
21717  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21718  " its value here has no effect since it is set only by plbox or\n"
21719  " plbox3. However, the user may obtain its value after a call to\n"
21720  " either of these functions by calling plgzax.\n"
21721  "\n"
21722  ""},
21723  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21724  "Switch to text screen\n"
21725  "\n"
21726  "DESCRIPTION:\n"
21727  "\n"
21728  " Sets an interactive device to text mode, used in conjunction with\n"
21729  " plgra to allow graphics and text to be interspersed. On a device\n"
21730  " which supports separate text and graphics windows, this command causes\n"
21731  " control to be switched to the text window. This can be useful for\n"
21732  " printing diagnostic messages or getting user input, which would\n"
21733  " otherwise interfere with the plots. The program must switch back to\n"
21734  " the graphics window before issuing plot commands, as the text (or\n"
21735  " console) device will probably become quite confused otherwise. If\n"
21736  " already in text mode, this command is ignored. It is also ignored on\n"
21737  " devices which only support a single window or use a different method\n"
21738  " for shifting focus (see also plgra).\n"
21739  "\n"
21740  " Redacted form: pltext()\n"
21741  "\n"
21742  " This function is used in example 1.\n"
21743  "\n"
21744  "\n"
21745  "\n"
21746  "SYNOPSIS:\n"
21747  "\n"
21748  "pltext()\n"
21749  "\n"
21750  ""},
21751  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21752  "Set format for date / time labels\n"
21753  "\n"
21754  "DESCRIPTION:\n"
21755  "\n"
21756  " Sets the format for date / time labels. To enable date / time format\n"
21757  " labels see the options to plbox, plbox3, and plenv.\n"
21758  "\n"
21759  " Redacted form: pltimefmt(fmt)\n"
21760  "\n"
21761  " This function is used in example 29.\n"
21762  "\n"
21763  "\n"
21764  "\n"
21765  "SYNOPSIS:\n"
21766  "\n"
21767  "pltimefmt(fmt)\n"
21768  "\n"
21769  "ARGUMENTS:\n"
21770  "\n"
21771  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21772  " interpreted similarly to the format specifier of typical system\n"
21773  " strftime routines except that PLplot ignores locale and also\n"
21774  " supplies some useful extensions in the context of plotting. All\n"
21775  " text in the string is printed as-is other than conversion\n"
21776  " specifications which take the form of a '%' character followed by\n"
21777  " further conversion specification character. The conversion\n"
21778  " specifications which are similar to those provided by system\n"
21779  " strftime routines are the following: %a: The abbreviated (English)\n"
21780  " weekday name.\n"
21781  " %A: The full (English) weekday name.\n"
21782  " %b: The abbreviated (English) month name.\n"
21783  " %B: The full (English) month name.\n"
21784  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21785  " %C: The century number (year/100) as a 2-digit integer.\n"
21786  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21787  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21788  " %e: Like %d, but a leading zero is replaced by a space.\n"
21789  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21790  " %h: Equivalent to %b.\n"
21791  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21792  " 00 to 23).\n"
21793  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21794  " 01 to 12).\n"
21795  " %j: The day of the year as a decimal number (range 001 to\n"
21796  " 366).\n"
21797  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21798  " 23); single digits are preceded by a blank. (See also %H.)\n"
21799  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21800  " 12); single digits are preceded by a blank. (See also %I.)\n"
21801  " %m: The month as a decimal number (range 01 to 12).\n"
21802  " %M: The minute as a decimal number (range 00 to 59).\n"
21803  " %n: A newline character.\n"
21804  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21805  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21806  " %r: Equivalent to %I:%M:%S %p.\n"
21807  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21808  " including the seconds, see %T below.\n"
21809  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21810  " +0000 (UTC).\n"
21811  " %S: The second as a decimal number (range 00 to 60). (The\n"
21812  " range is up to 60 to allow for occasional leap seconds.)\n"
21813  " %t: A tab character.\n"
21814  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21815  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21816  " being 1. See also %w.\n"
21817  " %U: The week number of the current year as a decimal number,\n"
21818  " range 00 to 53, starting with the first Sunday as the first\n"
21819  " day of week 01. See also %V and %W.\n"
21820  " %v: Equivalent to %e-%b-%Y.\n"
21821  " %V: The ISO 8601 week number of the current year as a decimal\n"
21822  " number, range 01 to 53, where week 1 is the first week that\n"
21823  " has at least 4 days in the new year. See also %U and %W.\n"
21824  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21825  " being 0. See also %u.\n"
21826  " %W: The week number of the current year as a decimal number,\n"
21827  " range 00 to 53, starting with the first Monday as the first\n"
21828  " day of week 01.\n"
21829  " %x: Equivalent to %a %b %d %Y.\n"
21830  " %X: Equivalent to %T.\n"
21831  " %y: The year as a decimal number without a century (range 00\n"
21832  " to 99).\n"
21833  " %Y: The year as a decimal number including a century.\n"
21834  " %z: The UTC time-zone string = \"+0000\".\n"
21835  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21836  " %+: The UTC date and time in default format of the Unix date\n"
21837  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21838  " %%: A literal \"%\" character.\n"
21839  " The conversion specifications which are extensions to those normally\n"
21840  " provided by system strftime routines are the following: %(0-9):\n"
21841  " The fractional part of the seconds field (including leading\n"
21842  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21843  " seconds to millisecond accuracy (00.000).\n"
21844  " %.: The fractional part of the seconds field (including\n"
21845  " leading decimal point) to the maximum available accuracy. Thus\n"
21846  " %S%. would give seconds with fractional part up to 9 decimal\n"
21847  " places if available.\n"
21848  "\n"
21849  ""},
21850  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
21851  "Specify viewport using aspect ratio only\n"
21852  "\n"
21853  "DESCRIPTION:\n"
21854  "\n"
21855  " Selects the largest viewport with the given aspect ratio within the\n"
21856  " subpage that leaves a standard margin (left-hand margin of eight\n"
21857  " character heights, and a margin around the other three sides of five\n"
21858  " character heights).\n"
21859  "\n"
21860  " Redacted form: plvasp(aspect)\n"
21861  "\n"
21862  " This function is used in example 13.\n"
21863  "\n"
21864  "\n"
21865  "\n"
21866  "SYNOPSIS:\n"
21867  "\n"
21868  "plvasp(aspect)\n"
21869  "\n"
21870  "ARGUMENTS:\n"
21871  "\n"
21872  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21873  " axis of resulting viewport.\n"
21874  "\n"
21875  ""},
21876  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
21877  "Vector plot\n"
21878  "\n"
21879  "DESCRIPTION:\n"
21880  "\n"
21881  " Draws a plot of vector data contained in the matrices (\n"
21882  " u[\n"
21883  " nx][\n"
21884  " ny],\n"
21885  " v[\n"
21886  " nx][\n"
21887  " ny]) . The scaling factor for the vectors is given by scale. A\n"
21888  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21889  " additional data required by the transformation routine to map indices\n"
21890  " within the matrices to the world coordinates. The style of the vector\n"
21891  " arrow may be set using plsvect.\n"
21892  "\n"
21893  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21894  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21895  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21896  " with either one or two dimensions.\n"
21897  "\n"
21898  " This function is used in example 22.\n"
21899  "\n"
21900  "\n"
21901  "\n"
21902  "SYNOPSIS:\n"
21903  "\n"
21904  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21905  "\n"
21906  "ARGUMENTS:\n"
21907  "\n"
21908  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21909  " and y components of the vector data to be plotted.\n"
21910  "\n"
21911  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21912  "\n"
21913  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21914  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21915  " automatically calculated for the data. If scale < 0 then the\n"
21916  " scaling factor is automatically calculated for the data and then\n"
21917  " multiplied by -\n"
21918  " scale. If scale > 0 then the scaling factor is set to scale.\n"
21919  "\n"
21920  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21921  " defines the transformation between the zero-based indices of the\n"
21922  " matrices u and v and world coordinates.For the C case,\n"
21923  " transformation functions are provided in the PLplot library: pltr0\n"
21924  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21925  " mappings respectively defined by vectors and matrices. In\n"
21926  " addition, C callback routines for the transformation can be\n"
21927  " supplied by the user such as the mypltr function in\n"
21928  " examples/c/x09c.c which provides a general linear transformation\n"
21929  " between index coordinates and world coordinates.For languages\n"
21930  " other than C you should consult the PLplot documentation for the\n"
21931  " details concerning how PLTRANSFORM_callback arguments are\n"
21932  " interfaced. However, in general, a particular pattern of\n"
21933  " callback-associated arguments such as a tr vector with 6 elements;\n"
21934  " xg and yg vectors; or xg and yg matrices are respectively\n"
21935  " interfaced to a linear-transformation routine similar to the above\n"
21936  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21937  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21938  " support native language callbacks for handling index to\n"
21939  " world-coordinate transformations. Examples of these various\n"
21940  " approaches are given in examples/<language>x09*,\n"
21941  " examples/<language>x16*, examples/<language>x20*,\n"
21942  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21943  " supported languages.\n"
21944  "\n"
21945  " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
21946  " pass information to pltr0, pltr1, pltr2, or whatever callback\n"
21947  " routine that is externally supplied.\n"
21948  "\n"
21949  ""},
21950  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
21951  "Specify viewport using coordinates and aspect ratio\n"
21952  "\n"
21953  "DESCRIPTION:\n"
21954  "\n"
21955  " Device-independent routine for setting up the viewport. The viewport\n"
21956  " is chosen to be the largest with the given aspect ratio that fits\n"
21957  " within the specified region (in terms of normalized subpage\n"
21958  " coordinates). This routine is functionally equivalent to plvpor when\n"
21959  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21960  " routine reserves no extra space at the edges for labels.\n"
21961  "\n"
21962  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21963  "\n"
21964  " This function is used in example 9.\n"
21965  "\n"
21966  "\n"
21967  "\n"
21968  "SYNOPSIS:\n"
21969  "\n"
21970  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21971  "\n"
21972  "ARGUMENTS:\n"
21973  "\n"
21974  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21975  " left-hand edge of the viewport.\n"
21976  "\n"
21977  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21978  " right-hand edge of the viewport.\n"
21979  "\n"
21980  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21981  " bottom edge of the viewport.\n"
21982  "\n"
21983  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21984  " edge of the viewport.\n"
21985  "\n"
21986  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21987  " axis.\n"
21988  "\n"
21989  ""},
21990  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
21991  "Specify viewport using normalized subpage coordinates\n"
21992  "\n"
21993  "DESCRIPTION:\n"
21994  "\n"
21995  " Device-independent routine for setting up the viewport. This defines\n"
21996  " the viewport in terms of normalized subpage coordinates which run from\n"
21997  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21998  " current subpage. Use the alternate routine plsvpa in order to create\n"
21999  " a viewport of a definite size.\n"
22000  "\n"
22001  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22002  "\n"
22003  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22004  " 24, 26, 27, and 31.\n"
22005  "\n"
22006  "\n"
22007  "\n"
22008  "SYNOPSIS:\n"
22009  "\n"
22010  "plvpor(xmin, xmax, ymin, ymax)\n"
22011  "\n"
22012  "ARGUMENTS:\n"
22013  "\n"
22014  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22015  " left-hand edge of the viewport.\n"
22016  "\n"
22017  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22018  " right-hand edge of the viewport.\n"
22019  "\n"
22020  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22021  " bottom edge of the viewport.\n"
22022  "\n"
22023  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22024  " edge of the viewport.\n"
22025  "\n"
22026  ""},
22027  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
22028  "Select standard viewport\n"
22029  "\n"
22030  "DESCRIPTION:\n"
22031  "\n"
22032  " Selects the largest viewport within the subpage that leaves a standard\n"
22033  " margin (left-hand margin of eight character heights, and a margin\n"
22034  " around the other three sides of five character heights).\n"
22035  "\n"
22036  " Redacted form: plvsta()\n"
22037  "\n"
22038  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22039  "\n"
22040  "\n"
22041  "\n"
22042  "SYNOPSIS:\n"
22043  "\n"
22044  "plvsta()\n"
22045  "\n"
22046  ""},
22047  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
22048  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22049  "\n"
22050  "DESCRIPTION:\n"
22051  "\n"
22052  " Configure the transformations required for projecting a 3D surface on\n"
22053  " an existing 2D window. Those transformations (see the PLplot\n"
22054  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22055  " surface which has its limits expressed in 3D world coordinates and\n"
22056  " also normalized 3D coordinates (used for interpreting the altitude and\n"
22057  " azimuth of the viewing angle). The transformations consist of the\n"
22058  " linear transform from 3D world coordinates to normalized 3D\n"
22059  " coordinates, and the 3D rotation of normalized coordinates required to\n"
22060  " align the pole of the new 3D coordinate system with the viewing\n"
22061  " direction specified by altitude and azimuth so that x and y of the\n"
22062  " surface elements in that transformed coordinate system are the\n"
22063  " projection of the 3D surface with given viewing direction on the 2D\n"
22064  " window.\n"
22065  "\n"
22066  " The enclosing rectangular cuboid for the surface plot is defined by\n"
22067  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22068  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22069  " sizes of basex by basey by height so that xmin maps to -\n"
22070  " basex/2, xmax maps to basex/2, ymin maps to -\n"
22071  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22072  " The resulting rectangular cuboid in normalized coordinates is then\n"
22073  " viewed by an observer at altitude alt and azimuth az. This routine\n"
22074  " must be called before plbox3 or any of the 3D surface plotting\n"
22075  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22076  " plsurf3dl or plfill3.\n"
22077  "\n"
22078  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22079  " zmin, zmax, alt, az)\n"
22080  "\n"
22081  " This function is examples 8, 11, 18, and 21.\n"
22082  "\n"
22083  "\n"
22084  "\n"
22085  "SYNOPSIS:\n"
22086  "\n"
22087  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22088  "\n"
22089  "ARGUMENTS:\n"
22090  "\n"
22091  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22092  " rectangular cuboid.\n"
22093  "\n"
22094  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22095  " rectangular cuboid.\n"
22096  "\n"
22097  " height (PLFLT, input) : The normalized z coordinate size of the\n"
22098  " rectangular cuboid.\n"
22099  "\n"
22100  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22101  " rectangular cuboid.\n"
22102  "\n"
22103  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22104  " rectangular cuboid.\n"
22105  "\n"
22106  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22107  " rectangular cuboid.\n"
22108  "\n"
22109  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22110  " rectangular cuboid.\n"
22111  "\n"
22112  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22113  " rectangular cuboid.\n"
22114  "\n"
22115  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22116  " rectangular cuboid.\n"
22117  "\n"
22118  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22119  " plane of the rectangular cuboid in normalized coordinates.\n"
22120  "\n"
22121  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22122  " rectangular cuboid in normalized coordinates. When az=0, the\n"
22123  " observer is looking face onto the zx plane of the rectangular\n"
22124  " cuboid in normalized coordinates, and as az is increased, the\n"
22125  " observer moves clockwise around that cuboid when viewed from above\n"
22126  " the xy plane.\n"
22127  "\n"
22128  ""},
22129  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
22130  "Set pen width\n"
22131  "\n"
22132  "DESCRIPTION:\n"
22133  "\n"
22134  " Sets the pen width.\n"
22135  "\n"
22136  " Redacted form: plwidth(width)\n"
22137  "\n"
22138  " This function is used in examples 1 and 2.\n"
22139  "\n"
22140  "\n"
22141  "\n"
22142  "SYNOPSIS:\n"
22143  "\n"
22144  "plwidth(width)\n"
22145  "\n"
22146  "ARGUMENTS:\n"
22147  "\n"
22148  " width (PLFLT, input) : The desired pen width. If width is negative\n"
22149  " or the same as the previous value no action is taken. width = 0.\n"
22150  " should be interpreted as as the minimum valid pen width for the\n"
22151  " device. The interpretation of positive width values is also\n"
22152  " device dependent.\n"
22153  "\n"
22154  ""},
22155  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
22156  "Specify window\n"
22157  "\n"
22158  "DESCRIPTION:\n"
22159  "\n"
22160  " Specify the window, i.e., the world coordinates of the edges of the\n"
22161  " viewport.\n"
22162  "\n"
22163  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22164  "\n"
22165  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22166  " 29, and 31.\n"
22167  "\n"
22168  "\n"
22169  "\n"
22170  "SYNOPSIS:\n"
22171  "\n"
22172  "plwind(xmin, xmax, ymin, ymax)\n"
22173  "\n"
22174  "ARGUMENTS:\n"
22175  "\n"
22176  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22177  " of the viewport.\n"
22178  "\n"
22179  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22180  " of the viewport.\n"
22181  "\n"
22182  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22183  " the viewport.\n"
22184  "\n"
22185  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22186  " viewport.\n"
22187  "\n"
22188  ""},
22189  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
22190  "Enter or leave xor mode\n"
22191  "\n"
22192  "DESCRIPTION:\n"
22193  "\n"
22194  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22195  " those drivers (e.g., the xwin driver) that support it. Enables\n"
22196  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22197  " is not capable of xor operation it returns a status of false.\n"
22198  "\n"
22199  " Redacted form: plxormod(mode, status)\n"
22200  "\n"
22201  " This function is used in examples 1 and 20.\n"
22202  "\n"
22203  "\n"
22204  "\n"
22205  "SYNOPSIS:\n"
22206  "\n"
22207  "plxormod(mode, status)\n"
22208  "\n"
22209  "ARGUMENTS:\n"
22210  "\n"
22211  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22212  " is false means leave xor mode.\n"
22213  "\n"
22214  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22215  " modestatus of true (false) means driver is capable (incapable) of\n"
22216  " xor mode.\n"
22217  "\n"
22218  ""},
22219  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
22220  "Plot continental outline or shapefile data in world coordinates\n"
22221  "\n"
22222  "DESCRIPTION:\n"
22223  "\n"
22224  " Plots continental outlines or shapefile data in world coordinates. A\n"
22225  " demonstration of how to use this function to create different\n"
22226  " projections can be found in examples/c/x19c. PLplot is provided with\n"
22227  " basic coastal outlines and USA state borders. These can be used\n"
22228  " irrespective of whether Shapefile support is built into PLplot. With\n"
22229  " Shapefile support this function can also be used with user Shapefiles,\n"
22230  " in which case it will plot the entire contents of a Shapefile joining\n"
22231  " each point of each Shapefile element with a line. Shapefiles have\n"
22232  " become a popular standard for geographical data and data in this\n"
22233  " format can be easily found from a number of online sources. Shapefile\n"
22234  " data is actually provided as three or more files with the same\n"
22235  " filename, but different extensions. The .shp and .shx files are\n"
22236  " required for plotting Shapefile data with PLplot.\n"
22237  "\n"
22238  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22239  "\n"
22240  " This function is used in example 19.\n"
22241  "\n"
22242  "\n"
22243  "\n"
22244  "SYNOPSIS:\n"
22245  "\n"
22246  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22247  "\n"
22248  "ARGUMENTS:\n"
22249  "\n"
22250  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22251  " transform the original map data coordinates to a new coordinate\n"
22252  " system. The PLplot-supplied map data is provided as latitudes and\n"
22253  " longitudes; other Shapefile data may be provided in other\n"
22254  " coordinate systems as can be found in their .prj plain text files.\n"
22255  " For example, by using this transform we can change from a\n"
22256  " longitude, latitude coordinate to a polar stereographic\n"
22257  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22258  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22259  " corresponding y coordinates (latitudes for the PLplot supplied\n"
22260  " data). After the call to mapform(), x[] and y[] should be\n"
22261  " replaced by the corresponding plot coordinates. If no transform is\n"
22262  " desired, mapform can be replaced by NULL.\n"
22263  "\n"
22264  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22265  " the type of map plotted. This is either one of the PLplot built-in\n"
22266  " maps or the file name of a set of Shapefile files without the file\n"
22267  " extensions. For the PLplot built-in maps the possible values are:\n"
22268  " \"globe\" -- continental outlines\n"
22269  " \"usa\" -- USA and state boundaries\n"
22270  " \"cglobe\" -- continental outlines and countries\n"
22271  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22272  "\n"
22273  "\n"
22274  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22275  " drawn. For the built in maps this is a measure of longitude. For\n"
22276  " Shapefiles the units must match the projection. The value of minx\n"
22277  " must be less than the value of maxx. Specifying a useful limit for\n"
22278  " these limits provides a useful optimization for complex or\n"
22279  " detailed maps.\n"
22280  "\n"
22281  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22282  " drawn\n"
22283  "\n"
22284  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22285  " drawn. For the built in maps this is a measure of latitude. For\n"
22286  " Shapefiles the units must match the projection. The value of miny\n"
22287  " must be less than the value of maxy.\n"
22288  "\n"
22289  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22290  " drawn.\n"
22291  "\n"
22292  ""},
22293  { (char *)"plmapline", _wrap_plmapline, METH_VARARGS, (char *)"\n"
22294  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22295  "\n"
22296  "DESCRIPTION:\n"
22297  "\n"
22298  " Plot all or a subset of Shapefile data using lines in world\n"
22299  " coordinates. Our 19th standard example demonstrates how to use this\n"
22300  " function. This function plots data from a Shapefile using lines as in\n"
22301  " plmap, however it also has the option of also only drawing specified\n"
22302  " elements from the Shapefile. The vector of indices of the required\n"
22303  " elements are passed as a function argument. The Shapefile data should\n"
22304  " include a metadata file (extension.dbf) listing all items within the\n"
22305  " Shapefile. This file can be opened by most popular spreadsheet\n"
22306  " programs and can be used to decide which indices to pass to this\n"
22307  " function.\n"
22308  "\n"
22309  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22310  " plotentries)\n"
22311  "\n"
22312  " This function is used in example 19.\n"
22313  "\n"
22314  "\n"
22315  "\n"
22316  "SYNOPSIS:\n"
22317  "\n"
22318  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22319  "\n"
22320  "ARGUMENTS:\n"
22321  "\n"
22322  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22323  " transform the coordinates given in the shapefile into a plot\n"
22324  " coordinate system. By using this transform, we can change from a\n"
22325  " longitude, latitude coordinate to a polar stereographic project,\n"
22326  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22327  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22328  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22329  " plot coordinates. If no transform is desired, mapform can be\n"
22330  " replaced by NULL.\n"
22331  "\n"
22332  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22333  " the file name of a set of Shapefile files without the file\n"
22334  " extension.\n"
22335  "\n"
22336  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22337  " be in the same units as used by the Shapefile. You could use a\n"
22338  " very large negative number to plot everything, but you can improve\n"
22339  " performance by limiting the area drawn. The units must match those\n"
22340  " of the Shapefile projection, which may be for example longitude or\n"
22341  " distance. The value of minx must be less than the value of maxx.\n"
22342  "\n"
22343  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22344  " use a very large number to plot everything, but you can improve\n"
22345  " performance by limiting the area drawn.\n"
22346  "\n"
22347  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22348  " be in the same units as used by the Shapefile. You could use a\n"
22349  " very large negative number to plot everything, but you can improve\n"
22350  " performance by limiting the area drawn. The units must match those\n"
22351  " of the Shapefile projection, which may be for example latitude or\n"
22352  " distance. The value of miny must be less than the value of maxy.\n"
22353  "\n"
22354  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22355  " use a very large number to plot everything, but you can improve\n"
22356  " performance by limiting the area drawn.\n"
22357  "\n"
22358  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22359  " zero-based indices of the Shapefile elements which will be drawn.\n"
22360  " Setting\n"
22361  " plotentries to NULL will plot all elements of the Shapefile.\n"
22362  "\n"
22363  " nplotentries (PLINT, input) : The number of items in\n"
22364  " plotentries. Ignored if\n"
22365  " plotentries is NULL.\n"
22366  "\n"
22367  ""},
22368  { (char *)"plmapstring", _wrap_plmapstring, METH_VARARGS, (char *)"\n"
22369  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22370  "\n"
22371  "DESCRIPTION:\n"
22372  "\n"
22373  " As per plmapline, however the items are plotted as strings or points\n"
22374  " in the same way as plstring.\n"
22375  "\n"
22376  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22377  " maxy, plotentries)\n"
22378  "\n"
22379  " This function is not used in any examples.\n"
22380  "\n"
22381  "\n"
22382  "\n"
22383  "SYNOPSIS:\n"
22384  "\n"
22385  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22386  "\n"
22387  "ARGUMENTS:\n"
22388  "\n"
22389  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22390  " transform the coordinates given in the shapefile into a plot\n"
22391  " coordinate system. By using this transform, we can change from a\n"
22392  " longitude, latitude coordinate to a polar stereographic project,\n"
22393  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22394  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22395  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22396  " plot coordinates. If no transform is desired, mapform can be\n"
22397  " replaced by NULL.\n"
22398  "\n"
22399  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22400  " the file name of a set of Shapefile files without the file\n"
22401  " extension.\n"
22402  "\n"
22403  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22404  " drawn.\n"
22405  "\n"
22406  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22407  " be in the same units as used by the Shapefile. You could use a\n"
22408  " very large negative number to plot everything, but you can improve\n"
22409  " performance by limiting the area drawn. The units must match those\n"
22410  " of the Shapefile projection, which may be for example longitude or\n"
22411  " distance. The value of minx must be less than the value of maxx.\n"
22412  "\n"
22413  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22414  " use a very large number to plot everything, but you can improve\n"
22415  " performance by limiting the area drawn.\n"
22416  "\n"
22417  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22418  " be in the same units as used by the Shapefile. You could use a\n"
22419  " very large negative number to plot everything, but you can improve\n"
22420  " performance by limiting the area drawn. The units must match those\n"
22421  " of the Shapefile projection, which may be for example latitude or\n"
22422  " distance. The value of miny must be less than the value of maxy.\n"
22423  "\n"
22424  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22425  " use a very large number to plot everything, but you can improve\n"
22426  " performance by limiting the area drawn.\n"
22427  "\n"
22428  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22429  " zero-based indices of the Shapefile elements which will be drawn.\n"
22430  " Setting\n"
22431  " plotentries to NULL will plot all elements of the Shapefile.\n"
22432  "\n"
22433  " nplotentries (PLINT, input) : The number of items in\n"
22434  " plotentries. Ignored if\n"
22435  " plotentries is NULL.\n"
22436  "\n"
22437  ""},
22438  { (char *)"plmaptex", _wrap_plmaptex, METH_VARARGS, (char *)"\n"
22439  "Draw text at points defined by Shapefile data in world coordinates\n"
22440  "\n"
22441  "DESCRIPTION:\n"
22442  "\n"
22443  " As per plmapline, however the items are plotted as text in the same\n"
22444  " way as plptex.\n"
22445  "\n"
22446  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22447  " miny, maxy, plotentry)\n"
22448  "\n"
22449  " This function is used in example 19.\n"
22450  "\n"
22451  "\n"
22452  "\n"
22453  "SYNOPSIS:\n"
22454  "\n"
22455  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22456  "\n"
22457  "ARGUMENTS:\n"
22458  "\n"
22459  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22460  " transform the coordinates given in the shapefile into a plot\n"
22461  " coordinate system. By using this transform, we can change from a\n"
22462  " longitude, latitude coordinate to a polar stereographic project,\n"
22463  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22464  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22465  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22466  " plot coordinates. If no transform is desired, mapform can be\n"
22467  " replaced by NULL.\n"
22468  "\n"
22469  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22470  " the file name of a set of Shapefile files without the file\n"
22471  " extension.\n"
22472  "\n"
22473  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22474  " dy/dx.\n"
22475  "\n"
22476  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22477  " dy/dx.\n"
22478  "\n"
22479  " just (PLFLT, input) : Set the justification of the text. The value\n"
22480  " given will be the fraction of the distance along the string that\n"
22481  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22482  " centralized text and 1.0 gives right aligned text.\n"
22483  "\n"
22484  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22485  "\n"
22486  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22487  " be in the same units as used by the Shapefile. You could use a\n"
22488  " very large negative number to plot everything, but you can improve\n"
22489  " performance by limiting the area drawn. The units must match those\n"
22490  " of the Shapefile projection, which may be for example longitude or\n"
22491  " distance. The value of minx must be less than the value of maxx.\n"
22492  "\n"
22493  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22494  " use a very large number to plot everything, but you can improve\n"
22495  " performance by limiting the area drawn.\n"
22496  "\n"
22497  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22498  " be in the same units as used by the Shapefile. You could use a\n"
22499  " very large negative number to plot everything, but you can improve\n"
22500  " performance by limiting the area drawn. The units must match those\n"
22501  " of the Shapefile projection, which may be for example latitude or\n"
22502  " distance. The value of miny must be less than the value of maxy.\n"
22503  "\n"
22504  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22505  " use a very large number to plot everything, but you can improve\n"
22506  " performance by limiting the area drawn.\n"
22507  "\n"
22508  " plotentry (PLINT, input) : An integer indicating which text string\n"
22509  " of the Shapefile (zero indexed) will be drawn.\n"
22510  "\n"
22511  ""},
22512  { (char *)"plmapfill", _wrap_plmapfill, METH_VARARGS, (char *)"\n"
22513  "Plot all or a subset of Shapefile data, filling the polygons\n"
22514  "\n"
22515  "DESCRIPTION:\n"
22516  "\n"
22517  " As per plmapline, however the items are filled in the same way as\n"
22518  " plfill.\n"
22519  "\n"
22520  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22521  " plotentries)\n"
22522  "\n"
22523  " This function is used in example 19.\n"
22524  "\n"
22525  "\n"
22526  "\n"
22527  "SYNOPSIS:\n"
22528  "\n"
22529  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22530  "\n"
22531  "ARGUMENTS:\n"
22532  "\n"
22533  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22534  " transform the coordinates given in the shapefile into a plot\n"
22535  " coordinate system. By using this transform, we can change from a\n"
22536  " longitude, latitude coordinate to a polar stereographic project,\n"
22537  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22538  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22539  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22540  " plot coordinates. If no transform is desired, mapform can be\n"
22541  " replaced by NULL.\n"
22542  "\n"
22543  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22544  " the file name of a set of Shapefile files without the file\n"
22545  " extension.\n"
22546  "\n"
22547  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22548  " be in the same units as used by the Shapefile. You could use a\n"
22549  " very large negative number to plot everything, but you can improve\n"
22550  " performance by limiting the area drawn. The units must match those\n"
22551  " of the Shapefile projection, which may be for example longitude or\n"
22552  " distance. The value of minx must be less than the value of maxx.\n"
22553  "\n"
22554  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22555  " use a very large number to plot everything, but you can improve\n"
22556  " performance by limiting the area drawn.\n"
22557  "\n"
22558  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22559  " be in the same units as used by the Shapefile. You could use a\n"
22560  " very large negative number to plot everything, but you can improve\n"
22561  " performance by limiting the area drawn. The units must match those\n"
22562  " of the Shapefile projection, which may be for example latitude or\n"
22563  " distance. The value of miny must be less than the value of maxy.\n"
22564  "\n"
22565  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22566  " use a very large number to plot everything, but you can improve\n"
22567  " performance by limiting the area drawn.\n"
22568  "\n"
22569  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22570  " zero-based indices of the Shapefile elements which will be drawn.\n"
22571  " Setting\n"
22572  " plotentries to NULL will plot all elements of the Shapefile.\n"
22573  "\n"
22574  " nplotentries (PLINT, input) : The number of items in\n"
22575  " plotentries. Ignored if\n"
22576  " plotentries is NULL.\n"
22577  "\n"
22578  ""},
22579  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
22580  "Plot latitude and longitude lines\n"
22581  "\n"
22582  "DESCRIPTION:\n"
22583  "\n"
22584  " Displays latitude and longitude on the current plot. The lines are\n"
22585  " plotted in the current color and line style.\n"
22586  "\n"
22587  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22588  " minlat, maxlat)\n"
22589  "\n"
22590  " This function is used in example 19.\n"
22591  "\n"
22592  "\n"
22593  "\n"
22594  "SYNOPSIS:\n"
22595  "\n"
22596  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22597  "\n"
22598  "ARGUMENTS:\n"
22599  "\n"
22600  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22601  " transform the coordinate longitudes and latitudes to a plot\n"
22602  " coordinate system. By using this transform, we can change from a\n"
22603  " longitude, latitude coordinate to a polar stereographic project,\n"
22604  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22605  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22606  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22607  " plot coordinates. If no transform is desired, mapform can be\n"
22608  " replaced by NULL.\n"
22609  "\n"
22610  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22611  " longitude lines are to be plotted.\n"
22612  "\n"
22613  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22614  " lines are to be plotted.\n"
22615  "\n"
22616  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22617  " side of the plot. The value of minlong must be less than the value\n"
22618  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22619  " equal to 360.\n"
22620  "\n"
22621  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22622  " side of the plot.\n"
22623  "\n"
22624  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22625  " background. One can always use -90.0 as the boundary outside the\n"
22626  " plot window will be automatically eliminated. However, the\n"
22627  " program will be faster if one can reduce the size of the\n"
22628  " background plotted.\n"
22629  "\n"
22630  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22631  " background. One can always use 90.0 as the boundary outside the\n"
22632  " plot window will be automatically eliminated.\n"
22633  "\n"
22634  ""},
22635  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
22636  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22637  "\n"
22638  "DESCRIPTION:\n"
22639  "\n"
22640  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22641  " automatically adjusted to use the maximum and minimum values in idata\n"
22642  " as valuemin and valuemax in a call to plimagefr.\n"
22643  "\n"
22644  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22645  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22646  "\n"
22647  "\n"
22648  " This function is used in example 20.\n"
22649  "\n"
22650  "\n"
22651  "\n"
22652  "SYNOPSIS:\n"
22653  "\n"
22654  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22655  "\n"
22656  "ARGUMENTS:\n"
22657  "\n"
22658  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22659  " to plot. Should have dimensions of\n"
22660  " nx by\n"
22661  " ny.\n"
22662  "\n"
22663  " nx, ny (PLINT, input) : Dimensions of idata\n"
22664  "\n"
22665  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22666  " are linearly transformed to these world coordinate ranges such\n"
22667  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22668  " - 1] corresponds to (xmax, ymax).\n"
22669  "\n"
22670  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22671  " (inclusive) will be plotted.\n"
22672  "\n"
22673  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22674  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22675  " Dymin) to (Dxmax, Dymax).\n"
22676  "\n"
22677  ""},
22678  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
22679  "Plot a 2D matrix using cmap1\n"
22680  "\n"
22681  "DESCRIPTION:\n"
22682  "\n"
22683  " Plot a 2D matrix using cmap1.\n"
22684  "\n"
22685  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22686  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22687  "\n"
22688  "\n"
22689  " This function is used in example 20.\n"
22690  "\n"
22691  "\n"
22692  "\n"
22693  "SYNOPSIS:\n"
22694  "\n"
22695  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22696  "\n"
22697  "ARGUMENTS:\n"
22698  "\n"
22699  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22700  " plot. Should have dimensions of\n"
22701  " nx by\n"
22702  " ny.\n"
22703  "\n"
22704  " nx, ny (PLINT, input) : Dimensions of idata\n"
22705  "\n"
22706  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22707  " pltr below for how these arguments are used (only for the special case\n"
22708  " when the callback function\n"
22709  " pltr is not supplied).\n"
22710  "\n"
22711  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22712  " (inclusive) will be plotted.\n"
22713  "\n"
22714  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22715  " values to use for value to color mappings. A datum equal to or\n"
22716  " less than valuemin will be plotted with color 0.0, while a datum\n"
22717  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22718  " Data between valuemin and valuemax map linearly to colors in the\n"
22719  " range (0.0-1.0).\n"
22720  "\n"
22721  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22722  " defines the transformation between the zero-based indices of the\n"
22723  " matrix idata and world coordinates. If\n"
22724  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22725  " indices of idata are mapped to the range\n"
22726  " xmin through\n"
22727  " xmax and the y indices of idata are mapped to the range\n"
22728  " ymin through\n"
22729  " ymax.For the C case, transformation functions are provided in the\n"
22730  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22731  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22732  " matrices. In addition, C callback routines for the transformation\n"
22733  " can be supplied by the user such as the mypltr function in\n"
22734  " examples/c/x09c.c which provides a general linear transformation\n"
22735  " between index coordinates and world coordinates.For languages\n"
22736  " other than C you should consult the PLplot documentation for the\n"
22737  " details concerning how PLTRANSFORM_callback arguments are\n"
22738  " interfaced. However, in general, a particular pattern of\n"
22739  " callback-associated arguments such as a tr vector with 6 elements;\n"
22740  " xg and yg vectors; or xg and yg matrices are respectively\n"
22741  " interfaced to a linear-transformation routine similar to the above\n"
22742  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22743  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22744  " support native language callbacks for handling index to\n"
22745  " world-coordinate transformations. Examples of these various\n"
22746  " approaches are given in examples/<language>x09*,\n"
22747  " examples/<language>x16*, examples/<language>x20*,\n"
22748  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22749  " supported languages.\n"
22750  "\n"
22751  " pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n"
22752  " pass information to pltr0, pltr1, pltr2, or whatever routine is\n"
22753  " externally supplied.\n"
22754  "\n"
22755  ""},
22756  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
22757  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
22758  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22759  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
22760  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
22761  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, (char *)"\n"
22762  "Wait for graphics input event and translate to world coordinates.\n"
22763  "\n"
22764  "DESCRIPTION:\n"
22765  "\n"
22766  " Wait for graphics input event and translate to world coordinates.\n"
22767  " Returns 0 if no translation to world coordinates is possible.\n"
22768  "\n"
22769  " This function returns 1 on success and 0 if no translation to world\n"
22770  " coordinates is possible.\n"
22771  "\n"
22772  " Redacted form: plGetCursor(gin)\n"
22773  "\n"
22774  " This function is used in examples 1 and 20.\n"
22775  "\n"
22776  "\n"
22777  "\n"
22778  "SYNOPSIS:\n"
22779  "\n"
22780  "PLINT plGetCursor(gin)\n"
22781  "\n"
22782  "ARGUMENTS:\n"
22783  "\n"
22784  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22785  " which will contain the output. The structure is not allocated by\n"
22786  " the routine and must exist before the function is called.\n"
22787  "\n"
22788  ""},
22789  { NULL, NULL, 0, NULL }
22790 };
22791 
22792 
22793 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22794 
22795 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22796 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22797 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22798 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22799 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22800 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};
22801 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};
22802 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};
22803 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};
22804 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};
22805 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22806 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22807 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22808 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22809 
22814  &_swigt__p_char,
22821  &_swigt__p_int,
22825 };
22826 
22827 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22828 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22829 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22830 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22831 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22837 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22838 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22839 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22840 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22841 
22853  _swigc__p_int,
22857 };
22858 
22859 
22860 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22861 
22863 {0, 0, 0, 0.0, 0, 0}};
22864 
22865 #ifdef __cplusplus
22866 }
22867 #endif
22868 /* -----------------------------------------------------------------------------
22869  * Type initialization:
22870  * This problem is tough by the requirement that no dynamic
22871  * memory is used. Also, since swig_type_info structures store pointers to
22872  * swig_cast_info structures and swig_cast_info structures store pointers back
22873  * to swig_type_info structures, we need some lookup code at initialization.
22874  * The idea is that swig generates all the structures that are needed.
22875  * The runtime then collects these partially filled structures.
22876  * The SWIG_InitializeModule function takes these initial arrays out of
22877  * swig_module, and does all the lookup, filling in the swig_module.types
22878  * array with the correct data and linking the correct swig_cast_info
22879  * structures together.
22880  *
22881  * The generated swig_type_info structures are assigned staticly to an initial
22882  * array. We just loop through that array, and handle each type individually.
22883  * First we lookup if this type has been already loaded, and if so, use the
22884  * loaded structure instead of the generated one. Then we have to fill in the
22885  * cast linked list. The cast data is initially stored in something like a
22886  * two-dimensional array. Each row corresponds to a type (there are the same
22887  * number of rows as there are in the swig_type_initial array). Each entry in
22888  * a column is one of the swig_cast_info structures for that type.
22889  * The cast_initial array is actually an array of arrays, because each row has
22890  * a variable number of columns. So to actually build the cast linked list,
22891  * we find the array of casts associated with the type, and loop through it
22892  * adding the casts to the list. The one last trick we need to do is making
22893  * sure the type pointer in the swig_cast_info struct is correct.
22894  *
22895  * First off, we lookup the cast->type name to see if it is already loaded.
22896  * There are three cases to handle:
22897  * 1) If the cast->type has already been loaded AND the type we are adding
22898  * casting info to has not been loaded (it is in this module), THEN we
22899  * replace the cast->type pointer with the type pointer that has already
22900  * been loaded.
22901  * 2) If BOTH types (the one we are adding casting info to, and the
22902  * cast->type) are loaded, THEN the cast info has already been loaded by
22903  * the previous module so we just ignore it.
22904  * 3) Finally, if cast->type has not already been loaded, then we add that
22905  * swig_cast_info to the linked list (because the cast->type) pointer will
22906  * be correct.
22907  * ----------------------------------------------------------------------------- */
22908 
22909 #ifdef __cplusplus
22910 extern "C" {
22911 #if 0
22912 } /* c-mode */
22913 #endif
22914 #endif
22915 
22916 #if 0
22917 #define SWIGRUNTIME_DEBUG
22918 #endif
22919 
22920 
22921 SWIGRUNTIME void
22922 SWIG_InitializeModule(void *clientdata) {
22923  size_t i;
22924  swig_module_info *module_head, *iter;
22925  int found, init;
22926 
22927  /* check to see if the circular list has been setup, if not, set it up */
22928  if (swig_module.next==0) {
22929  /* Initialize the swig_module */
22930  swig_module.type_initial = swig_type_initial;
22931  swig_module.cast_initial = swig_cast_initial;
22932  swig_module.next = &swig_module;
22933  init = 1;
22934  } else {
22935  init = 0;
22936  }
22937 
22938  /* Try and load any already created modules */
22939  module_head = SWIG_GetModule(clientdata);
22940  if (!module_head) {
22941  /* This is the first module loaded for this interpreter */
22942  /* so set the swig module into the interpreter */
22943  SWIG_SetModule(clientdata, &swig_module);
22944  module_head = &swig_module;
22945  } else {
22946  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22947  found=0;
22948  iter=module_head;
22949  do {
22950  if (iter==&swig_module) {
22951  found=1;
22952  break;
22953  }
22954  iter=iter->next;
22955  } while (iter!= module_head);
22956 
22957  /* if the is found in the list, then all is done and we may leave */
22958  if (found) return;
22959  /* otherwise we must add out module into the list */
22960  swig_module.next = module_head->next;
22961  module_head->next = &swig_module;
22962  }
22963 
22964  /* When multiple interpreters are used, a module could have already been initialized in
22965  a different interpreter, but not yet have a pointer in this interpreter.
22966  In this case, we do not want to continue adding types... everything should be
22967  set up already */
22968  if (init == 0) return;
22969 
22970  /* Now work on filling in swig_module.types */
22971 #ifdef SWIGRUNTIME_DEBUG
22972  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22973 #endif
22974  for (i = 0; i < swig_module.size; ++i) {
22975  swig_type_info *type = 0;
22976  swig_type_info *ret;
22977  swig_cast_info *cast;
22978 
22979 #ifdef SWIGRUNTIME_DEBUG
22980  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22981 #endif
22982 
22983  /* if there is another module already loaded */
22984  if (swig_module.next != &swig_module) {
22985  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22986  }
22987  if (type) {
22988  /* Overwrite clientdata field */
22989 #ifdef SWIGRUNTIME_DEBUG
22990  printf("SWIG_InitializeModule: found type %s\n", type->name);
22991 #endif
22992  if (swig_module.type_initial[i]->clientdata) {
22993  type->clientdata = swig_module.type_initial[i]->clientdata;
22994 #ifdef SWIGRUNTIME_DEBUG
22995  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22996 #endif
22997  }
22998  } else {
22999  type = swig_module.type_initial[i];
23000  }
23001 
23002  /* Insert casting types */
23003  cast = swig_module.cast_initial[i];
23004  while (cast->type) {
23005  /* Don't need to add information already in the list */
23006  ret = 0;
23007 #ifdef SWIGRUNTIME_DEBUG
23008  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23009 #endif
23010  if (swig_module.next != &swig_module) {
23011  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23012 #ifdef SWIGRUNTIME_DEBUG
23013  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23014 #endif
23015  }
23016  if (ret) {
23017  if (type == swig_module.type_initial[i]) {
23018 #ifdef SWIGRUNTIME_DEBUG
23019  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23020 #endif
23021  cast->type = ret;
23022  ret = 0;
23023  } else {
23024  /* Check for casting already in the list */
23025  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23026 #ifdef SWIGRUNTIME_DEBUG
23027  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23028 #endif
23029  if (!ocast) ret = 0;
23030  }
23031  }
23032 
23033  if (!ret) {
23034 #ifdef SWIGRUNTIME_DEBUG
23035  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23036 #endif
23037  if (type->cast) {
23038  type->cast->prev = cast;
23039  cast->next = type->cast;
23040  }
23041  type->cast = cast;
23042  }
23043  cast++;
23044  }
23045  /* Set entry in modules->types array equal to the type */
23046  swig_module.types[i] = type;
23047  }
23048  swig_module.types[i] = 0;
23049 
23050 #ifdef SWIGRUNTIME_DEBUG
23051  printf("**** SWIG_InitializeModule: Cast List ******\n");
23052  for (i = 0; i < swig_module.size; ++i) {
23053  int j = 0;
23054  swig_cast_info *cast = swig_module.cast_initial[i];
23055  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23056  while (cast->type) {
23057  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23058  cast++;
23059  ++j;
23060  }
23061  printf("---- Total casts: %d\n",j);
23062  }
23063  printf("**** SWIG_InitializeModule: Cast List ******\n");
23064 #endif
23065 }
23066 
23067 /* This function will propagate the clientdata field of type to
23068 * any new swig_type_info structures that have been added into the list
23069 * of equivalent types. It is like calling
23070 * SWIG_TypeClientData(type, clientdata) a second time.
23071 */
23072 SWIGRUNTIME void
23074  size_t i;
23075  swig_cast_info *equiv;
23076  static int init_run = 0;
23077 
23078  if (init_run) return;
23079  init_run = 1;
23080 
23081  for (i = 0; i < swig_module.size; i++) {
23082  if (swig_module.types[i]->clientdata) {
23083  equiv = swig_module.types[i]->cast;
23084  while (equiv) {
23085  if (!equiv->converter) {
23086  if (equiv->type && !equiv->type->clientdata)
23087  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23088  }
23089  equiv = equiv->next;
23090  }
23091  }
23092  }
23093 }
23094 
23095 #ifdef __cplusplus
23096 #if 0
23097 {
23098  /* c-mode */
23099 #endif
23100 }
23101 #endif
23102 
23103 
23104 
23105 #ifdef __cplusplus
23106 extern "C" {
23107 #endif
23108 
23109  /* Python-specific SWIG API */
23110 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23111 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23112 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23113 
23114  /* -----------------------------------------------------------------------------
23115  * global variable support code.
23116  * ----------------------------------------------------------------------------- */
23117 
23118  typedef struct swig_globalvar {
23119  char *name; /* Name of global variable */
23120  PyObject *(*get_attr)(void); /* Return the current value */
23121  int (*set_attr)(PyObject *); /* Set the value */
23123  } swig_globalvar;
23124 
23125  typedef struct swig_varlinkobject {
23126  PyObject_HEAD
23129 
23130  SWIGINTERN PyObject *
23132 #if PY_VERSION_HEX >= 0x03000000
23133  return PyUnicode_InternFromString("<Swig global variables>");
23134 #else
23135  return PyString_FromString("<Swig global variables>");
23136 #endif
23137  }
23138 
23139  SWIGINTERN PyObject *
23141 #if PY_VERSION_HEX >= 0x03000000
23142  PyObject *str = PyUnicode_InternFromString("(");
23143  PyObject *tail;
23144  PyObject *joined;
23145  swig_globalvar *var;
23146  for (var = v->vars; var; var=var->next) {
23147  tail = PyUnicode_FromString(var->name);
23148  joined = PyUnicode_Concat(str, tail);
23149  Py_DecRef(str);
23150  Py_DecRef(tail);
23151  str = joined;
23152  if (var->next) {
23153  tail = PyUnicode_InternFromString(", ");
23154  joined = PyUnicode_Concat(str, tail);
23155  Py_DecRef(str);
23156  Py_DecRef(tail);
23157  str = joined;
23158  }
23159  }
23160  tail = PyUnicode_InternFromString(")");
23161  joined = PyUnicode_Concat(str, tail);
23162  Py_DecRef(str);
23163  Py_DecRef(tail);
23164  str = joined;
23165 #else
23166  PyObject *str = PyString_FromString("(");
23167  swig_globalvar *var;
23168  for (var = v->vars; var; var=var->next) {
23169  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23170  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23171  }
23172  PyString_ConcatAndDel(&str,PyString_FromString(")"));
23173 #endif
23174  return str;
23175  }
23176 
23177  SWIGINTERN int
23179  char *tmp;
23180  PyObject *str = swig_varlink_str(v);
23181  fprintf(fp,"Swig global variables ");
23182  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
23184  Py_DECREF(str);
23185  return 0;
23186  }
23187 
23188  SWIGINTERN void
23190  swig_globalvar *var = v->vars;
23191  while (var) {
23192  swig_globalvar *n = var->next;
23193  free(var->name);
23194  free(var);
23195  var = n;
23196  }
23197  }
23198 
23199  SWIGINTERN PyObject *
23201  PyObject *res = NULL;
23202  swig_globalvar *var = v->vars;
23203  while (var) {
23204  if (strcmp(var->name,n) == 0) {
23205  res = (*var->get_attr)();
23206  break;
23207  }
23208  var = var->next;
23209  }
23210  if (res == NULL && !PyErr_Occurred()) {
23211  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23212  }
23213  return res;
23214  }
23215 
23216  SWIGINTERN int
23217  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23218  int res = 1;
23219  swig_globalvar *var = v->vars;
23220  while (var) {
23221  if (strcmp(var->name,n) == 0) {
23222  res = (*var->set_attr)(p);
23223  break;
23224  }
23225  var = var->next;
23226  }
23227  if (res == 1 && !PyErr_Occurred()) {
23228  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23229  }
23230  return res;
23231  }
23232 
23233  SWIGINTERN PyTypeObject*
23235  static char varlink__doc__[] = "Swig var link object";
23236  static PyTypeObject varlink_type;
23237  static int type_init = 0;
23238  if (!type_init) {
23239  const PyTypeObject tmp = {
23240  /* PyObject header changed in Python 3 */
23241 #if PY_VERSION_HEX >= 0x03000000
23242  PyVarObject_HEAD_INIT(NULL, 0)
23243 #else
23244  PyObject_HEAD_INIT(NULL)
23245  0, /* ob_size */
23246 #endif
23247  (char *)"swigvarlink", /* tp_name */
23248  sizeof(swig_varlinkobject), /* tp_basicsize */
23249  0, /* tp_itemsize */
23250  (destructor) swig_varlink_dealloc, /* tp_dealloc */
23251  (printfunc) swig_varlink_print, /* tp_print */
23252  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
23253  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
23254  0, /* tp_compare */
23255  (reprfunc) swig_varlink_repr, /* tp_repr */
23256  0, /* tp_as_number */
23257  0, /* tp_as_sequence */
23258  0, /* tp_as_mapping */
23259  0, /* tp_hash */
23260  0, /* tp_call */
23261  (reprfunc) swig_varlink_str, /* tp_str */
23262  0, /* tp_getattro */
23263  0, /* tp_setattro */
23264  0, /* tp_as_buffer */
23265  0, /* tp_flags */
23266  varlink__doc__, /* tp_doc */
23267  0, /* tp_traverse */
23268  0, /* tp_clear */
23269  0, /* tp_richcompare */
23270  0, /* tp_weaklistoffset */
23271 #if PY_VERSION_HEX >= 0x02020000
23272  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23273 #endif
23274 #if PY_VERSION_HEX >= 0x02030000
23275  0, /* tp_del */
23276 #endif
23277 #if PY_VERSION_HEX >= 0x02060000
23278  0, /* tp_version */
23279 #endif
23280 #ifdef COUNT_ALLOCS
23281  0,0,0,0 /* tp_alloc -> tp_next */
23282 #endif
23283  };
23284  varlink_type = tmp;
23285  type_init = 1;
23286 #if PY_VERSION_HEX < 0x02020000
23287  varlink_type.ob_type = &PyType_Type;
23288 #else
23289  if (PyType_Ready(&varlink_type) < 0)
23290  return NULL;
23291 #endif
23292  }
23293  return &varlink_type;
23294  }
23295 
23296  /* Create a variable linking object for use later */
23297  SWIGINTERN PyObject *
23299  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23300  if (result) {
23301  result->vars = 0;
23302  }
23303  return ((PyObject*) result);
23304  }
23305 
23306  SWIGINTERN void
23307  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23309  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23310  if (gv) {
23311  size_t size = strlen(name)+1;
23312  gv->name = (char *)malloc(size);
23313  if (gv->name) {
23314  strncpy(gv->name,name,size);
23315  gv->get_attr = get_attr;
23316  gv->set_attr = set_attr;
23317  gv->next = v->vars;
23318  }
23319  }
23320  v->vars = gv;
23321  }
23322 
23323  SWIGINTERN PyObject *
23325  static PyObject *_SWIG_globals = 0;
23326  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23327  return _SWIG_globals;
23328  }
23329 
23330  /* -----------------------------------------------------------------------------
23331  * constants/methods manipulation
23332  * ----------------------------------------------------------------------------- */
23333 
23334  /* Install Constants */
23335  SWIGINTERN void
23336  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23337  PyObject *obj = 0;
23338  size_t i;
23339  for (i = 0; constants[i].type; ++i) {
23340  switch(constants[i].type) {
23341  case SWIG_PY_POINTER:
23342  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23343  break;
23344  case SWIG_PY_BINARY:
23345  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23346  break;
23347  default:
23348  obj = 0;
23349  break;
23350  }
23351  if (obj) {
23352  PyDict_SetItemString(d, constants[i].name, obj);
23353  Py_DECREF(obj);
23354  }
23355  }
23356  }
23357 
23358  /* -----------------------------------------------------------------------------*/
23359  /* Fix SwigMethods to carry the callback ptrs when needed */
23360  /* -----------------------------------------------------------------------------*/
23361 
23362  SWIGINTERN void
23363  SWIG_Python_FixMethods(PyMethodDef *methods,
23364  swig_const_info *const_table,
23365  swig_type_info **types,
23366  swig_type_info **types_initial) {
23367  size_t i;
23368  for (i = 0; methods[i].ml_name; ++i) {
23369  const char *c = methods[i].ml_doc;
23370  if (c && (c = strstr(c, "swig_ptr: "))) {
23371  int j;
23372  swig_const_info *ci = 0;
23373  const char *name = c + 10;
23374  for (j = 0; const_table[j].type; ++j) {
23375  if (strncmp(const_table[j].name, name,
23376  strlen(const_table[j].name)) == 0) {
23377  ci = &(const_table[j]);
23378  break;
23379  }
23380  }
23381  if (ci) {
23382  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23383  if (ptr) {
23384  size_t shift = (ci->ptype) - types;
23385  swig_type_info *ty = types_initial[shift];
23386  size_t ldoc = (c - methods[i].ml_doc);
23387  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23388  char *ndoc = (char*)malloc(ldoc + lptr + 10);
23389  if (ndoc) {
23390  char *buff = ndoc;
23391  strncpy(buff, methods[i].ml_doc, ldoc);
23392  buff += ldoc;
23393  strncpy(buff, "swig_ptr: ", 10);
23394  buff += 10;
23395  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23396  methods[i].ml_doc = ndoc;
23397  }
23398  }
23399  }
23400  }
23401  }
23402  }
23403 
23404 #ifdef __cplusplus
23405 }
23406 #endif
23407 
23408 /* -----------------------------------------------------------------------------*
23409  * Partial Init method
23410  * -----------------------------------------------------------------------------*/
23411 
23412 #ifdef __cplusplus
23413 extern "C"
23414 #endif
23415 
23416 SWIGEXPORT
23417 #if PY_VERSION_HEX >= 0x03000000
23418 PyObject*
23419 #else
23420 void
23421 #endif
23422 SWIG_init(void) {
23423  PyObject *m, *d, *md;
23424 #if PY_VERSION_HEX >= 0x03000000
23425  static struct PyModuleDef SWIG_module = {
23426 # if PY_VERSION_HEX >= 0x03020000
23427  PyModuleDef_HEAD_INIT,
23428 # else
23429  {
23430  PyObject_HEAD_INIT(NULL)
23431  NULL, /* m_init */
23432  0, /* m_index */
23433  NULL, /* m_copy */
23434  },
23435 # endif
23436  (char *) SWIG_name,
23437  NULL,
23438  -1,
23439  SwigMethods,
23440  NULL,
23441  NULL,
23442  NULL,
23443  NULL
23444  };
23445 #endif
23446 
23447 #if defined(SWIGPYTHON_BUILTIN)
23448  static SwigPyClientData SwigPyObject_clientdata = {
23449  0, 0, 0, 0, 0, 0, 0
23450  };
23451  static PyGetSetDef this_getset_def = {
23452  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23453  };
23454  static SwigPyGetSet thisown_getset_closure = {
23455  (PyCFunction) SwigPyObject_own,
23456  (PyCFunction) SwigPyObject_own
23457  };
23458  static PyGetSetDef thisown_getset_def = {
23459  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23460  };
23461  PyObject *metatype_args;
23462  PyTypeObject *builtin_pytype;
23463  int builtin_base_count;
23464  swig_type_info *builtin_basetype;
23465  PyObject *tuple;
23466  PyGetSetDescrObject *static_getset;
23467  PyTypeObject *metatype;
23468  SwigPyClientData *cd;
23469  PyObject *public_interface, *public_symbol;
23470  PyObject *this_descr;
23471  PyObject *thisown_descr;
23472  int i;
23473 
23474  (void)builtin_pytype;
23475  (void)builtin_base_count;
23476  (void)builtin_basetype;
23477  (void)tuple;
23478  (void)static_getset;
23479 
23480  /* metatype is used to implement static member variables. */
23481  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
23482  assert(metatype_args);
23483  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
23484  assert(metatype);
23485  Py_DECREF(metatype_args);
23486  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
23487  assert(PyType_Ready(metatype) >= 0);
23488 #endif
23489 
23490  /* Fix SwigMethods to carry the callback ptrs when needed */
23491  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23492 
23493 #if PY_VERSION_HEX >= 0x03000000
23494  m = PyModule_Create(&SWIG_module);
23495 #else
23496  m = Py_InitModule((char *) SWIG_name, SwigMethods);
23497 #endif
23498  md = d = PyModule_GetDict(m);
23499  (void)md;
23500 
23502 
23503 #ifdef SWIGPYTHON_BUILTIN
23504  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23505  assert(SwigPyObject_stype);
23506  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23507  if (!cd) {
23508  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23509  SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
23510  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
23511  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23512 # if PY_VERSION_HEX >= 0x03000000
23513  return NULL;
23514 # else
23515  return;
23516 # endif
23517  }
23518 
23519  /* All objects have a 'this' attribute */
23520  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23521  (void)this_descr;
23522 
23523  /* All objects have a 'thisown' attribute */
23524  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23525  (void)thisown_descr;
23526 
23527  public_interface = PyList_New(0);
23528  public_symbol = 0;
23529  (void)public_symbol;
23530 
23531  PyDict_SetItemString(md, "__all__", public_interface);
23532  Py_DECREF(public_interface);
23533  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23534  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23535  for (i = 0; swig_const_table[i].name != 0; ++i)
23536  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23537 #endif
23538 
23540 
23541 
23542  import_array();
23543 
23544  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23545  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23546  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23547  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23548  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23549  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23550  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23551  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23552  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23553  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23554  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23555  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23556  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23557  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23558  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23559  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23560  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23561  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23562  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23563  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23564  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23565  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23566  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23567  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23568  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23569  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23570  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23571  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23572  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23573  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23574  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23575  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23576  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23577  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23578  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23579  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23580  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23581  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23582  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23583  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23584  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23585  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23586  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23587  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23588  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23589  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23590  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23591  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23592  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23593  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23594  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23595  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23596  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23597  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23598  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23599  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23600  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23601  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23602  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23603  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23604  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23605  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23606  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23607  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23608  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23609  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23610  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23611  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23612  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23613  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23614  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23615  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23616  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23617  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23618  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23619  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23620  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23621  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23622  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23623  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23624  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23625  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23626  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23627  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23628  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23629  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23630  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23631  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23632  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23633  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23634  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23635  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23636  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23637  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23638  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23639  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23640  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23641  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23642  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23643  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23644  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23645  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23646  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23647  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23648  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23649  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23650  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23651  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23652  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23653  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23654  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23655  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23656  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23657  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23658  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23659  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23660  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23661  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23662  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23663  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23664  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23665  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23666  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23667  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23668  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23669  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23670  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23671  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23672  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23673  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23674  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23675  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23676  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23677  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23678  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23679  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23680  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23681  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23682  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23683  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23684  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23685  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23686  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23687  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23688  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23689  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23690  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23691  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23692  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23693  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23694  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23695  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23696  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23697  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23698  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23699  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23700  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23701  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23702  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23703  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23704  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23705  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23706  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23707  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23708  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23709  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23710  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23711  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23712  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23713  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23714  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23715  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23716  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23717  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23718 #if PY_VERSION_HEX >= 0x03000000
23719  return m;
23720 #else
23721  return;
23722 #endif
23723 }
23724 
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intobjargproc ssizeobjargproc
PyObject_HEAD void * ptr
#define SWIG_SetModule(clientdata, pointer)
#define plsfam
Definition: plplot.h:818
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
#define plw3d
Definition: plplot.h:863
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * name
Definition: tkMain.c:135
#define plpath
Definition: plplot.h:759
#define SWIG_PY_POINTER
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgxax
Definition: plplot.h:743
static PLcGrid tmpGrid1
#define SWIG_IsOK(r)
#define plsstrm
Definition: plplot.h:836
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
void cleanup_PLcGrid2(void)
#define PyObject_DEL
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_globalvar swig_globalvar
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plspage
Definition: plplot.h:832
PyObject_HEAD swig_globalvar * vars
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define plvpor
Definition: plplot.h:861
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_OverflowError
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_str_FromFormat
static swig_cast_info _swigc__p_char[]
#define plmtex3
Definition: plplot.h:772
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plerry
Definition: plplot.h:711
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
#define plsyax
Definition: plplot.h:853
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plschr
Definition: plplot.h:792
#define plsdev
Definition: plplot.h:809
enum callback_type pltr_type
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
#define plgdev
Definition: plplot.h:724
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
int min(int a, int b)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject * python_f2eval
#define PyObject_GenericGetAttr
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static long PyNumber_AsSsize_t(PyObject *x, void *SWIGUNUSEDPARM(exc))
#define pllegend
Definition: plplot.h:756
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIGTYPE_p_int
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGINTERNINLINE
void cleanup_ct(void)
#define PySequence_Size
#define SWIG_CAST_NEW_MEMORY
#define plshade
Definition: plplot.h:822
struct swig_globalvar * next
#define plscompression
Definition: plplot.h:808
#define SWIG_STATIC_POINTER(var)
#define plarc
Definition: plplot.h:689
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
PLUINT PLUNICODE
Definition: plplot.h:194
intargfunc ssizeargfunc
PL_NC_GENERIC_POINTER PLPointer
Definition: plplot.h:211
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
static PLINT Xlen
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
static swig_type_info _swigt__p_char
static swig_cast_info _swigc__p_int[]
static swig_type_info _swigt__p_f_double_double__int
#define plot3dc
Definition: plplot.h:774
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define t_output_helper
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3dcl
Definition: plplot.h:775
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
inquiry lenfunc
static swig_type_info _swigt__p_PLcGrid
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
PyArrayObject * pltr_yg
SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
#define pllsty
Definition: plplot.h:761
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmin
Definition: plplot.h:829
#define plwind
Definition: plplot.h:868
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plclear
Definition: plplot.h:697
#define plfill
Definition: plplot.h:713
#define plconfigtime
Definition: plplot.h:701
#define SWIG_ValueError
#define plsurf3dl
Definition: plplot.h:849
#define SWIG_name
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD void * pack
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:628
#define plbtime
Definition: plplot.h:695
#define pl_setcontlabelparam
Definition: plplot.h:687
#define SWIG_MemoryError
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolbg
Definition: plplot.h:805
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
intintargfunc ssizessizeargfunc
swig_dycast_func dcast
struct swig_cast_info * cast
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
#define plfont
Definition: plplot.h:716
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
#define plstyl
Definition: plplot.h:847
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
#define plpoly3
Definition: plplot.h:780
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
#define plimage
Definition: plplot.h:751
swig_type_info * type
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
#define SWIG_ArgError(r)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define plfontld
Definition: plplot.h:717
#define SWIG_SystemError
#define plscolbga
Definition: plplot.h:806
SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define plbin
Definition: plplot.h:691
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdiori
Definition: plplot.h:812
static swig_type_info _swigt__p_p_char
#define SWIG_RuntimeError
#define Py_NotImplemented
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:742
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plparseopts
Definition: plplot.h:776
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:673
#define plsym
Definition: plplot.h:854
#define plscmap1
Definition: plplot.h:796
#define SWIG_as_voidptrptr(a)
#define plinit
Definition: plplot.h:753
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
#define SWIGUNUSEDPARM(p)
#define plctime
Definition: plplot.h:704
#define pltimefmt
Definition: plplot.h:857
#define plscmap1n
Definition: plplot.h:800
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbop
Definition: plplot.h:692
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_double_double__int[]
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
#define plsdiplt
Definition: plplot.h:813
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsvect
Definition: plplot.h:850
#define plscmap1a
Definition: plplot.h:797
#define plssub
Definition: plplot.h:837
static PLINT Alen
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLGraphicsIn
#define SWIG_PYTHON_THREAD_END_BLOCK
#define plspal1
Definition: plplot.h:834
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsetopt
Definition: plplot.h:817
static swig_cast_info _swigc__p_unsigned_int[]
#define plmeshc
Definition: plplot.h:769
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgcompression
Definition: plplot.h:723
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
#define plszax
Definition: plplot.h:855
#define SWIG_PY_BINARY
#define plvsta
Definition: plplot.h:862
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyMappingMethods as_mapping
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
#define SWIG_IOError
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgpage
Definition: plplot.h:734
#define plaxes
Definition: plplot.h:690
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsori
Definition: plplot.h:831
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_pltr(void)
#define SWIG_Python_str_DelForPy3(x)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgdiplt
Definition: plplot.h:727
void cleanup_mapform(void)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
#define plscmap0a
Definition: plplot.h:794
PLINT ny
Definition: plplot.h:532
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfamadv
Definition: plplot.h:712
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plend
Definition: plplot.h:705
#define SWIGINTERN
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
#define plsmem
Definition: plplot.h:827
#define plgfont
Definition: plplot.h:732
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plend1
Definition: plplot.h:706
int PLINT
Definition: plplot.h:174
#define plenv0
Definition: plplot.h:708
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
#define SWIG_RUNTIME_VERSION
#define plgdiori
Definition: plplot.h:726
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plshades
Definition: plplot.h:824
PLINT PLBOOL
Definition: plplot.h:197
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:838
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
PLFLT_NC_MATRIX yg
Definition: plplot.h:531
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define pljoin
Definition: plplot.h:754
#define plgzax
Definition: plplot.h:745
static PLINT Ylen
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfam
Definition: plplot.h:729
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT ny
Definition: plplot.h:520
#define plgdidev
Definition: plplot.h:725
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
#define SWIGRUNTIMEINLINE
#define SWIG_NewClientData(obj)
#define plstar
Definition: plplot.h:839
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
#define SWIG_GetModule(clientdata)
#define NPY_PLFLT
#define myArray_ContiguousFromObject
PyObject * python_ct
#define plcpstrm
Definition: plplot.h:703
static PyMethodDef swigobject_methods[]
#define plimagefr
Definition: plplot.h:752
#define plcalc_world
Definition: plplot.h:696
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define SWIGEXPORT
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsfnam
Definition: plplot.h:820
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
SWIGRUNTIME void SWIG_PropagateClientData(void)
#define plhist
Definition: plplot.h:746
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
#define PyString_AsStringAndSize(obj, s, len)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
#define SWIG_DelNewMask(r)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
#define plgchr
Definition: plplot.h:718
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
struct swig_module_info * next
#define plsdidev
Definition: plplot.h:810
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plspal0
Definition: plplot.h:833
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
plSetUsage
Definition: plplotc.py:8414
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfill3
Definition: plplot.h:714
#define SWIG_PYBUFFER_SIZE
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define plsmema
Definition: plplot.h:828
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
getreadbufferproc readbufferproc
swig_converter_func converter
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define plseed
Definition: plplot.h:815
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:519
#define plstring
Definition: plplot.h:842
plOptUsage
Definition: plplotc.py:8418
#define plstransform
Definition: plplot.h:841
#define plvect
Definition: plplot.h:859
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
int(* set_attr)(PyObject *)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1la
Definition: plplot.h:799
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfnam
Definition: plplot.h:731
#define SWIG_From_double
static swig_module_info swig_module
#define SWIG_TMPOBJ
#define SWIG_POINTER_DISOWN
#define plcont
Definition: plplot.h:702
#define plsxax
Definition: plplot.h:852
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
static swig_cast_info _swigc__p_PLcGrid[]
#define plstart
Definition: plplot.h:840
plClearOpts
Definition: plplotc.py:8406
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pleop
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:768
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plhlsrgb
Definition: plplot.h:750
swig_type_info ** types
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmaj
Definition: plplot.h:826
PLINT nx
Definition: plplot.h:532
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
destructor freefunc
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol1
Definition: plplot.h:699
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllab
Definition: plplot.h:755
#define pllightsource
Definition: plplot.h:757
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_exception_fail(code, msg)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbox
Definition: plplot.h:693
pl_setcontlabelformat
Definition: tclgen_s.h:1
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pltext
Definition: plplot.h:856
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
#define SWIG_ERROR
plMinMax2dGrid
Definition: plplotc.py:8422
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plwidth
Definition: plplot.h:867
#define plgver
Definition: plplot.h:740
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0a
Definition: plplot.h:804
#define SWIG_NewPointerObj(ptr, type, flags)
static swig_cast_info _swigc__p_double[]
#define plptex3
Definition: plplot.h:784
#define plsdiplz
Definition: plplot.h:814
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static char buf[200]
Definition: tclAPI.c:873
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyArrayObject * pltr_xg
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
static swig_type_info * swig_type_initial[]
#define plspause
Definition: plplot.h:835
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define plline3
Definition: plplot.h:760
#define plstripd
Definition: plplot.h:846
#define SWIG_MangledTypeQuery(name)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define plgfci
Definition: plplot.h:730
#define plgspa
Definition: plplot.h:738
#define plgcolbg
Definition: plplot.h:721
#define plstripc
Definition: plplot.h:845
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
#define plstripa
Definition: plplot.h:844
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstring3
Definition: plplot.h:843
PyObject *(* get_attr)(void)
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
PyObject * python_mapform
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvpas
Definition: plplot.h:860
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PySequenceMethods as_sequence
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
#define plsfont
Definition: plplot.h:821
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:695
#define PyInt_FromSize_t(x)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
#define plpsty
Definition: plplot.h:782
#define PyOS_snprintf
#define SWIG_as_voidptr(a)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1209
#define plgvpd
Definition: plplot.h:741
#define plpoin
Definition: plplot.h:778
#define plgriddata
Definition: plplot.h:737
static swig_type_info _swigt__p_unsigned_int
#define plgvpw
Definition: plplot.h:742
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_p_double
static swig_type_info _swigt__p_PLcGrid2
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
int max(int a, int b)
#define SWIG_fail
pltr_func marshal_pltr(PyObject *input)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * _SWIG_This(void)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
getwritebufferproc writebufferproc
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
PyObject * python_pltr
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
intintobjargproc ssizessizeobjargproc
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
#define plmkstrm
Definition: plplot.h:770
#define PL_UNUSED(x)
Definition: plplot.h:128
float PLFLT
Definition: plplot.h:157
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0
Definition: plplot.h:803
#define SWIG_TypeQuery(name)
static swig_cast_info _swigc__p_PLcGrid2[]
#define plxormod
Definition: plplot.h:869
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_cast_info swig_cast_info
#define plflush
Definition: plplot.h:715
#define SWIG_AddCast(r)
#define plerrx
Definition: plplot.h:710
#define plgcol0a
Definition: plplot.h:720
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeError
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgcolbga
Definition: plplot.h:722
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * PyString_FromFormat(const char *fmt,...)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_DivisionByZero
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
#define plgyax
Definition: plplot.h:744
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define plsesc
Definition: plplot.h:816
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define plenv
Definition: plplot.h:707
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
struct swig_cast_info * next
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define MY_BLOCK_THREADS
#define plgcmap1_range
Definition: plplot.h:802
#define plcol0
Definition: plplot.h:698
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
#define plbox3
Definition: plplot.h:694
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcolorbar
Definition: plplot.h:700
struct swig_module_info swig_module_info
static swig_cast_info * swig_cast_initial[]
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:733
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:519
PyObject * python_label
#define plpoin3
Definition: plplot.h:779
getsegcountproc segcountproc
#define plscmap0n
Definition: plplot.h:795
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolor
Definition: plplot.h:807
#define plsvpa
Definition: plplot.h:851
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
#define SWIG_newvarlink()
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static tclMatrixXtnsnDescr * tail
Definition: tclMatrix.c:461
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpat
Definition: plplot.h:777
#define plscmap1_range
Definition: plplot.h:801
#define SWIG_IsTmpObj(r)
struct swig_cast_info * prev
struct swig_const_info swig_const_info
#define plgcol0
Definition: plplot.h:719
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
getcharbufferproc charbufferproc
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define plreplot
Definition: plplot.h:786
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_cast_info ** cast_initial
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
ct_func marshal_ct(PyObject *input)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_cast_info _swigc__p_p_double[]
#define plscmap1l
Definition: plplot.h:798
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:599
#define NPY_PLINT
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
#define plprec
Definition: plplot.h:781
#define SWIG_OLDOBJ
#define plptex
Definition: plplot.h:783
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline
Definition: plplot.h:758
SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o)
PLFLT_NC_MATRIX xg
Definition: plplot.h:531
SWIGRUNTIME PyObject * SWIG_This(void)
#define SWIG_InstallConstants(d, constants)
mapform_func marshal_mapform(PyObject *input)
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_init
#define SWIG_SyntaxError
#define plgradient
Definition: plplot.h:736
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_type_info ** type_initial
#define MY_UNBLOCK_THREADS
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pladv
Definition: plplot.h:688
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
static swig_type_info _swigt__p_int
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
#define SWIG_AttributeError
#define plvasp
Definition: plplot.h:858
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrandd
Definition: plplot.h:785
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0
Definition: plplot.h:793
static PyObject * PyBool_FromLong(long ok)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:650
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgstrm
Definition: plplot.h:739
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
#define plsfci
Definition: plplot.h:819
static swig_type_info * swig_types[15]
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
char string[PL_MAXKEY]
Definition: plplot.h:451
plResetOpts
Definition: plplotc.py:8410
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmtex
Definition: plplot.h:771
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrgbhls
Definition: plplot.h:791
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsurf3d
Definition: plplot.h:848
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgra
Definition: plplot.h:735
#define SWIG_OK
SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj, char *name)
#define plsdimap
Definition: plplot.h:811
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3d
Definition: plplot.h:773
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
#define plslabelfunc
Definition: plplot.h:825
static swig_const_info swig_const_table[]
PLINT nx
Definition: plplot.h:520
#define SWIG_NEWOBJ
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV