PLplot  5.14.0
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 3.0.12
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15 
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17 
18 /* -----------------------------------------------------------------------------
19  * This section contains generic SWIG labels for method/variable
20  * declarations/attributes, and other compiler dependent labels.
21  * ----------------------------------------------------------------------------- */
22 
23 /* template workaround for compilers that cannot correctly implement the C++ standard */
24 #ifndef SWIGTEMPLATEDISAMBIGUATOR
25 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # elif defined(__HP_aCC)
28 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30 # define SWIGTEMPLATEDISAMBIGUATOR template
31 # else
32 # define SWIGTEMPLATEDISAMBIGUATOR
33 # endif
34 #endif
35 
36 /* inline attribute */
37 #ifndef SWIGINLINE
38 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39 # define SWIGINLINE inline
40 # else
41 # define SWIGINLINE
42 # endif
43 #endif
44 
45 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 #ifndef SWIGUNUSED
47 # if defined(__GNUC__)
48 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 # elif defined(__ICC)
54 # define SWIGUNUSED __attribute__ ((__unused__))
55 # else
56 # define SWIGUNUSED
57 # endif
58 #endif
59 
60 #ifndef SWIG_MSC_UNSUPPRESS_4505
61 # if defined(_MSC_VER)
62 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
63 # endif
64 #endif
65 
66 #ifndef SWIGUNUSEDPARM
67 # ifdef __cplusplus
68 # define SWIGUNUSEDPARM(p)
69 # else
70 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
71 # endif
72 #endif
73 
74 /* internal SWIG method */
75 #ifndef SWIGINTERN
76 # define SWIGINTERN static SWIGUNUSED
77 #endif
78 
79 /* internal inline SWIG method */
80 #ifndef SWIGINTERNINLINE
81 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82 #endif
83 
84 /* exporting methods */
85 #if defined(__GNUC__)
86 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87 # ifndef GCC_HASCLASSVISIBILITY
88 # define GCC_HASCLASSVISIBILITY
89 # endif
90 # endif
91 #endif
92 
93 #ifndef SWIGEXPORT
94 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95 # if defined(STATIC_LINKED)
96 # define SWIGEXPORT
97 # else
98 # define SWIGEXPORT __declspec(dllexport)
99 # endif
100 # else
101 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102 # define SWIGEXPORT __attribute__ ((visibility("default")))
103 # else
104 # define SWIGEXPORT
105 # endif
106 # endif
107 #endif
108 
109 /* calling conventions for Windows */
110 #ifndef SWIGSTDCALL
111 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112 # define SWIGSTDCALL __stdcall
113 # else
114 # define SWIGSTDCALL
115 # endif
116 #endif
117 
118 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120 # define _CRT_SECURE_NO_DEPRECATE
121 #endif
122 
123 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125 # define _SCL_SECURE_NO_DEPRECATE
126 #endif
127 
128 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131 #endif
132 
133 /* Intel's compiler complains if a variable which was never initialised is
134  * cast to void, which is a common idiom which we use to indicate that we
135  * are aware a variable isn't used. So we just silence that warning.
136  * See: https://github.com/swig/swig/issues/192 for more discussion.
137  */
138 #ifdef __INTEL_COMPILER
139 # pragma warning disable 592
140 #endif
141 
142 
143 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
144 /* Use debug wrappers with the Python release dll */
145 # undef _DEBUG
146 # include <Python.h>
147 # define _DEBUG
148 #else
149 # include <Python.h>
150 #endif
151 
152 /* -----------------------------------------------------------------------------
153  * swigrun.swg
154  *
155  * This file contains generic C API SWIG runtime support for pointer
156  * type checking.
157  * ----------------------------------------------------------------------------- */
158 
159 /* This should only be incremented when either the layout of swig_type_info changes,
160  or for whatever reason, the runtime changes incompatibly */
161 #define SWIG_RUNTIME_VERSION "4"
162 
163 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
164 #ifdef SWIG_TYPE_TABLE
165 # define SWIG_QUOTE_STRING(x) #x
166 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
167 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
168 #else
169 # define SWIG_TYPE_TABLE_NAME
170 #endif
171 
172 /*
173  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
174  creating a static or dynamic library from the SWIG runtime code.
175  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
176 
177  But only do this if strictly necessary, ie, if you have problems
178  with your compiler or suchlike.
179 */
180 
181 #ifndef SWIGRUNTIME
182 # define SWIGRUNTIME SWIGINTERN
183 #endif
184 
185 #ifndef SWIGRUNTIMEINLINE
186 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
187 #endif
188 
189 /* Generic buffer size */
190 #ifndef SWIG_BUFFER_SIZE
191 # define SWIG_BUFFER_SIZE 1024
192 #endif
193 
194 /* Flags for pointer conversions */
195 #define SWIG_POINTER_DISOWN 0x1
196 #define SWIG_CAST_NEW_MEMORY 0x2
197 
198 /* Flags for new pointer objects */
199 #define SWIG_POINTER_OWN 0x1
200 
201 
202 /*
203  Flags/methods for returning states.
204 
205  The SWIG conversion methods, as ConvertPtr, return an integer
206  that tells if the conversion was successful or not. And if not,
207  an error code can be returned (see swigerrors.swg for the codes).
208 
209  Use the following macros/flags to set or process the returning
210  states.
211 
212  In old versions of SWIG, code such as the following was usually written:
213 
214  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
215  // success code
216  } else {
217  //fail code
218  }
219 
220  Now you can be more explicit:
221 
222  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
223  if (SWIG_IsOK(res)) {
224  // success code
225  } else {
226  // fail code
227  }
228 
229  which is the same really, but now you can also do
230 
231  Type *ptr;
232  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
233  if (SWIG_IsOK(res)) {
234  // success code
235  if (SWIG_IsNewObj(res) {
236  ...
237  delete *ptr;
238  } else {
239  ...
240  }
241  } else {
242  // fail code
243  }
244 
245  I.e., now SWIG_ConvertPtr can return new objects and you can
246  identify the case and take care of the deallocation. Of course that
247  also requires SWIG_ConvertPtr to return new result values, such as
248 
249  int SWIG_ConvertPtr(obj, ptr,...) {
250  if (<obj is ok>) {
251  if (<need new object>) {
252  *ptr = <ptr to new allocated object>;
253  return SWIG_NEWOBJ;
254  } else {
255  *ptr = <ptr to old object>;
256  return SWIG_OLDOBJ;
257  }
258  } else {
259  return SWIG_BADOBJ;
260  }
261  }
262 
263  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
264  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
265  SWIG errors code.
266 
267  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
268  allows to return the 'cast rank', for example, if you have this
269 
270  int food(double)
271  int fooi(int);
272 
273  and you call
274 
275  food(1) // cast rank '1' (1 -> 1.0)
276  fooi(1) // cast rank '0'
277 
278  just use the SWIG_AddCast()/SWIG_CheckState()
279 */
280 
281 #define SWIG_OK (0)
282 #define SWIG_ERROR (-1)
283 #define SWIG_IsOK(r) (r >= 0)
284 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
285 
286 /* The CastRankLimit says how many bits are used for the cast rank */
287 #define SWIG_CASTRANKLIMIT (1 << 8)
288 /* The NewMask denotes the object was created (using new/malloc) */
289 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
290 /* The TmpMask is for in/out typemaps that use temporal objects */
291 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
292 /* Simple returning values */
293 #define SWIG_BADOBJ (SWIG_ERROR)
294 #define SWIG_OLDOBJ (SWIG_OK)
295 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
296 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
297 /* Check, add and del mask methods */
298 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
299 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
300 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
301 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
302 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
303 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
304 
305 /* Cast-Rank Mode */
306 #if defined(SWIG_CASTRANK_MODE)
307 # ifndef SWIG_TypeRank
308 # define SWIG_TypeRank unsigned long
309 # endif
310 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
311 # define SWIG_MAXCASTRANK (2)
312 # endif
313 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
314 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
315 SWIGINTERNINLINE int SWIG_AddCast(int r) {
316  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
317 }
319  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
320 }
321 #else /* no cast-rank mode */
322 # define SWIG_AddCast(r) (r)
323 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
324 #endif
325 
326 
327 #include <string.h>
328 
329 #ifdef __cplusplus
330 extern "C" {
331 #endif
332 
333 typedef void *(*swig_converter_func)(void *, int *);
334 typedef struct swig_type_info *(*swig_dycast_func)(void **);
335 
336 /* Structure to store information on one type */
337 typedef struct swig_type_info {
338  const char *name; /* mangled name of this type */
339  const char *str; /* human readable name of this type */
340  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
341  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
342  void *clientdata; /* language specific type data */
343  int owndata; /* flag if the structure owns the clientdata */
345 
346 /* Structure to store a type and conversion function used for casting */
347 typedef struct swig_cast_info {
348  swig_type_info *type; /* pointer to type that is equivalent to this type */
349  swig_converter_func converter; /* function to cast the void pointers */
350  struct swig_cast_info *next; /* pointer to next cast in linked list */
351  struct swig_cast_info *prev; /* pointer to the previous cast */
353 
354 /* Structure used to store module information
355  * Each module generates one structure like this, and the runtime collects
356  * all of these structures and stores them in a circularly linked list.*/
357 typedef struct swig_module_info {
358  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
359  size_t size; /* Number of types in this module */
360  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
361  swig_type_info **type_initial; /* Array of initially generated type structures */
362  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
363  void *clientdata; /* Language specific module data */
365 
366 /*
367  Compare two type names skipping the space characters, therefore
368  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
369 
370  Return 0 when the two name types are equivalent, as in
371  strncmp, but skipping ' '.
372 */
373 SWIGRUNTIME int
374 SWIG_TypeNameComp(const char *f1, const char *l1,
375  const char *f2, const char *l2) {
376  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
377  while ((*f1 == ' ') && (f1 != l1)) ++f1;
378  while ((*f2 == ' ') && (f2 != l2)) ++f2;
379  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
380  }
381  return (int)((l1 - f1) - (l2 - f2));
382 }
383 
384 /*
385  Check type equivalence in a name list like <name1>|<name2>|...
386  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
387 */
388 SWIGRUNTIME int
389 SWIG_TypeCmp(const char *nb, const char *tb) {
390  int equiv = 1;
391  const char* te = tb + strlen(tb);
392  const char* ne = nb;
393  while (equiv != 0 && *ne) {
394  for (nb = ne; *ne; ++ne) {
395  if (*ne == '|') break;
396  }
397  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
398  if (*ne) ++ne;
399  }
400  return equiv;
401 }
402 
403 /*
404  Check type equivalence in a name list like <name1>|<name2>|...
405  Return 0 if not equal, 1 if equal
406 */
407 SWIGRUNTIME int
408 SWIG_TypeEquiv(const char *nb, const char *tb) {
409  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
410 }
411 
412 /*
413  Check the typename
414 */
416 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
417  if (ty) {
418  swig_cast_info *iter = ty->cast;
419  while (iter) {
420  if (strcmp(iter->type->name, c) == 0) {
421  if (iter == ty->cast)
422  return iter;
423  /* Move iter to the top of the linked list */
424  iter->prev->next = iter->next;
425  if (iter->next)
426  iter->next->prev = iter->prev;
427  iter->next = ty->cast;
428  iter->prev = 0;
429  if (ty->cast) ty->cast->prev = iter;
430  ty->cast = iter;
431  return iter;
432  }
433  iter = iter->next;
434  }
435  }
436  return 0;
437 }
438 
439 /*
440  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
441 */
444  if (ty) {
445  swig_cast_info *iter = ty->cast;
446  while (iter) {
447  if (iter->type == from) {
448  if (iter == ty->cast)
449  return iter;
450  /* Move iter to the top of the linked list */
451  iter->prev->next = iter->next;
452  if (iter->next)
453  iter->next->prev = iter->prev;
454  iter->next = ty->cast;
455  iter->prev = 0;
456  if (ty->cast) ty->cast->prev = iter;
457  ty->cast = iter;
458  return iter;
459  }
460  iter = iter->next;
461  }
462  }
463  return 0;
464 }
465 
466 /*
467  Cast a pointer up an inheritance hierarchy
468 */
469 SWIGRUNTIMEINLINE void *
470 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
471  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
472 }
473 
474 /*
475  Dynamic pointer casting. Down an inheritance hierarchy
476 */
479  swig_type_info *lastty = ty;
480  if (!ty || !ty->dcast) return ty;
481  while (ty && (ty->dcast)) {
482  ty = (*ty->dcast)(ptr);
483  if (ty) lastty = ty;
484  }
485  return lastty;
486 }
487 
488 /*
489  Return the name associated with this type
490 */
491 SWIGRUNTIMEINLINE const char *
493  return ty->name;
494 }
495 
496 /*
497  Return the pretty name associated with this type,
498  that is an unmangled type name in a form presentable to the user.
499 */
500 SWIGRUNTIME const char *
502  /* The "str" field contains the equivalent pretty names of the
503  type, separated by vertical-bar characters. We choose
504  to print the last name, as it is often (?) the most
505  specific. */
506  if (!type) return NULL;
507  if (type->str != NULL) {
508  const char *last_name = type->str;
509  const char *s;
510  for (s = type->str; *s; s++)
511  if (*s == '|') last_name = s+1;
512  return last_name;
513  }
514  else
515  return type->name;
516 }
517 
518 /*
519  Set the clientdata field for a type
520 */
521 SWIGRUNTIME void
523  swig_cast_info *cast = ti->cast;
524  /* if (ti->clientdata == clientdata) return; */
525  ti->clientdata = clientdata;
526 
527  while (cast) {
528  if (!cast->converter) {
529  swig_type_info *tc = cast->type;
530  if (!tc->clientdata) {
532  }
533  }
534  cast = cast->next;
535  }
536 }
537 SWIGRUNTIME void
540  ti->owndata = 1;
541 }
542 
543 /*
544  Search for a swig_type_info structure only by mangled name
545  Search is a O(log #types)
546 
547  We start searching at module start, and finish searching when start == end.
548  Note: if start == end at the beginning of the function, we go all the way around
549  the circular list.
550 */
553  swig_module_info *end,
554  const char *name) {
555  swig_module_info *iter = start;
556  do {
557  if (iter->size) {
558  size_t l = 0;
559  size_t r = iter->size - 1;
560  do {
561  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
562  size_t i = (l + r) >> 1;
563  const char *iname = iter->types[i]->name;
564  if (iname) {
565  int compare = strcmp(name, iname);
566  if (compare == 0) {
567  return iter->types[i];
568  } else if (compare < 0) {
569  if (i) {
570  r = i - 1;
571  } else {
572  break;
573  }
574  } else if (compare > 0) {
575  l = i + 1;
576  }
577  } else {
578  break; /* should never happen */
579  }
580  } while (l <= r);
581  }
582  iter = iter->next;
583  } while (iter != end);
584  return 0;
585 }
586 
587 /*
588  Search for a swig_type_info structure for either a mangled name or a human readable name.
589  It first searches the mangled names of the types, which is a O(log #types)
590  If a type is not found it then searches the human readable names, which is O(#types).
591 
592  We start searching at module start, and finish searching when start == end.
593  Note: if start == end at the beginning of the function, we go all the way around
594  the circular list.
595 */
598  swig_module_info *end,
599  const char *name) {
600  /* STEP 1: Search the name field using binary search */
601  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
602  if (ret) {
603  return ret;
604  } else {
605  /* STEP 2: If the type hasn't been found, do a complete search
606  of the str field (the human readable name) */
607  swig_module_info *iter = start;
608  do {
609  size_t i = 0;
610  for (; i < iter->size; ++i) {
611  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
612  return iter->types[i];
613  }
614  iter = iter->next;
615  } while (iter != end);
616  }
617 
618  /* neither found a match */
619  return 0;
620 }
621 
622 /*
623  Pack binary data into a string
624 */
625 SWIGRUNTIME char *
626 SWIG_PackData(char *c, void *ptr, size_t sz) {
627  static const char hex[17] = "0123456789abcdef";
628  const unsigned char *u = (unsigned char *) ptr;
629  const unsigned char *eu = u + sz;
630  for (; u != eu; ++u) {
631  unsigned char uu = *u;
632  *(c++) = hex[(uu & 0xf0) >> 4];
633  *(c++) = hex[uu & 0xf];
634  }
635  return c;
636 }
637 
638 /*
639  Unpack binary data from a string
640 */
641 SWIGRUNTIME const char *
642 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
643  unsigned char *u = (unsigned char *) ptr;
644  const unsigned char *eu = u + sz;
645  for (; u != eu; ++u) {
646  char d = *(c++);
647  unsigned char uu;
648  if ((d >= '0') && (d <= '9'))
649  uu = (unsigned char)((d - '0') << 4);
650  else if ((d >= 'a') && (d <= 'f'))
651  uu = (unsigned char)((d - ('a'-10)) << 4);
652  else
653  return (char *) 0;
654  d = *(c++);
655  if ((d >= '0') && (d <= '9'))
656  uu |= (unsigned char)(d - '0');
657  else if ((d >= 'a') && (d <= 'f'))
658  uu |= (unsigned char)(d - ('a'-10));
659  else
660  return (char *) 0;
661  *u = uu;
662  }
663  return c;
664 }
665 
666 /*
667  Pack 'void *' into a string buffer.
668 */
669 SWIGRUNTIME char *
670 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
671  char *r = buff;
672  if ((2*sizeof(void *) + 2) > bsz) return 0;
673  *(r++) = '_';
674  r = SWIG_PackData(r,&ptr,sizeof(void *));
675  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
676  strcpy(r,name);
677  return buff;
678 }
679 
680 SWIGRUNTIME const char *
681 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
682  if (*c != '_') {
683  if (strcmp(c,"NULL") == 0) {
684  *ptr = (void *) 0;
685  return name;
686  } else {
687  return 0;
688  }
689  }
690  return SWIG_UnpackData(++c,ptr,sizeof(void *));
691 }
692 
693 SWIGRUNTIME char *
694 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
695  char *r = buff;
696  size_t lname = (name ? strlen(name) : 0);
697  if ((2*sz + 2 + lname) > bsz) return 0;
698  *(r++) = '_';
699  r = SWIG_PackData(r,ptr,sz);
700  if (lname) {
701  strncpy(r,name,lname+1);
702  } else {
703  *r = 0;
704  }
705  return buff;
706 }
707 
708 SWIGRUNTIME const char *
709 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
710  if (*c != '_') {
711  if (strcmp(c,"NULL") == 0) {
712  memset(ptr,0,sz);
713  return name;
714  } else {
715  return 0;
716  }
717  }
718  return SWIG_UnpackData(++c,ptr,sz);
719 }
720 
721 #ifdef __cplusplus
722 }
723 #endif
724 
725 /* Errors in SWIG */
726 #define SWIG_UnknownError -1
727 #define SWIG_IOError -2
728 #define SWIG_RuntimeError -3
729 #define SWIG_IndexError -4
730 #define SWIG_TypeError -5
731 #define SWIG_DivisionByZero -6
732 #define SWIG_OverflowError -7
733 #define SWIG_SyntaxError -8
734 #define SWIG_ValueError -9
735 #define SWIG_SystemError -10
736 #define SWIG_AttributeError -11
737 #define SWIG_MemoryError -12
738 #define SWIG_NullReferenceError -13
739 
740 
741 
742 /* Compatibility macros for Python 3 */
743 #if PY_VERSION_HEX >= 0x03000000
744 
745 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
746 #define PyInt_Check(x) PyLong_Check(x)
747 #define PyInt_AsLong(x) PyLong_AsLong(x)
748 #define PyInt_FromLong(x) PyLong_FromLong(x)
749 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
750 #define PyString_Check(name) PyBytes_Check(name)
751 #define PyString_FromString(x) PyUnicode_FromString(x)
752 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
753 #define PyString_AsString(str) PyBytes_AsString(str)
754 #define PyString_Size(str) PyBytes_Size(str)
755 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
756 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
757 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
758 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
759 
760 #endif
761 
762 #ifndef Py_TYPE
763 # define Py_TYPE(op) ((op)->ob_type)
764 #endif
765 
766 /* SWIG APIs for compatibility of both Python 2 & 3 */
767 
768 #if PY_VERSION_HEX >= 0x03000000
769 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
770 #else
771 # define SWIG_Python_str_FromFormat PyString_FromFormat
772 #endif
773 
774 
775 /* Warning: This function will allocate a new string in Python 3,
776  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
777  */
778 SWIGINTERN char*
780 {
781 #if PY_VERSION_HEX >= 0x03000000
782  char *cstr;
783  char *newstr;
784  Py_ssize_t len;
785  str = PyUnicode_AsUTF8String(str);
786  PyBytes_AsStringAndSize(str, &cstr, &len);
787  newstr = (char *) malloc(len+1);
788  memcpy(newstr, cstr, len+1);
789  Py_XDECREF(str);
790  return newstr;
791 #else
792  return PyString_AsString(str);
793 #endif
794 }
795 
796 #if PY_VERSION_HEX >= 0x03000000
797 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
798 #else
799 # define SWIG_Python_str_DelForPy3(x)
800 #endif
801 
802 
803 SWIGINTERN PyObject*
805 {
806 #if PY_VERSION_HEX >= 0x03000000
807  return PyUnicode_FromString(c);
808 #else
809  return PyString_FromString(c);
810 #endif
811 }
812 
813 /* Add PyOS_snprintf for old Pythons */
814 #if PY_VERSION_HEX < 0x02020000
815 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
816 # define PyOS_snprintf _snprintf
817 # else
818 # define PyOS_snprintf snprintf
819 # endif
820 #endif
821 
822 /* A crude PyString_FromFormat implementation for old Pythons */
823 #if PY_VERSION_HEX < 0x02020000
824 
825 #ifndef SWIG_PYBUFFER_SIZE
826 # define SWIG_PYBUFFER_SIZE 1024
827 #endif
828 
829 static PyObject *
830 PyString_FromFormat(const char *fmt, ...) {
831  va_list ap;
832  char buf[SWIG_PYBUFFER_SIZE * 2];
833  int res;
834  va_start(ap, fmt);
835  res = vsnprintf(buf, sizeof(buf), fmt, ap);
836  va_end(ap);
837  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
838 }
839 #endif
840 
841 #ifndef PyObject_DEL
842 # define PyObject_DEL PyObject_Del
843 #endif
844 
845 /* A crude PyExc_StopIteration exception for old Pythons */
846 #if PY_VERSION_HEX < 0x02020000
847 # ifndef PyExc_StopIteration
848 # define PyExc_StopIteration PyExc_RuntimeError
849 # endif
850 # ifndef PyObject_GenericGetAttr
851 # define PyObject_GenericGetAttr 0
852 # endif
853 #endif
854 
855 /* Py_NotImplemented is defined in 2.1 and up. */
856 #if PY_VERSION_HEX < 0x02010000
857 # ifndef Py_NotImplemented
858 # define Py_NotImplemented PyExc_RuntimeError
859 # endif
860 #endif
861 
862 /* A crude PyString_AsStringAndSize implementation for old Pythons */
863 #if PY_VERSION_HEX < 0x02010000
864 # ifndef PyString_AsStringAndSize
865 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
866 # endif
867 #endif
868 
869 /* PySequence_Size for old Pythons */
870 #if PY_VERSION_HEX < 0x02000000
871 # ifndef PySequence_Size
872 # define PySequence_Size PySequence_Length
873 # endif
874 #endif
875 
876 /* PyBool_FromLong for old Pythons */
877 #if PY_VERSION_HEX < 0x02030000
878 static
879 PyObject *PyBool_FromLong(long ok)
880 {
881  PyObject *result = ok ? Py_True : Py_False;
882  Py_INCREF(result);
883  return result;
884 }
885 #endif
886 
887 /* Py_ssize_t for old Pythons */
888 /* This code is as recommended by: */
889 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
890 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
891 typedef int Py_ssize_t;
892 # define PY_SSIZE_T_MAX INT_MAX
893 # define PY_SSIZE_T_MIN INT_MIN
894 typedef inquiry lenfunc;
895 typedef intargfunc ssizeargfunc;
896 typedef intintargfunc ssizessizeargfunc;
897 typedef intobjargproc ssizeobjargproc;
898 typedef intintobjargproc ssizessizeobjargproc;
899 typedef getreadbufferproc readbufferproc;
900 typedef getwritebufferproc writebufferproc;
901 typedef getsegcountproc segcountproc;
902 typedef getcharbufferproc charbufferproc;
903 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
904 {
905  long result = 0;
906  PyObject *i = PyNumber_Int(x);
907  if (i) {
908  result = PyInt_AsLong(i);
909  Py_DECREF(i);
910  }
911  return result;
912 }
913 #endif
914 
915 #if PY_VERSION_HEX < 0x02050000
916 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
917 #endif
918 
919 #if PY_VERSION_HEX < 0x02040000
920 #define Py_VISIT(op) \
921  do { \
922  if (op) { \
923  int vret = visit((op), arg); \
924  if (vret) \
925  return vret; \
926  } \
927  } while (0)
928 #endif
929 
930 #if PY_VERSION_HEX < 0x02030000
931 typedef struct {
932  PyTypeObject type;
933  PyNumberMethods as_number;
934  PyMappingMethods as_mapping;
935  PySequenceMethods as_sequence;
936  PyBufferProcs as_buffer;
937  PyObject *name, *slots;
939 #endif
940 
941 #if PY_VERSION_HEX < 0x02030000
942 typedef destructor freefunc;
943 #endif
944 
945 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
946  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
947  (PY_MAJOR_VERSION > 3))
948 # define SWIGPY_USE_CAPSULE
949 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
950 #endif
951 
952 #if PY_VERSION_HEX < 0x03020000
953 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
954 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
955 #define Py_hash_t long
956 #endif
957 
958 /* -----------------------------------------------------------------------------
959  * error manipulation
960  * ----------------------------------------------------------------------------- */
961 
962 SWIGRUNTIME PyObject*
964  PyObject* type = 0;
965  switch(code) {
966  case SWIG_MemoryError:
967  type = PyExc_MemoryError;
968  break;
969  case SWIG_IOError:
970  type = PyExc_IOError;
971  break;
972  case SWIG_RuntimeError:
973  type = PyExc_RuntimeError;
974  break;
975  case SWIG_IndexError:
976  type = PyExc_IndexError;
977  break;
978  case SWIG_TypeError:
979  type = PyExc_TypeError;
980  break;
981  case SWIG_DivisionByZero:
982  type = PyExc_ZeroDivisionError;
983  break;
984  case SWIG_OverflowError:
985  type = PyExc_OverflowError;
986  break;
987  case SWIG_SyntaxError:
988  type = PyExc_SyntaxError;
989  break;
990  case SWIG_ValueError:
991  type = PyExc_ValueError;
992  break;
993  case SWIG_SystemError:
994  type = PyExc_SystemError;
995  break;
996  case SWIG_AttributeError:
997  type = PyExc_AttributeError;
998  break;
999  default:
1000  type = PyExc_RuntimeError;
1001  }
1002  return type;
1003 }
1004 
1005 
1006 SWIGRUNTIME void
1007 SWIG_Python_AddErrorMsg(const char* mesg)
1008 {
1009  PyObject *type = 0;
1010  PyObject *value = 0;
1011  PyObject *traceback = 0;
1012 
1013  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1014  if (value) {
1015  char *tmp;
1016  PyObject *old_str = PyObject_Str(value);
1017  PyErr_Clear();
1018  Py_XINCREF(type);
1019 
1020  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1022  Py_DECREF(old_str);
1023  Py_DECREF(value);
1024  } else {
1025  PyErr_SetString(PyExc_RuntimeError, mesg);
1026  }
1027 }
1028 
1029 #if defined(SWIG_PYTHON_NO_THREADS)
1030 # if defined(SWIG_PYTHON_THREADS)
1031 # undef SWIG_PYTHON_THREADS
1032 # endif
1033 #endif
1034 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1035 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1036 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1037 # define SWIG_PYTHON_USE_GIL
1038 # endif
1039 # endif
1040 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1041 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1042 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1043 # endif
1044 # ifdef __cplusplus /* C++ code */
1045  class SWIG_Python_Thread_Block {
1046  bool status;
1047  PyGILState_STATE state;
1048  public:
1049  void end() { if (status) { PyGILState_Release(state); status = false;} }
1050  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1051  ~SWIG_Python_Thread_Block() { end(); }
1052  };
1053  class SWIG_Python_Thread_Allow {
1054  bool status;
1055  PyThreadState *save;
1056  public:
1057  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1058  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1059  ~SWIG_Python_Thread_Allow() { end(); }
1060  };
1061 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1062 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1063 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1064 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1065 # else /* C code */
1066 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1067 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1068 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1069 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1070 # endif
1071 # else /* Old thread way, not implemented, user must provide it */
1072 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1073 # define SWIG_PYTHON_INITIALIZE_THREADS
1074 # endif
1075 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1076 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1077 # endif
1078 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1079 # define SWIG_PYTHON_THREAD_END_BLOCK
1080 # endif
1081 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1082 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1083 # endif
1084 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1085 # define SWIG_PYTHON_THREAD_END_ALLOW
1086 # endif
1087 # endif
1088 #else /* No thread support */
1089 # define SWIG_PYTHON_INITIALIZE_THREADS
1090 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1091 # define SWIG_PYTHON_THREAD_END_BLOCK
1092 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1093 # define SWIG_PYTHON_THREAD_END_ALLOW
1094 #endif
1095 
1096 /* -----------------------------------------------------------------------------
1097  * Python API portion that goes into the runtime
1098  * ----------------------------------------------------------------------------- */
1099 
1100 #ifdef __cplusplus
1101 extern "C" {
1102 #endif
1103 
1104 /* -----------------------------------------------------------------------------
1105  * Constant declarations
1106  * ----------------------------------------------------------------------------- */
1107 
1108 /* Constant Types */
1109 #define SWIG_PY_POINTER 4
1110 #define SWIG_PY_BINARY 5
1111 
1112 /* Constant information structure */
1113 typedef struct swig_const_info {
1114  int type;
1115  char *name;
1116  long lvalue;
1117  double dvalue;
1118  void *pvalue;
1120 } swig_const_info;
1121 
1122 
1123 /* -----------------------------------------------------------------------------
1124  * Wrapper of PyInstanceMethod_New() used in Python 3
1125  * It is exported to the generated module, used for -fastproxy
1126  * ----------------------------------------------------------------------------- */
1127 #if PY_VERSION_HEX >= 0x03000000
1128 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1129 {
1130  return PyInstanceMethod_New(func);
1131 }
1132 #else
1133 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1134 {
1135  return NULL;
1136 }
1137 #endif
1138 
1139 #ifdef __cplusplus
1140 }
1141 #endif
1142 
1143 
1144 /* -----------------------------------------------------------------------------
1145  * pyrun.swg
1146  *
1147  * This file contains the runtime support for Python modules
1148  * and includes code for managing global variables and pointer
1149  * type checking.
1150  *
1151  * ----------------------------------------------------------------------------- */
1152 
1153 /* Common SWIG API */
1154 
1155 /* for raw pointers */
1156 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1157 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1158 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1159 
1160 #ifdef SWIGPYTHON_BUILTIN
1161 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1162 #else
1163 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1164 #endif
1165 
1166 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1167 
1168 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1169 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1170 #define swig_owntype int
1171 
1172 /* for raw packed data */
1173 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1174 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1175 
1176 /* for class or struct pointers */
1177 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1178 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1179 
1180 /* for C or C++ function pointers */
1181 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1182 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1183 
1184 /* for C++ member pointers, ie, member methods */
1185 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1186 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1187 
1188 
1189 /* Runtime API */
1190 
1191 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1192 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1193 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1194 
1195 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1196 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1197 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1198 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1199 #define SWIG_fail goto fail
1200 
1201 
1202 /* Runtime API implementation */
1203 
1204 /* Error manipulation */
1205 
1206 SWIGINTERN void
1207 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1209  PyErr_SetObject(errtype, obj);
1210  Py_DECREF(obj);
1212 }
1213 
1214 SWIGINTERN void
1215 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1217  PyErr_SetString(errtype, msg);
1219 }
1220 
1221 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1222 
1223 /* Set a constant value */
1224 
1225 #if defined(SWIGPYTHON_BUILTIN)
1226 
1227 SWIGINTERN void
1228 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1229  PyObject *s = PyString_InternFromString(key);
1230  PyList_Append(seq, s);
1231  Py_DECREF(s);
1232 }
1233 
1234 SWIGINTERN void
1235 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1236 #if PY_VERSION_HEX < 0x02030000
1237  PyDict_SetItemString(d, (char *)name, obj);
1238 #else
1239  PyDict_SetItemString(d, name, obj);
1240 #endif
1241  Py_DECREF(obj);
1242  if (public_interface)
1243  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1244 }
1245 
1246 #else
1247 
1248 SWIGINTERN void
1249 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1250 #if PY_VERSION_HEX < 0x02030000
1251  PyDict_SetItemString(d, (char *)name, obj);
1252 #else
1253  PyDict_SetItemString(d, name, obj);
1254 #endif
1255  Py_DECREF(obj);
1256 }
1257 
1258 #endif
1259 
1260 /* Append a value to the result obj */
1261 
1262 SWIGINTERN PyObject*
1263 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1264 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1265  if (!result) {
1266  result = obj;
1267  } else if (result == Py_None) {
1268  Py_DECREF(result);
1269  result = obj;
1270  } else {
1271  if (!PyList_Check(result)) {
1272  PyObject *o2 = result;
1273  result = PyList_New(1);
1274  PyList_SetItem(result, 0, o2);
1275  }
1276  PyList_Append(result,obj);
1277  Py_DECREF(obj);
1278  }
1279  return result;
1280 #else
1281  PyObject* o2;
1282  PyObject* o3;
1283  if (!result) {
1284  result = obj;
1285  } else if (result == Py_None) {
1286  Py_DECREF(result);
1287  result = obj;
1288  } else {
1289  if (!PyTuple_Check(result)) {
1290  o2 = result;
1291  result = PyTuple_New(1);
1292  PyTuple_SET_ITEM(result, 0, o2);
1293  }
1294  o3 = PyTuple_New(1);
1295  PyTuple_SET_ITEM(o3, 0, obj);
1296  o2 = result;
1297  result = PySequence_Concat(o2, o3);
1298  Py_DECREF(o2);
1299  Py_DECREF(o3);
1300  }
1301  return result;
1302 #endif
1303 }
1304 
1305 /* Unpack the argument tuple */
1306 
1308 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1309 {
1310  if (!args) {
1311  if (!min && !max) {
1312  return 1;
1313  } else {
1314  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1315  name, (min == max ? "" : "at least "), (int)min);
1316  return 0;
1317  }
1318  }
1319  if (!PyTuple_Check(args)) {
1320  if (min <= 1 && max >= 1) {
1321  Py_ssize_t i;
1322  objs[0] = args;
1323  for (i = 1; i < max; ++i) {
1324  objs[i] = 0;
1325  }
1326  return 2;
1327  }
1328  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1329  return 0;
1330  } else {
1331  Py_ssize_t l = PyTuple_GET_SIZE(args);
1332  if (l < min) {
1333  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1334  name, (min == max ? "" : "at least "), (int)min, (int)l);
1335  return 0;
1336  } else if (l > max) {
1337  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1338  name, (min == max ? "" : "at most "), (int)max, (int)l);
1339  return 0;
1340  } else {
1341  Py_ssize_t i;
1342  for (i = 0; i < l; ++i) {
1343  objs[i] = PyTuple_GET_ITEM(args, i);
1344  }
1345  for (; l < max; ++l) {
1346  objs[l] = 0;
1347  }
1348  return i + 1;
1349  }
1350  }
1351 }
1352 
1353 /* A functor is a function object with one single object argument */
1354 #if PY_VERSION_HEX >= 0x02020000
1355 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1356 #else
1357 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1358 #endif
1359 
1360 /*
1361  Helper for static pointer initialization for both C and C++ code, for example
1362  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1363 */
1364 #ifdef __cplusplus
1365 #define SWIG_STATIC_POINTER(var) var
1366 #else
1367 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1368 #endif
1369 
1370 /* -----------------------------------------------------------------------------
1371  * Pointer declarations
1372  * ----------------------------------------------------------------------------- */
1373 
1374 /* Flags for new pointer objects */
1375 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1376 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1377 
1378 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1379 
1380 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1381 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1382 
1383 #ifdef __cplusplus
1384 extern "C" {
1385 #endif
1386 
1387 /* How to access Py_None */
1388 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1389 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1390 # ifndef SWIG_PYTHON_BUILD_NONE
1391 # define SWIG_PYTHON_BUILD_NONE
1392 # endif
1393 # endif
1394 #endif
1395 
1396 #ifdef SWIG_PYTHON_BUILD_NONE
1397 # ifdef Py_None
1398 # undef Py_None
1399 # define Py_None SWIG_Py_None()
1400 # endif
1401 SWIGRUNTIMEINLINE PyObject *
1402 _SWIG_Py_None(void)
1403 {
1404  PyObject *none = Py_BuildValue((char*)"");
1405  Py_DECREF(none);
1406  return none;
1407 }
1408 SWIGRUNTIME PyObject *
1409 SWIG_Py_None(void)
1410 {
1411  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1412  return none;
1413 }
1414 #endif
1415 
1416 /* The python void return value */
1417 
1418 SWIGRUNTIMEINLINE PyObject *
1420 {
1421  PyObject *none = Py_None;
1422  Py_INCREF(none);
1423  return none;
1424 }
1425 
1426 /* SwigPyClientData */
1427 
1428 typedef struct {
1429  PyObject *klass;
1430  PyObject *newraw;
1431  PyObject *newargs;
1432  PyObject *destroy;
1433  int delargs;
1435  PyTypeObject *pytype;
1437 
1438 SWIGRUNTIMEINLINE int
1440 {
1442  return data ? data->implicitconv : 0;
1443 }
1444 
1445 SWIGRUNTIMEINLINE PyObject *
1447  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1448  PyObject *klass = data ? data->klass : 0;
1449  return (klass ? klass : PyExc_RuntimeError);
1450 }
1451 
1452 
1454 SwigPyClientData_New(PyObject* obj)
1455 {
1456  if (!obj) {
1457  return 0;
1458  } else {
1459  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1460  /* the klass element */
1461  data->klass = obj;
1462  Py_INCREF(data->klass);
1463  /* the newraw method and newargs arguments used to create a new raw instance */
1464  if (PyClass_Check(obj)) {
1465  data->newraw = 0;
1466  data->newargs = obj;
1467  Py_INCREF(obj);
1468  } else {
1469 #if (PY_VERSION_HEX < 0x02020000)
1470  data->newraw = 0;
1471 #else
1472  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1473 #endif
1474  if (data->newraw) {
1475  Py_INCREF(data->newraw);
1476  data->newargs = PyTuple_New(1);
1477  PyTuple_SetItem(data->newargs, 0, obj);
1478  } else {
1479  data->newargs = obj;
1480  }
1481  Py_INCREF(data->newargs);
1482  }
1483  /* the destroy method, aka as the C++ delete method */
1484  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1485  if (PyErr_Occurred()) {
1486  PyErr_Clear();
1487  data->destroy = 0;
1488  }
1489  if (data->destroy) {
1490  int flags;
1491  Py_INCREF(data->destroy);
1492  flags = PyCFunction_GET_FLAGS(data->destroy);
1493 #ifdef METH_O
1494  data->delargs = !(flags & (METH_O));
1495 #else
1496  data->delargs = 0;
1497 #endif
1498  } else {
1499  data->delargs = 0;
1500  }
1501  data->implicitconv = 0;
1502  data->pytype = 0;
1503  return data;
1504  }
1505 }
1506 
1507 SWIGRUNTIME void
1509  Py_XDECREF(data->newraw);
1510  Py_XDECREF(data->newargs);
1511  Py_XDECREF(data->destroy);
1512 }
1513 
1514 /* =============== SwigPyObject =====================*/
1515 
1516 typedef struct {
1517  PyObject_HEAD
1518  void *ptr;
1520  int own;
1521  PyObject *next;
1522 #ifdef SWIGPYTHON_BUILTIN
1523  PyObject *dict;
1524 #endif
1525 } SwigPyObject;
1526 
1527 
1528 #ifdef SWIGPYTHON_BUILTIN
1529 
1530 SWIGRUNTIME PyObject *
1531 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1532 {
1533  SwigPyObject *sobj = (SwigPyObject *)v;
1534 
1535  if (!sobj->dict)
1536  sobj->dict = PyDict_New();
1537 
1538  Py_INCREF(sobj->dict);
1539  return sobj->dict;
1540 }
1541 
1542 #endif
1543 
1544 SWIGRUNTIME PyObject *
1546 {
1547  return PyLong_FromVoidPtr(v->ptr);
1548 }
1549 
1550 SWIGRUNTIME PyObject *
1551 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1552 {
1553  PyObject *res = NULL;
1554  PyObject *args = PyTuple_New(1);
1555  if (args) {
1556  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1557  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1558  if (ofmt) {
1559 #if PY_VERSION_HEX >= 0x03000000
1560  res = PyUnicode_Format(ofmt,args);
1561 #else
1562  res = PyString_Format(ofmt,args);
1563 #endif
1564  Py_DECREF(ofmt);
1565  }
1566  Py_DECREF(args);
1567  }
1568  }
1569  return res;
1570 }
1571 
1572 SWIGRUNTIME PyObject *
1574 {
1575  return SwigPyObject_format("%o",v);
1576 }
1577 
1578 SWIGRUNTIME PyObject *
1580 {
1581  return SwigPyObject_format("%x",v);
1582 }
1583 
1584 SWIGRUNTIME PyObject *
1585 #ifdef METH_NOARGS
1587 #else
1588 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1589 #endif
1590 {
1591  const char *name = SWIG_TypePrettyName(v->ty);
1592  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1593  if (v->next) {
1594 # ifdef METH_NOARGS
1595  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1596 # else
1597  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1598 # endif
1599 # if PY_VERSION_HEX >= 0x03000000
1600  PyObject *joined = PyUnicode_Concat(repr, nrep);
1601  Py_DecRef(repr);
1602  Py_DecRef(nrep);
1603  repr = joined;
1604 # else
1605  PyString_ConcatAndDel(&repr,nrep);
1606 # endif
1607  }
1608  return repr;
1609 }
1610 
1611 SWIGRUNTIME int
1613 {
1614  void *i = v->ptr;
1615  void *j = w->ptr;
1616  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1617 }
1618 
1619 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1620 SWIGRUNTIME PyObject*
1622 {
1623  PyObject* res;
1624  if( op != Py_EQ && op != Py_NE ) {
1625  Py_INCREF(Py_NotImplemented);
1626  return Py_NotImplemented;
1627  }
1628  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1629  return res;
1630 }
1631 
1632 
1633 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1634 
1635 #ifdef SWIGPYTHON_BUILTIN
1636 static swig_type_info *SwigPyObject_stype = 0;
1637 SWIGRUNTIME PyTypeObject*
1638 SwigPyObject_type(void) {
1639  SwigPyClientData *cd;
1640  assert(SwigPyObject_stype);
1641  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1642  assert(cd);
1643  assert(cd->pytype);
1644  return cd->pytype;
1645 }
1646 #else
1647 SWIGRUNTIME PyTypeObject*
1649  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1650  return type;
1651 }
1652 #endif
1653 
1655 SwigPyObject_Check(PyObject *op) {
1656 #ifdef SWIGPYTHON_BUILTIN
1657  PyTypeObject *target_tp = SwigPyObject_type();
1658  if (PyType_IsSubtype(op->ob_type, target_tp))
1659  return 1;
1660  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1661 #else
1662  return (Py_TYPE(op) == SwigPyObject_type())
1663  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1664 #endif
1665 }
1666 
1667 SWIGRUNTIME PyObject *
1668 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1669 
1670 SWIGRUNTIME void
1672 {
1673  SwigPyObject *sobj = (SwigPyObject *) v;
1674  PyObject *next = sobj->next;
1675  if (sobj->own == SWIG_POINTER_OWN) {
1676  swig_type_info *ty = sobj->ty;
1677  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1678  PyObject *destroy = data ? data->destroy : 0;
1679  if (destroy) {
1680  /* destroy is always a VARARGS method */
1681  PyObject *res;
1682 
1683  /* PyObject_CallFunction() has the potential to silently drop
1684  the active active exception. In cases of unnamed temporary
1685  variable or where we just finished iterating over a generator
1686  StopIteration will be active right now, and this needs to
1687  remain true upon return from SwigPyObject_dealloc. So save
1688  and restore. */
1689 
1690  PyObject *val = NULL, *type = NULL, *tb = NULL;
1691  PyErr_Fetch(&val, &type, &tb);
1692 
1693  if (data->delargs) {
1694  /* we need to create a temporary object to carry the destroy operation */
1695  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1696  res = SWIG_Python_CallFunctor(destroy, tmp);
1697  Py_DECREF(tmp);
1698  } else {
1699  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1700  PyObject *mself = PyCFunction_GET_SELF(destroy);
1701  res = ((*meth)(mself, v));
1702  }
1703  if (!res)
1704  PyErr_WriteUnraisable(destroy);
1705 
1706  PyErr_Restore(val, type, tb);
1707 
1708  Py_XDECREF(res);
1709  }
1710 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1711  else {
1712  const char *name = SWIG_TypePrettyName(ty);
1713  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1714  }
1715 #endif
1716  }
1717  Py_XDECREF(next);
1718  PyObject_DEL(v);
1719 }
1720 
1721 SWIGRUNTIME PyObject*
1722 SwigPyObject_append(PyObject* v, PyObject* next)
1723 {
1724  SwigPyObject *sobj = (SwigPyObject *) v;
1725 #ifndef METH_O
1726  PyObject *tmp = 0;
1727  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1728  next = tmp;
1729 #endif
1730  if (!SwigPyObject_Check(next)) {
1731  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1732  return NULL;
1733  }
1734  sobj->next = next;
1735  Py_INCREF(next);
1736  return SWIG_Py_Void();
1737 }
1738 
1739 SWIGRUNTIME PyObject*
1740 #ifdef METH_NOARGS
1741 SwigPyObject_next(PyObject* v)
1742 #else
1743 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1744 #endif
1745 {
1746  SwigPyObject *sobj = (SwigPyObject *) v;
1747  if (sobj->next) {
1748  Py_INCREF(sobj->next);
1749  return sobj->next;
1750  } else {
1751  return SWIG_Py_Void();
1752  }
1753 }
1754 
1755 SWIGINTERN PyObject*
1756 #ifdef METH_NOARGS
1757 SwigPyObject_disown(PyObject *v)
1758 #else
1759 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1760 #endif
1761 {
1762  SwigPyObject *sobj = (SwigPyObject *)v;
1763  sobj->own = 0;
1764  return SWIG_Py_Void();
1765 }
1766 
1767 SWIGINTERN PyObject*
1768 #ifdef METH_NOARGS
1769 SwigPyObject_acquire(PyObject *v)
1770 #else
1771 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1772 #endif
1773 {
1774  SwigPyObject *sobj = (SwigPyObject *)v;
1775  sobj->own = SWIG_POINTER_OWN;
1776  return SWIG_Py_Void();
1777 }
1778 
1779 SWIGINTERN PyObject*
1780 SwigPyObject_own(PyObject *v, PyObject *args)
1781 {
1782  PyObject *val = 0;
1783 #if (PY_VERSION_HEX < 0x02020000)
1784  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1785 #elif (PY_VERSION_HEX < 0x02050000)
1786  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1787 #else
1788  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1789 #endif
1790  {
1791  return NULL;
1792  }
1793  else
1794  {
1795  SwigPyObject *sobj = (SwigPyObject *)v;
1796  PyObject *obj = PyBool_FromLong(sobj->own);
1797  if (val) {
1798 #ifdef METH_NOARGS
1799  if (PyObject_IsTrue(val)) {
1801  } else {
1803  }
1804 #else
1805  if (PyObject_IsTrue(val)) {
1806  SwigPyObject_acquire(v,args);
1807  } else {
1808  SwigPyObject_disown(v,args);
1809  }
1810 #endif
1811  }
1812  return obj;
1813  }
1814 }
1815 
1816 #ifdef METH_O
1817 static PyMethodDef
1818 swigobject_methods[] = {
1819  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1820  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1821  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1822  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1823  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1824  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1825  {0, 0, 0, 0}
1826 };
1827 #else
1828 static PyMethodDef
1830  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1831  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1832  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1833  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1834  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1835  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1836  {0, 0, 0, 0}
1837 };
1838 #endif
1839 
1840 #if PY_VERSION_HEX < 0x02020000
1841 SWIGINTERN PyObject *
1843 {
1844  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1845 }
1846 #endif
1847 
1848 SWIGRUNTIME PyTypeObject*
1850  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1851 
1852  static PyNumberMethods SwigPyObject_as_number = {
1853  (binaryfunc)0, /*nb_add*/
1854  (binaryfunc)0, /*nb_subtract*/
1855  (binaryfunc)0, /*nb_multiply*/
1856  /* nb_divide removed in Python 3 */
1857 #if PY_VERSION_HEX < 0x03000000
1858  (binaryfunc)0, /*nb_divide*/
1859 #endif
1860  (binaryfunc)0, /*nb_remainder*/
1861  (binaryfunc)0, /*nb_divmod*/
1862  (ternaryfunc)0,/*nb_power*/
1863  (unaryfunc)0, /*nb_negative*/
1864  (unaryfunc)0, /*nb_positive*/
1865  (unaryfunc)0, /*nb_absolute*/
1866  (inquiry)0, /*nb_nonzero*/
1867  0, /*nb_invert*/
1868  0, /*nb_lshift*/
1869  0, /*nb_rshift*/
1870  0, /*nb_and*/
1871  0, /*nb_xor*/
1872  0, /*nb_or*/
1873 #if PY_VERSION_HEX < 0x03000000
1874  0, /*nb_coerce*/
1875 #endif
1876  (unaryfunc)SwigPyObject_long, /*nb_int*/
1877 #if PY_VERSION_HEX < 0x03000000
1878  (unaryfunc)SwigPyObject_long, /*nb_long*/
1879 #else
1880  0, /*nb_reserved*/
1881 #endif
1882  (unaryfunc)0, /*nb_float*/
1883 #if PY_VERSION_HEX < 0x03000000
1884  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1885  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1886 #endif
1887 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1888  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1889 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1890  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1891 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1892  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1893 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1894  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1895 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1896  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1897 #endif
1898  };
1899 
1900  static PyTypeObject swigpyobject_type;
1901  static int type_init = 0;
1902  if (!type_init) {
1903  const PyTypeObject tmp = {
1904 #if PY_VERSION_HEX >= 0x03000000
1905  PyVarObject_HEAD_INIT(NULL, 0)
1906 #else
1907  PyObject_HEAD_INIT(NULL)
1908  0, /* ob_size */
1909 #endif
1910  (char *)"SwigPyObject", /* tp_name */
1911  sizeof(SwigPyObject), /* tp_basicsize */
1912  0, /* tp_itemsize */
1913  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1914  0, /* tp_print */
1915 #if PY_VERSION_HEX < 0x02020000
1916  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1917 #else
1918  (getattrfunc)0, /* tp_getattr */
1919 #endif
1920  (setattrfunc)0, /* tp_setattr */
1921 #if PY_VERSION_HEX >= 0x03000000
1922  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1923 #else
1924  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1925 #endif
1926  (reprfunc)SwigPyObject_repr, /* tp_repr */
1927  &SwigPyObject_as_number, /* tp_as_number */
1928  0, /* tp_as_sequence */
1929  0, /* tp_as_mapping */
1930  (hashfunc)0, /* tp_hash */
1931  (ternaryfunc)0, /* tp_call */
1932  0, /* tp_str */
1933  PyObject_GenericGetAttr, /* tp_getattro */
1934  0, /* tp_setattro */
1935  0, /* tp_as_buffer */
1936  Py_TPFLAGS_DEFAULT, /* tp_flags */
1937  swigobject_doc, /* tp_doc */
1938  0, /* tp_traverse */
1939  0, /* tp_clear */
1940  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1941  0, /* tp_weaklistoffset */
1942 #if PY_VERSION_HEX >= 0x02020000
1943  0, /* tp_iter */
1944  0, /* tp_iternext */
1945  swigobject_methods, /* tp_methods */
1946  0, /* tp_members */
1947  0, /* tp_getset */
1948  0, /* tp_base */
1949  0, /* tp_dict */
1950  0, /* tp_descr_get */
1951  0, /* tp_descr_set */
1952  0, /* tp_dictoffset */
1953  0, /* tp_init */
1954  0, /* tp_alloc */
1955  0, /* tp_new */
1956  0, /* tp_free */
1957  0, /* tp_is_gc */
1958  0, /* tp_bases */
1959  0, /* tp_mro */
1960  0, /* tp_cache */
1961  0, /* tp_subclasses */
1962  0, /* tp_weaklist */
1963 #endif
1964 #if PY_VERSION_HEX >= 0x02030000
1965  0, /* tp_del */
1966 #endif
1967 #if PY_VERSION_HEX >= 0x02060000
1968  0, /* tp_version_tag */
1969 #endif
1970 #if PY_VERSION_HEX >= 0x03040000
1971  0, /* tp_finalize */
1972 #endif
1973 #ifdef COUNT_ALLOCS
1974  0, /* tp_allocs */
1975  0, /* tp_frees */
1976  0, /* tp_maxalloc */
1977 #if PY_VERSION_HEX >= 0x02050000
1978  0, /* tp_prev */
1979 #endif
1980  0 /* tp_next */
1981 #endif
1982  };
1983  swigpyobject_type = tmp;
1984  type_init = 1;
1985 #if PY_VERSION_HEX < 0x02020000
1986  swigpyobject_type.ob_type = &PyType_Type;
1987 #else
1988  if (PyType_Ready(&swigpyobject_type) < 0)
1989  return NULL;
1990 #endif
1991  }
1992  return &swigpyobject_type;
1993 }
1994 
1995 SWIGRUNTIME PyObject *
1996 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1997 {
1998  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1999  if (sobj) {
2000  sobj->ptr = ptr;
2001  sobj->ty = ty;
2002  sobj->own = own;
2003  sobj->next = 0;
2004  }
2005  return (PyObject *)sobj;
2006 }
2007 
2008 /* -----------------------------------------------------------------------------
2009  * Implements a simple Swig Packed type, and use it instead of string
2010  * ----------------------------------------------------------------------------- */
2011 
2012 typedef struct {
2013  PyObject_HEAD
2014  void *pack;
2016  size_t size;
2017 } SwigPyPacked;
2018 
2019 SWIGRUNTIME int
2021 {
2022  char result[SWIG_BUFFER_SIZE];
2023  fputs("<Swig Packed ", fp);
2024  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2025  fputs("at ", fp);
2026  fputs(result, fp);
2027  }
2028  fputs(v->ty->name,fp);
2029  fputs(">", fp);
2030  return 0;
2031 }
2032 
2033 SWIGRUNTIME PyObject *
2035 {
2036  char result[SWIG_BUFFER_SIZE];
2037  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2038  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2039  } else {
2040  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2041  }
2042 }
2043 
2044 SWIGRUNTIME PyObject *
2046 {
2047  char result[SWIG_BUFFER_SIZE];
2048  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2049  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2050  } else {
2051  return SWIG_Python_str_FromChar(v->ty->name);
2052  }
2053 }
2054 
2055 SWIGRUNTIME int
2057 {
2058  size_t i = v->size;
2059  size_t j = w->size;
2060  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2061  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2062 }
2063 
2064 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2065 
2066 SWIGRUNTIME PyTypeObject*
2068  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2069  return type;
2070 }
2071 
2073 SwigPyPacked_Check(PyObject *op) {
2074  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2075  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2076 }
2077 
2078 SWIGRUNTIME void
2080 {
2081  if (SwigPyPacked_Check(v)) {
2082  SwigPyPacked *sobj = (SwigPyPacked *) v;
2083  free(sobj->pack);
2084  }
2085  PyObject_DEL(v);
2086 }
2087 
2088 SWIGRUNTIME PyTypeObject*
2090  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2091  static PyTypeObject swigpypacked_type;
2092  static int type_init = 0;
2093  if (!type_init) {
2094  const PyTypeObject tmp = {
2095 #if PY_VERSION_HEX>=0x03000000
2096  PyVarObject_HEAD_INIT(NULL, 0)
2097 #else
2098  PyObject_HEAD_INIT(NULL)
2099  0, /* ob_size */
2100 #endif
2101  (char *)"SwigPyPacked", /* tp_name */
2102  sizeof(SwigPyPacked), /* tp_basicsize */
2103  0, /* tp_itemsize */
2104  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2105  (printfunc)SwigPyPacked_print, /* tp_print */
2106  (getattrfunc)0, /* tp_getattr */
2107  (setattrfunc)0, /* tp_setattr */
2108 #if PY_VERSION_HEX>=0x03000000
2109  0, /* tp_reserved in 3.0.1 */
2110 #else
2111  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2112 #endif
2113  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2114  0, /* tp_as_number */
2115  0, /* tp_as_sequence */
2116  0, /* tp_as_mapping */
2117  (hashfunc)0, /* tp_hash */
2118  (ternaryfunc)0, /* tp_call */
2119  (reprfunc)SwigPyPacked_str, /* tp_str */
2120  PyObject_GenericGetAttr, /* tp_getattro */
2121  0, /* tp_setattro */
2122  0, /* tp_as_buffer */
2123  Py_TPFLAGS_DEFAULT, /* tp_flags */
2124  swigpacked_doc, /* tp_doc */
2125  0, /* tp_traverse */
2126  0, /* tp_clear */
2127  0, /* tp_richcompare */
2128  0, /* tp_weaklistoffset */
2129 #if PY_VERSION_HEX >= 0x02020000
2130  0, /* tp_iter */
2131  0, /* tp_iternext */
2132  0, /* tp_methods */
2133  0, /* tp_members */
2134  0, /* tp_getset */
2135  0, /* tp_base */
2136  0, /* tp_dict */
2137  0, /* tp_descr_get */
2138  0, /* tp_descr_set */
2139  0, /* tp_dictoffset */
2140  0, /* tp_init */
2141  0, /* tp_alloc */
2142  0, /* tp_new */
2143  0, /* tp_free */
2144  0, /* tp_is_gc */
2145  0, /* tp_bases */
2146  0, /* tp_mro */
2147  0, /* tp_cache */
2148  0, /* tp_subclasses */
2149  0, /* tp_weaklist */
2150 #endif
2151 #if PY_VERSION_HEX >= 0x02030000
2152  0, /* tp_del */
2153 #endif
2154 #if PY_VERSION_HEX >= 0x02060000
2155  0, /* tp_version_tag */
2156 #endif
2157 #if PY_VERSION_HEX >= 0x03040000
2158  0, /* tp_finalize */
2159 #endif
2160 #ifdef COUNT_ALLOCS
2161  0, /* tp_allocs */
2162  0, /* tp_frees */
2163  0, /* tp_maxalloc */
2164 #if PY_VERSION_HEX >= 0x02050000
2165  0, /* tp_prev */
2166 #endif
2167  0 /* tp_next */
2168 #endif
2169  };
2170  swigpypacked_type = tmp;
2171  type_init = 1;
2172 #if PY_VERSION_HEX < 0x02020000
2173  swigpypacked_type.ob_type = &PyType_Type;
2174 #else
2175  if (PyType_Ready(&swigpypacked_type) < 0)
2176  return NULL;
2177 #endif
2178  }
2179  return &swigpypacked_type;
2180 }
2181 
2182 SWIGRUNTIME PyObject *
2183 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2184 {
2185  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2186  if (sobj) {
2187  void *pack = malloc(size);
2188  if (pack) {
2189  memcpy(pack, ptr, size);
2190  sobj->pack = pack;
2191  sobj->ty = ty;
2192  sobj->size = size;
2193  } else {
2194  PyObject_DEL((PyObject *) sobj);
2195  sobj = 0;
2196  }
2197  }
2198  return (PyObject *) sobj;
2199 }
2200 
2202 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2203 {
2204  if (SwigPyPacked_Check(obj)) {
2205  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2206  if (sobj->size != size) return 0;
2207  memcpy(ptr, sobj->pack, size);
2208  return sobj->ty;
2209  } else {
2210  return 0;
2211  }
2212 }
2213 
2214 /* -----------------------------------------------------------------------------
2215  * pointers/data manipulation
2216  * ----------------------------------------------------------------------------- */
2217 
2218 SWIGRUNTIMEINLINE PyObject *
2220 {
2221  return SWIG_Python_str_FromChar("this");
2222 }
2223 
2224 static PyObject *swig_this = NULL;
2225 
2226 SWIGRUNTIME PyObject *
2228 {
2229  if (swig_this == NULL)
2230  swig_this = _SWIG_This();
2231  return swig_this;
2232 }
2233 
2234 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2235 
2236 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2237 #if PY_VERSION_HEX>=0x03000000
2238 #define SWIG_PYTHON_SLOW_GETSET_THIS
2239 #endif
2240 
2242 SWIG_Python_GetSwigThis(PyObject *pyobj)
2243 {
2244  PyObject *obj;
2245 
2246  if (SwigPyObject_Check(pyobj))
2247  return (SwigPyObject *) pyobj;
2248 
2249 #ifdef SWIGPYTHON_BUILTIN
2250  (void)obj;
2251 # ifdef PyWeakref_CheckProxy
2252  if (PyWeakref_CheckProxy(pyobj)) {
2253  pyobj = PyWeakref_GET_OBJECT(pyobj);
2254  if (pyobj && SwigPyObject_Check(pyobj))
2255  return (SwigPyObject*) pyobj;
2256  }
2257 # endif
2258  return NULL;
2259 #else
2260 
2261  obj = 0;
2262 
2263 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2264  if (PyInstance_Check(pyobj)) {
2265  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2266  } else {
2267  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2268  if (dictptr != NULL) {
2269  PyObject *dict = *dictptr;
2270  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2271  } else {
2272 #ifdef PyWeakref_CheckProxy
2273  if (PyWeakref_CheckProxy(pyobj)) {
2274  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2275  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2276  }
2277 #endif
2278  obj = PyObject_GetAttr(pyobj,SWIG_This());
2279  if (obj) {
2280  Py_DECREF(obj);
2281  } else {
2282  if (PyErr_Occurred()) PyErr_Clear();
2283  return 0;
2284  }
2285  }
2286  }
2287 #else
2288  obj = PyObject_GetAttr(pyobj,SWIG_This());
2289  if (obj) {
2290  Py_DECREF(obj);
2291  } else {
2292  if (PyErr_Occurred()) PyErr_Clear();
2293  return 0;
2294  }
2295 #endif
2296  if (obj && !SwigPyObject_Check(obj)) {
2297  /* a PyObject is called 'this', try to get the 'real this'
2298  SwigPyObject from it */
2299  return SWIG_Python_GetSwigThis(obj);
2300  }
2301  return (SwigPyObject *)obj;
2302 #endif
2303 }
2304 
2305 /* Acquire a pointer value */
2306 
2307 SWIGRUNTIME int
2308 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2309  if (own == SWIG_POINTER_OWN) {
2311  if (sobj) {
2312  int oldown = sobj->own;
2313  sobj->own = own;
2314  return oldown;
2315  }
2316  }
2317  return 0;
2318 }
2319 
2320 /* Convert a pointer value */
2321 
2322 SWIGRUNTIME int
2323 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2324  int res;
2325  SwigPyObject *sobj;
2326  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2327 
2328  if (!obj)
2329  return SWIG_ERROR;
2330  if (obj == Py_None && !implicit_conv) {
2331  if (ptr)
2332  *ptr = 0;
2333  return SWIG_OK;
2334  }
2335 
2336  res = SWIG_ERROR;
2337 
2338  sobj = SWIG_Python_GetSwigThis(obj);
2339  if (own)
2340  *own = 0;
2341  while (sobj) {
2342  void *vptr = sobj->ptr;
2343  if (ty) {
2344  swig_type_info *to = sobj->ty;
2345  if (to == ty) {
2346  /* no type cast needed */
2347  if (ptr) *ptr = vptr;
2348  break;
2349  } else {
2350  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2351  if (!tc) {
2352  sobj = (SwigPyObject *)sobj->next;
2353  } else {
2354  if (ptr) {
2355  int newmemory = 0;
2356  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2357  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2358  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2359  if (own)
2360  *own = *own | SWIG_CAST_NEW_MEMORY;
2361  }
2362  }
2363  break;
2364  }
2365  }
2366  } else {
2367  if (ptr) *ptr = vptr;
2368  break;
2369  }
2370  }
2371  if (sobj) {
2372  if (own)
2373  *own = *own | sobj->own;
2374  if (flags & SWIG_POINTER_DISOWN) {
2375  sobj->own = 0;
2376  }
2377  res = SWIG_OK;
2378  } else {
2379  if (implicit_conv) {
2380  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2381  if (data && !data->implicitconv) {
2382  PyObject *klass = data->klass;
2383  if (klass) {
2384  PyObject *impconv;
2385  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2386  impconv = SWIG_Python_CallFunctor(klass, obj);
2387  data->implicitconv = 0;
2388  if (PyErr_Occurred()) {
2389  PyErr_Clear();
2390  impconv = 0;
2391  }
2392  if (impconv) {
2393  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2394  if (iobj) {
2395  void *vptr;
2396  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2397  if (SWIG_IsOK(res)) {
2398  if (ptr) {
2399  *ptr = vptr;
2400  /* transfer the ownership to 'ptr' */
2401  iobj->own = 0;
2402  res = SWIG_AddCast(res);
2403  res = SWIG_AddNewMask(res);
2404  } else {
2405  res = SWIG_AddCast(res);
2406  }
2407  }
2408  }
2409  Py_DECREF(impconv);
2410  }
2411  }
2412  }
2413  }
2414  if (!SWIG_IsOK(res) && obj == Py_None) {
2415  if (ptr)
2416  *ptr = 0;
2417  if (PyErr_Occurred())
2418  PyErr_Clear();
2419  res = SWIG_OK;
2420  }
2421  }
2422  return res;
2423 }
2424 
2425 /* Convert a function ptr value */
2426 
2427 SWIGRUNTIME int
2428 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2429  if (!PyCFunction_Check(obj)) {
2430  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2431  } else {
2432  void *vptr = 0;
2433  swig_cast_info *tc;
2434 
2435  /* here we get the method pointer for callbacks */
2436  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2437  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2438  if (desc)
2439  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2440  if (!desc)
2441  return SWIG_ERROR;
2442  tc = SWIG_TypeCheck(desc,ty);
2443  if (tc) {
2444  int newmemory = 0;
2445  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2446  assert(!newmemory); /* newmemory handling not yet implemented */
2447  } else {
2448  return SWIG_ERROR;
2449  }
2450  return SWIG_OK;
2451  }
2452 }
2453 
2454 /* Convert a packed value value */
2455 
2456 SWIGRUNTIME int
2457 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2458  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2459  if (!to) return SWIG_ERROR;
2460  if (ty) {
2461  if (to != ty) {
2462  /* check type cast? */
2463  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2464  if (!tc) return SWIG_ERROR;
2465  }
2466  }
2467  return SWIG_OK;
2468 }
2469 
2470 /* -----------------------------------------------------------------------------
2471  * Create a new pointer object
2472  * ----------------------------------------------------------------------------- */
2473 
2474 /*
2475  Create a new instance object, without calling __init__, and set the
2476  'this' attribute.
2477 */
2478 
2479 SWIGRUNTIME PyObject*
2481 {
2482 #if (PY_VERSION_HEX >= 0x02020000)
2483  PyObject *inst = 0;
2484  PyObject *newraw = data->newraw;
2485  if (newraw) {
2486  inst = PyObject_Call(newraw, data->newargs, NULL);
2487  if (inst) {
2488 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2489  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2490  if (dictptr != NULL) {
2491  PyObject *dict = *dictptr;
2492  if (dict == NULL) {
2493  dict = PyDict_New();
2494  *dictptr = dict;
2495  PyDict_SetItem(dict, SWIG_This(), swig_this);
2496  }
2497  }
2498 #else
2499  PyObject *key = SWIG_This();
2500  PyObject_SetAttr(inst, key, swig_this);
2501 #endif
2502  }
2503  } else {
2504 #if PY_VERSION_HEX >= 0x03000000
2505  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2506  if (inst) {
2507  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2508  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2509  }
2510 #else
2511  PyObject *dict = PyDict_New();
2512  if (dict) {
2513  PyDict_SetItem(dict, SWIG_This(), swig_this);
2514  inst = PyInstance_NewRaw(data->newargs, dict);
2515  Py_DECREF(dict);
2516  }
2517 #endif
2518  }
2519  return inst;
2520 #else
2521 #if (PY_VERSION_HEX >= 0x02010000)
2522  PyObject *inst = 0;
2523  PyObject *dict = PyDict_New();
2524  if (dict) {
2525  PyDict_SetItem(dict, SWIG_This(), swig_this);
2526  inst = PyInstance_NewRaw(data->newargs, dict);
2527  Py_DECREF(dict);
2528  }
2529  return (PyObject *) inst;
2530 #else
2531  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2532  if (inst == NULL) {
2533  return NULL;
2534  }
2535  inst->in_class = (PyClassObject *)data->newargs;
2536  Py_INCREF(inst->in_class);
2537  inst->in_dict = PyDict_New();
2538  if (inst->in_dict == NULL) {
2539  Py_DECREF(inst);
2540  return NULL;
2541  }
2542 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2543  inst->in_weakreflist = NULL;
2544 #endif
2545 #ifdef Py_TPFLAGS_GC
2546  PyObject_GC_Init(inst);
2547 #endif
2548  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2549  return (PyObject *) inst;
2550 #endif
2551 #endif
2552 }
2553 
2554 SWIGRUNTIME void
2555 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2556 {
2557  PyObject *dict;
2558 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2559  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2560  if (dictptr != NULL) {
2561  dict = *dictptr;
2562  if (dict == NULL) {
2563  dict = PyDict_New();
2564  *dictptr = dict;
2565  }
2566  PyDict_SetItem(dict, SWIG_This(), swig_this);
2567  return;
2568  }
2569 #endif
2570  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2571  PyDict_SetItem(dict, SWIG_This(), swig_this);
2572  Py_DECREF(dict);
2573 }
2574 
2575 
2576 SWIGINTERN PyObject *
2578  PyObject *obj[2];
2579  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2580  return NULL;
2581  } else {
2582  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2583  if (sthis) {
2584  SwigPyObject_append((PyObject*) sthis, obj[1]);
2585  } else {
2586  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2587  }
2588  return SWIG_Py_Void();
2589  }
2590 }
2591 
2592 /* Create a new pointer object */
2593 
2594 SWIGRUNTIME PyObject *
2595 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2596  SwigPyClientData *clientdata;
2597  PyObject * robj;
2598  int own;
2599 
2600  if (!ptr)
2601  return SWIG_Py_Void();
2602 
2603  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2604  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2605  if (clientdata && clientdata->pytype) {
2606  SwigPyObject *newobj;
2607  if (flags & SWIG_BUILTIN_TP_INIT) {
2608  newobj = (SwigPyObject*) self;
2609  if (newobj->ptr) {
2610  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2611  while (newobj->next)
2612  newobj = (SwigPyObject *) newobj->next;
2613  newobj->next = next_self;
2614  newobj = (SwigPyObject *)next_self;
2615 #ifdef SWIGPYTHON_BUILTIN
2616  newobj->dict = 0;
2617 #endif
2618  }
2619  } else {
2620  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2621 #ifdef SWIGPYTHON_BUILTIN
2622  newobj->dict = 0;
2623 #endif
2624  }
2625  if (newobj) {
2626  newobj->ptr = ptr;
2627  newobj->ty = type;
2628  newobj->own = own;
2629  newobj->next = 0;
2630  return (PyObject*) newobj;
2631  }
2632  return SWIG_Py_Void();
2633  }
2634 
2635  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2636 
2637  robj = SwigPyObject_New(ptr, type, own);
2638  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2639  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2640  Py_DECREF(robj);
2641  robj = inst;
2642  }
2643  return robj;
2644 }
2645 
2646 /* Create a new packed object */
2647 
2648 SWIGRUNTIMEINLINE PyObject *
2649 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2650  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2651 }
2652 
2653 /* -----------------------------------------------------------------------------*
2654  * Get type list
2655  * -----------------------------------------------------------------------------*/
2656 
2657 #ifdef SWIG_LINK_RUNTIME
2658 void *SWIG_ReturnGlobalTypeList(void *);
2659 #endif
2660 
2663  static void *type_pointer = (void *)0;
2664  /* first check if module already created */
2665  if (!type_pointer) {
2666 #ifdef SWIG_LINK_RUNTIME
2667  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2668 #else
2669 # ifdef SWIGPY_USE_CAPSULE
2670  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2671 # else
2672  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2673  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2674 # endif
2675  if (PyErr_Occurred()) {
2676  PyErr_Clear();
2677  type_pointer = (void *)0;
2678  }
2679 #endif
2680  }
2681  return (swig_module_info *) type_pointer;
2682 }
2683 
2684 #if PY_MAJOR_VERSION < 2
2685 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2686  is copied out of Python/modsupport.c in python version 2.3.4 */
2687 SWIGINTERN int
2688 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2689 {
2690  PyObject *dict;
2691  if (!PyModule_Check(m)) {
2692  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2693  return SWIG_ERROR;
2694  }
2695  if (!o) {
2696  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2697  return SWIG_ERROR;
2698  }
2699 
2700  dict = PyModule_GetDict(m);
2701  if (dict == NULL) {
2702  /* Internal error -- modules must have a dict! */
2703  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2704  PyModule_GetName(m));
2705  return SWIG_ERROR;
2706  }
2707  if (PyDict_SetItemString(dict, name, o))
2708  return SWIG_ERROR;
2709  Py_DECREF(o);
2710  return SWIG_OK;
2711 }
2712 #endif
2713 
2714 SWIGRUNTIME void
2715 #ifdef SWIGPY_USE_CAPSULE
2716 SWIG_Python_DestroyModule(PyObject *obj)
2717 #else
2719 #endif
2720 {
2721 #ifdef SWIGPY_USE_CAPSULE
2722  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2723 #else
2725 #endif
2726  swig_type_info **types = swig_module->types;
2727  size_t i;
2728  for (i =0; i < swig_module->size; ++i) {
2729  swig_type_info *ty = types[i];
2730  if (ty->owndata) {
2732  if (data) SwigPyClientData_Del(data);
2733  }
2734  }
2735  Py_DECREF(SWIG_This());
2736  swig_this = NULL;
2737 }
2738 
2739 SWIGRUNTIME void
2741 #if PY_VERSION_HEX >= 0x03000000
2742  /* Add a dummy module object into sys.modules */
2743  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2744 #else
2745  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2746  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2747 #endif
2748 #ifdef SWIGPY_USE_CAPSULE
2749  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2750  if (pointer && module) {
2751  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2752  } else {
2753  Py_XDECREF(pointer);
2754  }
2755 #else
2756  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2757  if (pointer && module) {
2758  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2759  } else {
2760  Py_XDECREF(pointer);
2761  }
2762 #endif
2763 }
2764 
2765 /* The python cached type query */
2766 SWIGRUNTIME PyObject *
2768  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2769  return cache;
2770 }
2771 
2773 SWIG_Python_TypeQuery(const char *type)
2774 {
2775  PyObject *cache = SWIG_Python_TypeCache();
2776  PyObject *key = SWIG_Python_str_FromChar(type);
2777  PyObject *obj = PyDict_GetItem(cache, key);
2778  swig_type_info *descriptor;
2779  if (obj) {
2780 #ifdef SWIGPY_USE_CAPSULE
2781  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2782 #else
2783  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2784 #endif
2785  } else {
2787  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2788  if (descriptor) {
2789 #ifdef SWIGPY_USE_CAPSULE
2790  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2791 #else
2792  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2793 #endif
2794  PyDict_SetItem(cache, key, obj);
2795  Py_DECREF(obj);
2796  }
2797  }
2798  Py_DECREF(key);
2799  return descriptor;
2800 }
2801 
2802 /*
2803  For backward compatibility only
2804 */
2805 #define SWIG_POINTER_EXCEPTION 0
2806 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2807 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2808 
2809 SWIGRUNTIME int
2810 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2811 {
2812  if (PyErr_Occurred()) {
2813  PyObject *type = 0;
2814  PyObject *value = 0;
2815  PyObject *traceback = 0;
2816  PyErr_Fetch(&type, &value, &traceback);
2817  if (value) {
2818  char *tmp;
2819  PyObject *old_str = PyObject_Str(value);
2820  Py_XINCREF(type);
2821  PyErr_Clear();
2822  if (infront) {
2823  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2824  } else {
2825  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2826  }
2828  Py_DECREF(old_str);
2829  }
2830  return 1;
2831  } else {
2832  return 0;
2833  }
2834 }
2835 
2836 SWIGRUNTIME int
2838 {
2839  if (PyErr_Occurred()) {
2840  /* add information about failing argument */
2841  char mesg[256];
2842  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2843  return SWIG_Python_AddErrMesg(mesg, 1);
2844  } else {
2845  return 0;
2846  }
2847 }
2848 
2849 SWIGRUNTIMEINLINE const char *
2850 SwigPyObject_GetDesc(PyObject *self)
2851 {
2852  SwigPyObject *v = (SwigPyObject *)self;
2853  swig_type_info *ty = v ? v->ty : 0;
2854  return ty ? ty->str : "";
2855 }
2856 
2857 SWIGRUNTIME void
2858 SWIG_Python_TypeError(const char *type, PyObject *obj)
2859 {
2860  if (type) {
2861 #if defined(SWIG_COBJECT_TYPES)
2862  if (obj && SwigPyObject_Check(obj)) {
2863  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2864  if (otype) {
2865  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2866  type, otype);
2867  return;
2868  }
2869  } else
2870 #endif
2871  {
2872  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2873  if (otype) {
2874  PyObject *str = PyObject_Str(obj);
2875  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2876  if (cstr) {
2877  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2878  type, otype, cstr);
2880  } else {
2881  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2882  type, otype);
2883  }
2884  Py_XDECREF(str);
2885  return;
2886  }
2887  }
2888  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2889  } else {
2890  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2891  }
2892 }
2893 
2894 
2895 /* Convert a pointer value, signal an exception on a type mismatch */
2896 SWIGRUNTIME void *
2897 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2898  void *result;
2899  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2900  PyErr_Clear();
2901 #if SWIG_POINTER_EXCEPTION
2902  if (flags) {
2904  SWIG_Python_ArgFail(argnum);
2905  }
2906 #endif
2907  }
2908  return result;
2909 }
2910 
2911 #ifdef SWIGPYTHON_BUILTIN
2912 SWIGRUNTIME int
2913 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2914  PyTypeObject *tp = obj->ob_type;
2915  PyObject *descr;
2916  PyObject *encoded_name;
2917  descrsetfunc f;
2918  int res = -1;
2919 
2920 # ifdef Py_USING_UNICODE
2921  if (PyString_Check(name)) {
2922  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2923  if (!name)
2924  return -1;
2925  } else if (!PyUnicode_Check(name))
2926 # else
2927  if (!PyString_Check(name))
2928 # endif
2929  {
2930  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2931  return -1;
2932  } else {
2933  Py_INCREF(name);
2934  }
2935 
2936  if (!tp->tp_dict) {
2937  if (PyType_Ready(tp) < 0)
2938  goto done;
2939  }
2940 
2941  descr = _PyType_Lookup(tp, name);
2942  f = NULL;
2943  if (descr != NULL)
2944  f = descr->ob_type->tp_descr_set;
2945  if (!f) {
2946  if (PyString_Check(name)) {
2947  encoded_name = name;
2948  Py_INCREF(name);
2949  } else {
2950  encoded_name = PyUnicode_AsUTF8String(name);
2951  }
2952  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2953  Py_DECREF(encoded_name);
2954  } else {
2955  res = f(descr, obj, value);
2956  }
2957 
2958  done:
2959  Py_DECREF(name);
2960  return res;
2961 }
2962 #endif
2963 
2964 
2965 #ifdef __cplusplus
2966 }
2967 #endif
2968 
2969 
2970 
2971 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2972 
2973 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2974 
2975 
2976 
2977 /* -------- TYPES TABLE (BEGIN) -------- */
2978 
2979 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2980 #define SWIGTYPE_p_PLcGrid swig_types[1]
2981 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2982 #define SWIGTYPE_p_char swig_types[3]
2983 #define SWIGTYPE_p_double swig_types[4]
2984 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2985 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2986 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2987 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2988 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2989 #define SWIGTYPE_p_int swig_types[10]
2990 #define SWIGTYPE_p_p_char swig_types[11]
2991 #define SWIGTYPE_p_p_double swig_types[12]
2992 #define SWIGTYPE_p_unsigned_int swig_types[13]
2994 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2995 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2996 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2997 
2998 /* -------- TYPES TABLE (END) -------- */
2999 
3000 #if (PY_VERSION_HEX <= 0x02000000)
3001 # if !defined(SWIG_PYTHON_CLASSIC)
3002 # error "This python version requires swig to be run with the '-classic' option"
3003 # endif
3004 #endif
3005 
3006 /*-----------------------------------------------
3007  @(target):= _plplotc.so
3008  ------------------------------------------------*/
3009 #if PY_VERSION_HEX >= 0x03000000
3010 # define SWIG_init PyInit__plplotc
3011 
3012 #else
3013 # define SWIG_init init_plplotc
3014 
3015 #endif
3016 #define SWIG_name "_plplotc"
3017 
3018 #define SWIGVERSION 0x030012
3019 #define SWIG_VERSION SWIGVERSION
3020 
3021 
3022 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3023 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3024 
3025 
3026 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3027 #include <arrayobject.h>
3028 #include "plplot.h"
3029 #include "plplotP.h"
3030 
3031 #define NPY_PLINT NPY_INT32
3032 
3033 #ifdef PL_DOUBLE
3034 #define NPY_PLFLT NPY_FLOAT64
3035 #else
3036 #define NPY_PLFLT NPY_FLOAT32
3037 #endif
3038 
3039 // python-1.5 compatibility mode?
3040 #if !defined ( PySequence_Fast_GET_ITEM )
3041  #define PySequence_Fast_GET_ITEM PySequence_GetItem
3042 #endif
3043 #define PySequence_Size PySequence_Length
3044 
3045 
3046  static PLINT Alen = 0;
3047  static PLINT Xlen = 0, Ylen = 0;
3048 
3049 
3050 SWIGINTERN int
3051 SWIG_AsVal_double (PyObject *obj, double *val)
3052 {
3053  int res = SWIG_TypeError;
3054  if (PyFloat_Check(obj)) {
3055  if (val) *val = PyFloat_AsDouble(obj);
3056  return SWIG_OK;
3057 #if PY_VERSION_HEX < 0x03000000
3058  } else if (PyInt_Check(obj)) {
3059  if (val) *val = (double) PyInt_AsLong(obj);
3060  return SWIG_OK;
3061 #endif
3062  } else if (PyLong_Check(obj)) {
3063  double v = PyLong_AsDouble(obj);
3064  if (!PyErr_Occurred()) {
3065  if (val) *val = v;
3066  return SWIG_OK;
3067  } else {
3068  PyErr_Clear();
3069  }
3070  }
3071 #ifdef SWIG_PYTHON_CAST_MODE
3072  {
3073  int dispatch = 0;
3074  double d = PyFloat_AsDouble(obj);
3075  if (!PyErr_Occurred()) {
3076  if (val) *val = d;
3077  return SWIG_AddCast(SWIG_OK);
3078  } else {
3079  PyErr_Clear();
3080  }
3081  if (!dispatch) {
3082  long v = PyLong_AsLong(obj);
3083  if (!PyErr_Occurred()) {
3084  if (val) *val = v;
3086  } else {
3087  PyErr_Clear();
3088  }
3089  }
3090  }
3091 #endif
3092  return res;
3093 }
3094 
3095 
3096  #define SWIG_From_double PyFloat_FromDouble
3097 
3098 
3099  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3100  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3101  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3102  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3103  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3105  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3106 
3107 
3108 SWIGINTERNINLINE PyObject*
3110 {
3111  return PyInt_FromLong((long) value);
3112 }
3113 
3114 
3115 #include <limits.h>
3116 #if !defined(SWIG_NO_LLONG_MAX)
3117 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3118 # define LLONG_MAX __LONG_LONG_MAX__
3119 # define LLONG_MIN (-LLONG_MAX - 1LL)
3120 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3121 # endif
3122 #endif
3123 
3124 
3125 #include <float.h>
3126 
3127 
3128 #include <math.h>
3129 
3130 
3131 SWIGINTERNINLINE int
3132 SWIG_CanCastAsInteger(double *d, double min, double max) {
3133  double x = *d;
3134  if ((min <= x && x <= max)) {
3135  double fx = floor(x);
3136  double cx = ceil(x);
3137  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3138  if ((errno == EDOM) || (errno == ERANGE)) {
3139  errno = 0;
3140  } else {
3141  double summ, reps, diff;
3142  if (rd < x) {
3143  diff = x - rd;
3144  } else if (rd > x) {
3145  diff = rd - x;
3146  } else {
3147  return 1;
3148  }
3149  summ = rd + x;
3150  reps = diff/summ;
3151  if (reps < 8*DBL_EPSILON) {
3152  *d = rd;
3153  return 1;
3154  }
3155  }
3156  }
3157  return 0;
3158 }
3159 
3160 
3161 SWIGINTERN int
3162 SWIG_AsVal_long (PyObject *obj, long* val)
3163 {
3164 #if PY_VERSION_HEX < 0x03000000
3165  if (PyInt_Check(obj)) {
3166  if (val) *val = PyInt_AsLong(obj);
3167  return SWIG_OK;
3168  } else
3169 #endif
3170  if (PyLong_Check(obj)) {
3171  long v = PyLong_AsLong(obj);
3172  if (!PyErr_Occurred()) {
3173  if (val) *val = v;
3174  return SWIG_OK;
3175  } else {
3176  PyErr_Clear();
3177  return SWIG_OverflowError;
3178  }
3179  }
3180 #ifdef SWIG_PYTHON_CAST_MODE
3181  {
3182  int dispatch = 0;
3183  long v = PyInt_AsLong(obj);
3184  if (!PyErr_Occurred()) {
3185  if (val) *val = v;
3186  return SWIG_AddCast(SWIG_OK);
3187  } else {
3188  PyErr_Clear();
3189  }
3190  if (!dispatch) {
3191  double d;
3192  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3193  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3194  if (val) *val = (long)(d);
3195  return res;
3196  }
3197  }
3198  }
3199 #endif
3200  return SWIG_TypeError;
3201 }
3202 
3203 
3204 SWIGINTERN int
3205 SWIG_AsVal_int (PyObject * obj, int *val)
3206 {
3207  long v;
3208  int res = SWIG_AsVal_long (obj, &v);
3209  if (SWIG_IsOK(res)) {
3210  if ((v < INT_MIN || v > INT_MAX)) {
3211  return SWIG_OverflowError;
3212  } else {
3213  if (val) *val = (int)(v);
3214  }
3215  }
3216  return res;
3217 }
3218 
3219 
3220 SWIGINTERN int
3221 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3222 {
3223 #if PY_VERSION_HEX < 0x03000000
3224  if (PyInt_Check(obj)) {
3225  long v = PyInt_AsLong(obj);
3226  if (v >= 0) {
3227  if (val) *val = v;
3228  return SWIG_OK;
3229  } else {
3230  return SWIG_OverflowError;
3231  }
3232  } else
3233 #endif
3234  if (PyLong_Check(obj)) {
3235  unsigned long v = PyLong_AsUnsignedLong(obj);
3236  if (!PyErr_Occurred()) {
3237  if (val) *val = v;
3238  return SWIG_OK;
3239  } else {
3240  PyErr_Clear();
3241  return SWIG_OverflowError;
3242  }
3243  }
3244 #ifdef SWIG_PYTHON_CAST_MODE
3245  {
3246  int dispatch = 0;
3247  unsigned long v = PyLong_AsUnsignedLong(obj);
3248  if (!PyErr_Occurred()) {
3249  if (val) *val = v;
3250  return SWIG_AddCast(SWIG_OK);
3251  } else {
3252  PyErr_Clear();
3253  }
3254  if (!dispatch) {
3255  double d;
3256  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3257  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3258  if (val) *val = (unsigned long)(d);
3259  return res;
3260  }
3261  }
3262  }
3263 #endif
3264  return SWIG_TypeError;
3265 }
3266 
3267 
3268 SWIGINTERN int
3269 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3270 {
3271  unsigned long v;
3272  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3273  if (SWIG_IsOK(res)) {
3274  if ((v > UINT_MAX)) {
3275  return SWIG_OverflowError;
3276  } else {
3277  if (val) *val = (unsigned int)(v);
3278  }
3279  }
3280  return res;
3281 }
3282 
3283 
3284 SWIGINTERNINLINE PyObject*
3286 {
3287  return PyInt_FromSize_t((size_t) value);
3288 }
3289 
3290 
3293 {
3294  static int init = 0;
3295  static swig_type_info* info = 0;
3296  if (!init) {
3297  info = SWIG_TypeQuery("_p_char");
3298  init = 1;
3299  }
3300  return info;
3301 }
3302 
3303 
3304 SWIGINTERN int
3305 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3306 {
3307 #if PY_VERSION_HEX>=0x03000000
3308 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3309  if (PyBytes_Check(obj))
3310 #else
3311  if (PyUnicode_Check(obj))
3312 #endif
3313 #else
3314  if (PyString_Check(obj))
3315 #endif
3316  {
3317  char *cstr; Py_ssize_t len;
3318 #if PY_VERSION_HEX>=0x03000000
3319 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3320  if (!alloc && cptr) {
3321  /* We can't allow converting without allocation, since the internal
3322  representation of string in Python 3 is UCS-2/UCS-4 but we require
3323  a UTF-8 representation.
3324  TODO(bhy) More detailed explanation */
3325  return SWIG_RuntimeError;
3326  }
3327  obj = PyUnicode_AsUTF8String(obj);
3328  if(alloc) *alloc = SWIG_NEWOBJ;
3329 #endif
3330  PyBytes_AsStringAndSize(obj, &cstr, &len);
3331 #else
3332  PyString_AsStringAndSize(obj, &cstr, &len);
3333 #endif
3334  if (cptr) {
3335  if (alloc) {
3336  /*
3337  In python the user should not be able to modify the inner
3338  string representation. To warranty that, if you define
3339  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3340  buffer is always returned.
3341 
3342  The default behavior is just to return the pointer value,
3343  so, be careful.
3344  */
3345 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3346  if (*alloc != SWIG_OLDOBJ)
3347 #else
3348  if (*alloc == SWIG_NEWOBJ)
3349 #endif
3350  {
3351  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3352  *alloc = SWIG_NEWOBJ;
3353  } else {
3354  *cptr = cstr;
3355  *alloc = SWIG_OLDOBJ;
3356  }
3357  } else {
3358 #if PY_VERSION_HEX>=0x03000000
3359 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3360  *cptr = PyBytes_AsString(obj);
3361 #else
3362  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3363 #endif
3364 #else
3365  *cptr = SWIG_Python_str_AsChar(obj);
3366 #endif
3367  }
3368  }
3369  if (psize) *psize = len + 1;
3370 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3371  Py_XDECREF(obj);
3372 #endif
3373  return SWIG_OK;
3374  } else {
3375 #if defined(SWIG_PYTHON_2_UNICODE)
3376 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3377 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3378 #endif
3379 #if PY_VERSION_HEX<0x03000000
3380  if (PyUnicode_Check(obj)) {
3381  char *cstr; Py_ssize_t len;
3382  if (!alloc && cptr) {
3383  return SWIG_RuntimeError;
3384  }
3385  obj = PyUnicode_AsUTF8String(obj);
3386  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3387  if (cptr) {
3388  if (alloc) *alloc = SWIG_NEWOBJ;
3389  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3390  }
3391  if (psize) *psize = len + 1;
3392 
3393  Py_XDECREF(obj);
3394  return SWIG_OK;
3395  } else {
3396  Py_XDECREF(obj);
3397  }
3398  }
3399 #endif
3400 #endif
3401 
3402  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3403  if (pchar_descriptor) {
3404  void* vptr = 0;
3405  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3406  if (cptr) *cptr = (char *) vptr;
3407  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3408  if (alloc) *alloc = SWIG_OLDOBJ;
3409  return SWIG_OK;
3410  }
3411  }
3412  }
3413  return SWIG_TypeError;
3414 }
3415 
3416 
3417 SWIGINTERN int
3418 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3419 {
3420  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3421  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3422  if (SWIG_IsOK(res)) {
3423  /* special case of single char conversion when we don't need space for NUL */
3424  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3425  if (csize <= size) {
3426  if (val) {
3427  if (csize) memcpy(val, cptr, csize*sizeof(char));
3428  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3429  }
3430  if (alloc == SWIG_NEWOBJ) {
3431  free((char*)cptr);
3432  res = SWIG_DelNewMask(res);
3433  }
3434  return res;
3435  }
3436  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3437  }
3438  return SWIG_TypeError;
3439 }
3440 
3441 
3442 SWIGINTERNINLINE PyObject *
3443 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3444 {
3445  if (carray) {
3446  if (size > INT_MAX) {
3447  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3448  return pchar_descriptor ?
3449  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3450  } else {
3451 #if PY_VERSION_HEX >= 0x03000000
3452 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3453  return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3454 #else
3455 #if PY_VERSION_HEX >= 0x03010000
3456  return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3457 #else
3458  return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3459 #endif
3460 #endif
3461 #else
3462  return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3463 #endif
3464  }
3465  } else {
3466  return SWIG_Py_Void();
3467  }
3468 }
3469 
3470 
3471 SWIGINTERN size_t
3472 SWIG_strnlen(const char* s, size_t maxlen)
3473 {
3474  const char *p;
3475  for (p = s; maxlen-- && *p; p++)
3476  ;
3477  return p - s;
3478 }
3479 
3480 
3481 
3482 
3483 
3484 #define t_output_helper SWIG_Python_AppendOutput
3485 
3486 
3487 SWIGINTERN int
3488 SWIG_AsVal_char (PyObject * obj, char *val)
3489 {
3490  int res = SWIG_AsCharArray(obj, val, 1);
3491  if (!SWIG_IsOK(res)) {
3492  long v;
3493  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3494  if (SWIG_IsOK(res)) {
3495  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3496  if (val) *val = (char)(v);
3497  } else {
3498  res = SWIG_OverflowError;
3499  }
3500  }
3501  }
3502  return res;
3503 }
3504 
3505 #ifdef __cplusplus
3506 extern "C" {
3507 #endif
3508 
3509  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3510 
3511 // some really twisted stuff to allow calling a single precision library from python
3512  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3513  {
3514  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3515  mindims, maxdims );
3516  if ( !tmp )
3517  {
3518  // could be an incoming long array which can't be "safely" converted, do it anyway
3519  if ( PyArray_Check( in ) )
3520  {
3521  PyErr_Clear();
3522  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3523  }
3524  }
3525  return tmp;
3526  }
3527 
3528 
3529 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3530 
3531 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3532  PyObject *resultobj = 0;
3533  PLFLT arg1 ;
3534  PLFLT arg2 ;
3535  PLFLT *arg3 = (PLFLT *) 0 ;
3536  PLFLT *arg4 = (PLFLT *) 0 ;
3537  PLPointer arg5 = (PLPointer) 0 ;
3538  double val1 ;
3539  int ecode1 = 0 ;
3540  double val2 ;
3541  int ecode2 = 0 ;
3542  PLFLT temp3 ;
3543  int res3 = SWIG_TMPOBJ ;
3544  PLFLT temp4 ;
3545  int res4 = SWIG_TMPOBJ ;
3546  PyObject * obj0 = 0 ;
3547  PyObject * obj1 = 0 ;
3548 
3549  arg3 = &temp3;
3550  arg4 = &temp4;
3551  {
3552  arg5 = NULL;
3553  }
3554  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3555  ecode1 = SWIG_AsVal_double(obj0, &val1);
3556  if (!SWIG_IsOK(ecode1)) {
3557  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3558  }
3559  arg1 = (PLFLT)(val1);
3560  ecode2 = SWIG_AsVal_double(obj1, &val2);
3561  if (!SWIG_IsOK(ecode2)) {
3562  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3563  }
3564  arg2 = (PLFLT)(val2);
3565  pltr0(arg1,arg2,arg3,arg4,arg5);
3566  resultobj = SWIG_Py_Void();
3567  if (SWIG_IsTmpObj(res3)) {
3568  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3569  } else {
3570  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3571  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3572  }
3573  if (SWIG_IsTmpObj(res4)) {
3574  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3575  } else {
3576  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3577  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3578  }
3579  return resultobj;
3580 fail:
3581  return NULL;
3582 }
3583 
3584 
3585 
3586  PyArrayObject *pltr_xg, *pltr_yg;
3589 
3590  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3591  void cleanup_PLcGrid1( void );
3592  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3593  void cleanup_PLcGrid2( void );
3594 
3595  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3596  {
3597  // fprintf(stderr, "marshal PLcGrid1\n");
3598  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3599  {
3600  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3601  return NULL;
3602  }
3603  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3604  NPY_PLFLT, 1, 1 );
3605  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3606  NPY_PLFLT, 1, 1 );
3607  if ( pltr_xg == 0 || pltr_yg == 0 )
3608  {
3609  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3610  return NULL;
3611  }
3612  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3613  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3614  if ( isimg == 0 )
3615  {
3616  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3617  {
3618  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3619  return NULL;
3620  }
3621  }
3622  else
3623  {
3624  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3625  {
3626  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3627  return NULL;
3628  }
3629  }
3630  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3631  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3632  return &tmpGrid1;
3633  }
3634 
3635  void cleanup_PLcGrid1( void )
3636  {
3637  // fprintf(stderr, "cleanup PLcGrid1\n");
3638  Py_CLEAR( pltr_xg );
3639  Py_CLEAR( pltr_yg );
3640  }
3641 
3642  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3643  {
3644  int i, size;
3645  // fprintf(stderr, "marshal PLcGrid2\n");
3646  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3647  {
3648  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3649  return NULL;
3650  }
3651  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3652  NPY_PLFLT, 2, 2 );
3653  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3654  NPY_PLFLT, 2, 2 );
3655  if ( pltr_xg == 0 || pltr_yg == 0 )
3656  {
3657  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3658  return NULL;
3659  }
3660  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3661  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3662  {
3663  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3664  return NULL;
3665  }
3666  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3667  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3668  if ( isimg == 0 )
3669  {
3670  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3671  {
3672  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3673  return NULL;
3674  }
3675  }
3676  else
3677  {
3678  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3679  {
3680  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3681  return NULL;
3682  }
3683  }
3684  size = tmpGrid2.ny;
3685  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3686  for ( i = 0; i < tmpGrid2.nx; i++ )
3687  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3688  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3689  for ( i = 0; i < tmpGrid2.nx; i++ )
3690  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3691  return &tmpGrid2;
3692  }
3693 
3694  void cleanup_PLcGrid2( void )
3695  {
3696  // fprintf(stderr, "cleanup PLcGrid2\n");
3697  free( tmpGrid2.xg );
3698  free( tmpGrid2.yg );
3699  Py_CLEAR( pltr_xg );
3700  Py_CLEAR( pltr_yg );
3701  }
3702 
3703 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3704  PyObject *resultobj = 0;
3705  PLFLT arg1 ;
3706  PLFLT arg2 ;
3707  PLFLT *arg3 = (PLFLT *) 0 ;
3708  PLFLT *arg4 = (PLFLT *) 0 ;
3709  PLcGrid *arg5 = (PLcGrid *) 0 ;
3710  double val1 ;
3711  int ecode1 = 0 ;
3712  double val2 ;
3713  int ecode2 = 0 ;
3714  PLFLT temp3 ;
3715  int res3 = SWIG_TMPOBJ ;
3716  PLFLT temp4 ;
3717  int res4 = SWIG_TMPOBJ ;
3718  PyObject * obj0 = 0 ;
3719  PyObject * obj1 = 0 ;
3720  PyObject * obj2 = 0 ;
3721 
3722  arg3 = &temp3;
3723  arg4 = &temp4;
3724  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3725  ecode1 = SWIG_AsVal_double(obj0, &val1);
3726  if (!SWIG_IsOK(ecode1)) {
3727  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3728  }
3729  arg1 = (PLFLT)(val1);
3730  ecode2 = SWIG_AsVal_double(obj1, &val2);
3731  if (!SWIG_IsOK(ecode2)) {
3732  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3733  }
3734  arg2 = (PLFLT)(val2);
3735  {
3736  arg5 = marshal_PLcGrid1( obj2, 0 );
3737  if ( !arg5 )
3738  return NULL;
3739  }
3740  pltr1(arg1,arg2,arg3,arg4,arg5);
3741  resultobj = SWIG_Py_Void();
3742  if (SWIG_IsTmpObj(res3)) {
3743  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3744  } else {
3745  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3746  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3747  }
3748  if (SWIG_IsTmpObj(res4)) {
3749  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3750  } else {
3751  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3752  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3753  }
3754  {
3755  cleanup_PLcGrid1();
3756  }
3757  return resultobj;
3758 fail:
3759  {
3760  cleanup_PLcGrid1();
3761  }
3762  return NULL;
3763 }
3764 
3765 
3766 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3767  PyObject *resultobj = 0;
3768  PLFLT arg1 ;
3769  PLFLT arg2 ;
3770  PLFLT *arg3 = (PLFLT *) 0 ;
3771  PLFLT *arg4 = (PLFLT *) 0 ;
3772  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3773  double val1 ;
3774  int ecode1 = 0 ;
3775  double val2 ;
3776  int ecode2 = 0 ;
3777  PLFLT temp3 ;
3778  int res3 = SWIG_TMPOBJ ;
3779  PLFLT temp4 ;
3780  int res4 = SWIG_TMPOBJ ;
3781  PyObject * obj0 = 0 ;
3782  PyObject * obj1 = 0 ;
3783  PyObject * obj2 = 0 ;
3784 
3785  arg3 = &temp3;
3786  arg4 = &temp4;
3787  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3788  ecode1 = SWIG_AsVal_double(obj0, &val1);
3789  if (!SWIG_IsOK(ecode1)) {
3790  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3791  }
3792  arg1 = (PLFLT)(val1);
3793  ecode2 = SWIG_AsVal_double(obj1, &val2);
3794  if (!SWIG_IsOK(ecode2)) {
3795  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3796  }
3797  arg2 = (PLFLT)(val2);
3798  {
3799  arg5 = marshal_PLcGrid2( obj2, 0 );
3800  if ( !arg5 )
3801  return NULL;
3802  }
3803  pltr2(arg1,arg2,arg3,arg4,arg5);
3804  resultobj = SWIG_Py_Void();
3805  if (SWIG_IsTmpObj(res3)) {
3806  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3807  } else {
3808  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3809  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3810  }
3811  if (SWIG_IsTmpObj(res4)) {
3812  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3813  } else {
3814  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3815  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3816  }
3817  {
3818  cleanup_PLcGrid2();
3819  }
3820  return resultobj;
3821 fail:
3822  {
3823  cleanup_PLcGrid2();
3824  }
3825  return NULL;
3826 }
3827 
3828 
3829 
3830  // helper code for handling the callback
3831 #if 0
3832  static PyInterpreterState *save_interp = NULL;
3833 #endif
3835  PyObject* python_pltr = NULL;
3836  PyObject* python_f2eval = NULL;
3837  PyObject* python_ct = NULL;
3838  PyObject* python_mapform = NULL;
3839  PyObject* python_label = NULL;
3840 
3841 #if 0
3842 #define MY_BLOCK_THREADS { \
3843  PyThreadState *prev_state, *new_state; \
3844  /* need to have started a thread at some stage */ \
3845  /* for the following to work */ \
3846  PyEval_AcquireLock(); \
3847  new_state = PyThreadState_New( save_interp ); \
3848  prev_state = PyThreadState_Swap( new_state );
3849 #define MY_UNBLOCK_THREADS \
3850  new_state = PyThreadState_Swap( prev_state ); \
3851  PyThreadState_Clear( new_state ); \
3852  PyEval_ReleaseLock(); \
3853  PyThreadState_Delete( new_state ); \
3854  }
3855 #else
3856 #define MY_BLOCK_THREADS
3857 #define MY_UNBLOCK_THREADS
3858 #endif
3859 
3860 // Function prototypes
3861  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3863  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3864  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3865  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3866  pltr_func marshal_pltr( PyObject* input );
3867  void cleanup_pltr( void );
3868  ct_func marshal_ct( PyObject* input );
3869  void cleanup_ct( void );
3870  mapform_func marshal_mapform( PyObject* input );
3871  void cleanup_mapform( void );
3872  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3873  void cleanup_PLPointer( void );
3874 
3875 
3876 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3877 
3878  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3879  {
3880  PyObject *pdata, *arglist, *result;
3881  PyArrayObject *tmp;
3882 
3883  // the data argument is acutally a pointer to a python object
3884  pdata = (PyObject *) data;
3885  if ( data == NULL )
3886  {
3887  pdata = Py_None;
3888  }
3889  if ( python_pltr ) // if not something is terribly wrong
3890  { // hold a reference to the data object
3891  Py_XINCREF( pdata );
3892  // grab the Global Interpreter Lock to be sure threads don't mess us up
3894  // build the argument list
3895 #ifdef PL_DOUBLE
3896  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3897 #else
3898  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3899 #endif
3900  if ( arglist == NULL )
3901  {
3902  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3903  *tx = *ty = 0;
3904  return;
3905  }
3906  // call the python function
3907  result = PyEval_CallObject( python_pltr, arglist );
3908  // release the argument list
3909  Py_CLEAR( arglist );
3910  // check and unpack the result
3911  if ( result == NULL )
3912  {
3913  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3914  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3915  *tx = *ty = 0;
3916  }
3917  else
3918  {
3919  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3920  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3921  {
3922  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3923  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3924  *tx = *ty = 0;
3925  }
3926  else
3927  {
3928  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3929  *tx = t[0];
3930  *ty = t[1];
3931  Py_CLEAR( tmp );
3932  }
3933  }
3934  // release the result
3935  Py_CLEAR( result );
3936  // release the global interpreter lock
3938  }
3939  }
3940 
3942  {
3943  PyObject *pdata, *arglist, *result;
3944  PLFLT fresult = 0.0;
3945 
3946  // the data argument is acutally a pointer to a python object
3947  pdata = (PyObject *) data;
3948  if ( python_f2eval ) // if not something is terribly wrong
3949  { // hold a reference to the data object
3950  Py_XINCREF( pdata );
3951  // grab the Global Interpreter Lock to be sure threads don't mess us up
3953  // build the argument list
3954  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3955  // call the python function
3956  result = PyEval_CallObject( python_f2eval, arglist );
3957  // release the argument list
3958  Py_CLEAR( arglist );
3959  // check and unpack the result
3960  if ( !PyFloat_Check( result ) )
3961  {
3962  fprintf( stderr, "f2eval callback must return a float\n" );
3963  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3964  }
3965  else
3966  {
3967  // should I test the type here?
3968  fresult = (PLFLT) PyFloat_AsDouble( result );
3969  }
3970  // release the result
3971  Py_CLEAR( result );
3972  // release the global interpreter lock
3974  }
3975  return fresult;
3976  }
3977 
3978  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3979  {
3980  PyObject *pdata, *arglist, *result, *unicode_string;
3981  char *pystring;
3982 
3983  // the data argument is acutally a pointer to a python object
3984  if ( data )
3985  pdata = (PyObject *) data;
3986  else
3987  pdata = Py_None;
3988  if ( python_label ) // if not something is terribly wrong
3989  { // hold a reference to the data object
3990  Py_XINCREF( pdata );
3991  // grab the Global Interpreter Lock to be sure threads don't mess us up
3993  // build the argument list
3994 #ifdef PL_DOUBLE
3995  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3996 #else
3997  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3998 #endif
3999  // call the python function
4000  result = PyEval_CallObject( python_label, arglist );
4001  // release the argument list
4002  //Py_CLEAR(arglist);
4003  // check and unpack the result
4004  if ( result == NULL )
4005  {
4006  fprintf( stderr, "label callback failed with 3 arguments\n" );
4007  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4008  }
4009  else if ( PyString_Check( result ) )
4010  {
4011  // should I test the type here?
4012  pystring = PyString_AsString( result );
4013  strncpy( string, pystring, len );
4014  }
4015  else if ( PyUnicode_Check( result ) )
4016  {
4017  // unicode_string is never freed? memory leak here?
4018  unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4019  pystring = PyBytes_AS_STRING( unicode_string );
4020  // len may be different then the byte string length w/ unicode?
4021  strncpy( string, pystring, len );
4022  }
4023  else
4024  {
4025  fprintf( stderr, "label callback must return a string\n" );
4026  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4027  }
4028  // release the result
4029  Py_CLEAR( result );
4030  // release the global interpreter lock
4032  }
4033  }
4034 
4035  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4036  {
4037  PyObject *px, *py, *pdata, *arglist, *result;
4038  npy_intp n;
4039  n = 1;
4040 
4041  // the data argument is acutally a pointer to a python object
4042  pdata = (PyObject *) data;
4043  if ( data == NULL )
4044  {
4045  pdata = Py_None;
4046  }
4047  if ( python_ct ) // if not something is terribly wrong
4048  { // hold a reference to the data object
4049  Py_XINCREF( pdata );
4050  // grab the Global Interpreter Lock to be sure threads don't mess us up
4052  // build the argument list
4053  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4054  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4055  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4056  // call the python function
4057  result = PyEval_CallObject( python_ct, arglist );
4058  // release the argument list
4059  Py_CLEAR( arglist );
4060  Py_CLEAR( px );
4061  Py_CLEAR( py );
4062  Py_CLEAR( pdata );
4063  // check and unpack the result
4064  if ( result == NULL )
4065  {
4066  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4067  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4068  }
4069  // release the result
4070  Py_CLEAR( result );
4071  // release the global interpreter lock
4073  }
4074  }
4075 
4077  {
4078  PyObject *px, *py, *arglist, *result;
4079  // PyArrayObject *tmpx, *tmpy;
4080 // PLFLT *xx, *yy;
4081 // PLINT i;
4082  npy_intp nn;
4083  nn = n;
4084 
4085  if ( python_mapform ) // if not something is terribly wrong
4086  { // grab the Global Interpreter Lock to be sure threads don't mess us up
4088  // build the argument list
4089 #ifdef PL_HAVE_PTHREAD
4090  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4091  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4092 #else
4093  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4094  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4095 #endif
4096  arglist = Py_BuildValue( "(iOO)", n, px, py );
4097  // call the python function
4098  result = PyEval_CallObject( python_mapform, arglist );
4099  // release the argument list
4100  Py_CLEAR( arglist );
4101  Py_CLEAR( px );
4102  Py_CLEAR( py );
4103  // check and unpack the result
4104  if ( result == NULL )
4105  {
4106  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4107  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4108  }
4109  // release the result
4110  Py_CLEAR( result );
4111  // release the global interpreter lock
4113  }
4114  }
4115 
4116 // marshal the pltr function pointer argument
4117  pltr_func marshal_pltr( PyObject* input )
4118  {
4119  pltr_func result = do_pltr_callback;
4120  PyObject * rep = PyObject_Repr( input );
4121  if ( rep )
4122  {
4123  // Memory leaks here? str and uni_str are not freed?
4124  char* str;
4125  if ( PyUnicode_Check( rep ) )
4126  {
4127  PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4128  str = PyBytes_AS_STRING( uni_str );
4129  }
4130  else
4131  {
4132  str = PyString_AsString( rep );
4133  }
4134  if ( strstr( str, "function pltr0" ) != 0 )
4135  {
4136  result = pltr0;
4137  pltr_type = CB_0;
4138  python_pltr = NULL;
4139  }
4140  else if ( strstr( str, "function pltr1" ) != 0 )
4141  {
4142  result = pltr1;
4143  pltr_type = CB_1;
4144  python_pltr = NULL;
4145  }
4146  else if ( strstr( str, "function pltr2" ) != 0 )
4147  {
4148  result = pltr2;
4149  pltr_type = CB_2;
4150  python_pltr = NULL;
4151  }
4152  else
4153  {
4154  python_pltr = input;
4155  pltr_type = CB_Python;
4156  Py_XINCREF( input );
4157  }
4158  Py_CLEAR( rep );
4159  }
4160  else
4161  {
4162  python_pltr = input;
4163  pltr_type = CB_Python;
4164  Py_XINCREF( input );
4165  }
4166  return result;
4167  }
4168 
4169  void cleanup_pltr( void )
4170  {
4171  Py_CLEAR( python_pltr );
4172  python_pltr = 0;
4173  }
4174 
4175 // marshal the ct function pointer argument
4176  ct_func marshal_ct( PyObject* input )
4177  {
4178  ct_func result = do_ct_callback;
4179  python_ct = input;
4180  Py_XINCREF( input );
4181  return result;
4182  }
4183 
4184  void cleanup_ct( void )
4185  {
4186  Py_CLEAR( python_ct );
4187  python_ct = 0;
4188  }
4189 
4190 // marshal the mapform function pointer argument
4191  mapform_func marshal_mapform( PyObject* input )
4192  {
4194  python_mapform = input;
4195  Py_XINCREF( input );
4196  return result;
4197  }
4198 
4199  void cleanup_mapform( void )
4200  {
4201  Py_CLEAR( python_mapform );
4202  python_mapform = 0;
4203  }
4204 
4205  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4206  {
4207  PLPointer result = NULL;
4208  switch ( pltr_type )
4209  {
4210  case CB_0:
4211  break;
4212  case CB_1:
4213  if ( input != Py_None )
4214  result = marshal_PLcGrid1( input, isimg );
4215  break;
4216  case CB_2:
4217  if ( input != Py_None )
4218  result = marshal_PLcGrid2( input, isimg );
4219  break;
4220  case CB_Python:
4221  Py_XINCREF( input );
4222  result = (PLPointer *) input;
4223  break;
4224  default:
4225  fprintf( stderr, "pltr_type is invalid\n" );
4226  }
4227  return result;
4228  }
4229 
4230  void cleanup_PLPointer( void )
4231  {
4232  switch ( pltr_type )
4233  {
4234  case CB_0:
4235  break;
4236  case CB_1:
4237  cleanup_PLcGrid1();
4238  break;
4239  case CB_2:
4240  cleanup_PLcGrid2();
4241  break;
4242  case CB_Python:
4243  Py_CLEAR( python_pltr );
4244  break;
4245  default:
4246  fprintf( stderr, "pltr_type is invalid\n" );
4247  }
4248  python_pltr = 0;
4249  pltr_type = CB_0;
4250  }
4251 
4252 
4253 
4254 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255  PyObject *resultobj = 0;
4256  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4257  int arg2 ;
4258  void *argp1 = 0 ;
4259  int res1 = 0 ;
4260  int val2 ;
4261  int ecode2 = 0 ;
4262  PyObject * obj0 = 0 ;
4263  PyObject * obj1 = 0 ;
4264 
4265  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4266  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4267  if (!SWIG_IsOK(res1)) {
4268  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4269  }
4270  arg1 = (PLGraphicsIn *)(argp1);
4271  ecode2 = SWIG_AsVal_int(obj1, &val2);
4272  if (!SWIG_IsOK(ecode2)) {
4273  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4274  }
4275  arg2 = (int)(val2);
4276  if (arg1) (arg1)->type = arg2;
4277  resultobj = SWIG_Py_Void();
4278  return resultobj;
4279 fail:
4280  return NULL;
4281 }
4282 
4283 
4284 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4285  PyObject *resultobj = 0;
4286  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4287  void *argp1 = 0 ;
4288  int res1 = 0 ;
4289  PyObject * obj0 = 0 ;
4290  int result;
4291 
4292  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4293  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4294  if (!SWIG_IsOK(res1)) {
4295  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4296  }
4297  arg1 = (PLGraphicsIn *)(argp1);
4298  result = (int) ((arg1)->type);
4299  resultobj = SWIG_From_int((int)(result));
4300  return resultobj;
4301 fail:
4302  return NULL;
4303 }
4304 
4305 
4306 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307  PyObject *resultobj = 0;
4308  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4309  unsigned int arg2 ;
4310  void *argp1 = 0 ;
4311  int res1 = 0 ;
4312  unsigned int val2 ;
4313  int ecode2 = 0 ;
4314  PyObject * obj0 = 0 ;
4315  PyObject * obj1 = 0 ;
4316 
4317  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4318  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4319  if (!SWIG_IsOK(res1)) {
4320  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4321  }
4322  arg1 = (PLGraphicsIn *)(argp1);
4323  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4324  if (!SWIG_IsOK(ecode2)) {
4325  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4326  }
4327  arg2 = (unsigned int)(val2);
4328  if (arg1) (arg1)->state = arg2;
4329  resultobj = SWIG_Py_Void();
4330  return resultobj;
4331 fail:
4332  return NULL;
4333 }
4334 
4335 
4336 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337  PyObject *resultobj = 0;
4338  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4339  void *argp1 = 0 ;
4340  int res1 = 0 ;
4341  PyObject * obj0 = 0 ;
4342  unsigned int result;
4343 
4344  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4345  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4346  if (!SWIG_IsOK(res1)) {
4347  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4348  }
4349  arg1 = (PLGraphicsIn *)(argp1);
4350  result = (unsigned int) ((arg1)->state);
4351  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4352  return resultobj;
4353 fail:
4354  return NULL;
4355 }
4356 
4357 
4358 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4359  PyObject *resultobj = 0;
4360  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4361  unsigned int arg2 ;
4362  void *argp1 = 0 ;
4363  int res1 = 0 ;
4364  unsigned int val2 ;
4365  int ecode2 = 0 ;
4366  PyObject * obj0 = 0 ;
4367  PyObject * obj1 = 0 ;
4368 
4369  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4370  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4371  if (!SWIG_IsOK(res1)) {
4372  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4373  }
4374  arg1 = (PLGraphicsIn *)(argp1);
4375  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4376  if (!SWIG_IsOK(ecode2)) {
4377  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4378  }
4379  arg2 = (unsigned int)(val2);
4380  if (arg1) (arg1)->keysym = arg2;
4381  resultobj = SWIG_Py_Void();
4382  return resultobj;
4383 fail:
4384  return NULL;
4385 }
4386 
4387 
4388 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4389  PyObject *resultobj = 0;
4390  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4391  void *argp1 = 0 ;
4392  int res1 = 0 ;
4393  PyObject * obj0 = 0 ;
4394  unsigned int result;
4395 
4396  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4397  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4398  if (!SWIG_IsOK(res1)) {
4399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4400  }
4401  arg1 = (PLGraphicsIn *)(argp1);
4402  result = (unsigned int) ((arg1)->keysym);
4403  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4404  return resultobj;
4405 fail:
4406  return NULL;
4407 }
4408 
4409 
4410 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4411  PyObject *resultobj = 0;
4412  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4413  unsigned int arg2 ;
4414  void *argp1 = 0 ;
4415  int res1 = 0 ;
4416  unsigned int val2 ;
4417  int ecode2 = 0 ;
4418  PyObject * obj0 = 0 ;
4419  PyObject * obj1 = 0 ;
4420 
4421  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4422  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4423  if (!SWIG_IsOK(res1)) {
4424  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4425  }
4426  arg1 = (PLGraphicsIn *)(argp1);
4427  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4428  if (!SWIG_IsOK(ecode2)) {
4429  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4430  }
4431  arg2 = (unsigned int)(val2);
4432  if (arg1) (arg1)->button = arg2;
4433  resultobj = SWIG_Py_Void();
4434  return resultobj;
4435 fail:
4436  return NULL;
4437 }
4438 
4439 
4440 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4441  PyObject *resultobj = 0;
4442  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4443  void *argp1 = 0 ;
4444  int res1 = 0 ;
4445  PyObject * obj0 = 0 ;
4446  unsigned int result;
4447 
4448  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4449  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4450  if (!SWIG_IsOK(res1)) {
4451  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4452  }
4453  arg1 = (PLGraphicsIn *)(argp1);
4454  result = (unsigned int) ((arg1)->button);
4455  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4456  return resultobj;
4457 fail:
4458  return NULL;
4459 }
4460 
4461 
4462 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463  PyObject *resultobj = 0;
4464  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4465  PLINT arg2 ;
4466  void *argp1 = 0 ;
4467  int res1 = 0 ;
4468  int val2 ;
4469  int ecode2 = 0 ;
4470  PyObject * obj0 = 0 ;
4471  PyObject * obj1 = 0 ;
4472 
4473  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4474  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4475  if (!SWIG_IsOK(res1)) {
4476  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4477  }
4478  arg1 = (PLGraphicsIn *)(argp1);
4479  ecode2 = SWIG_AsVal_int(obj1, &val2);
4480  if (!SWIG_IsOK(ecode2)) {
4481  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4482  }
4483  arg2 = (PLINT)(val2);
4484  if (arg1) (arg1)->subwindow = arg2;
4485  resultobj = SWIG_Py_Void();
4486  return resultobj;
4487 fail:
4488  return NULL;
4489 }
4490 
4491 
4492 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493  PyObject *resultobj = 0;
4494  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4495  void *argp1 = 0 ;
4496  int res1 = 0 ;
4497  PyObject * obj0 = 0 ;
4498  PLINT result;
4499 
4500  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4501  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4502  if (!SWIG_IsOK(res1)) {
4503  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4504  }
4505  arg1 = (PLGraphicsIn *)(argp1);
4506  result = (PLINT) ((arg1)->subwindow);
4507  resultobj = SWIG_From_int((int)(result));
4508  return resultobj;
4509 fail:
4510  return NULL;
4511 }
4512 
4513 
4514 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515  PyObject *resultobj = 0;
4516  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4517  char *arg2 ;
4518  void *argp1 = 0 ;
4519  int res1 = 0 ;
4520  char temp2[16] ;
4521  int res2 ;
4522  PyObject * obj0 = 0 ;
4523  PyObject * obj1 = 0 ;
4524 
4525  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4526  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4527  if (!SWIG_IsOK(res1)) {
4528  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4529  }
4530  arg1 = (PLGraphicsIn *)(argp1);
4531  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4532  if (!SWIG_IsOK(res2)) {
4533  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4534  }
4535  arg2 = (char *)(temp2);
4536  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4537  else memset(arg1->string,0,16*sizeof(char));
4538  resultobj = SWIG_Py_Void();
4539  return resultobj;
4540 fail:
4541  return NULL;
4542 }
4543 
4544 
4545 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546  PyObject *resultobj = 0;
4547  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4548  void *argp1 = 0 ;
4549  int res1 = 0 ;
4550  PyObject * obj0 = 0 ;
4551  char *result = 0 ;
4552 
4553  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) 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_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4557  }
4558  arg1 = (PLGraphicsIn *)(argp1);
4559  result = (char *)(char *) ((arg1)->string);
4560  {
4561  size_t size = SWIG_strnlen(result, 16);
4562 
4563 
4564 
4565  resultobj = SWIG_FromCharPtrAndSize(result, size);
4566  }
4567  return resultobj;
4568 fail:
4569  return NULL;
4570 }
4571 
4572 
4573 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574  PyObject *resultobj = 0;
4575  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4576  int arg2 ;
4577  void *argp1 = 0 ;
4578  int res1 = 0 ;
4579  int val2 ;
4580  int ecode2 = 0 ;
4581  PyObject * obj0 = 0 ;
4582  PyObject * obj1 = 0 ;
4583 
4584  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4585  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4586  if (!SWIG_IsOK(res1)) {
4587  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4588  }
4589  arg1 = (PLGraphicsIn *)(argp1);
4590  ecode2 = SWIG_AsVal_int(obj1, &val2);
4591  if (!SWIG_IsOK(ecode2)) {
4592  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4593  }
4594  arg2 = (int)(val2);
4595  if (arg1) (arg1)->pX = arg2;
4596  resultobj = SWIG_Py_Void();
4597  return resultobj;
4598 fail:
4599  return NULL;
4600 }
4601 
4602 
4603 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4604  PyObject *resultobj = 0;
4605  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4606  void *argp1 = 0 ;
4607  int res1 = 0 ;
4608  PyObject * obj0 = 0 ;
4609  int result;
4610 
4611  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4612  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4613  if (!SWIG_IsOK(res1)) {
4614  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4615  }
4616  arg1 = (PLGraphicsIn *)(argp1);
4617  result = (int) ((arg1)->pX);
4618  resultobj = SWIG_From_int((int)(result));
4619  return resultobj;
4620 fail:
4621  return NULL;
4622 }
4623 
4624 
4625 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4626  PyObject *resultobj = 0;
4627  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4628  int arg2 ;
4629  void *argp1 = 0 ;
4630  int res1 = 0 ;
4631  int val2 ;
4632  int ecode2 = 0 ;
4633  PyObject * obj0 = 0 ;
4634  PyObject * obj1 = 0 ;
4635 
4636  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4637  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4638  if (!SWIG_IsOK(res1)) {
4639  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4640  }
4641  arg1 = (PLGraphicsIn *)(argp1);
4642  ecode2 = SWIG_AsVal_int(obj1, &val2);
4643  if (!SWIG_IsOK(ecode2)) {
4644  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4645  }
4646  arg2 = (int)(val2);
4647  if (arg1) (arg1)->pY = arg2;
4648  resultobj = SWIG_Py_Void();
4649  return resultobj;
4650 fail:
4651  return NULL;
4652 }
4653 
4654 
4655 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4656  PyObject *resultobj = 0;
4657  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4658  void *argp1 = 0 ;
4659  int res1 = 0 ;
4660  PyObject * obj0 = 0 ;
4661  int result;
4662 
4663  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4664  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4665  if (!SWIG_IsOK(res1)) {
4666  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4667  }
4668  arg1 = (PLGraphicsIn *)(argp1);
4669  result = (int) ((arg1)->pY);
4670  resultobj = SWIG_From_int((int)(result));
4671  return resultobj;
4672 fail:
4673  return NULL;
4674 }
4675 
4676 
4677 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4678  PyObject *resultobj = 0;
4679  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4680  PLFLT arg2 ;
4681  void *argp1 = 0 ;
4682  int res1 = 0 ;
4683  double val2 ;
4684  int ecode2 = 0 ;
4685  PyObject * obj0 = 0 ;
4686  PyObject * obj1 = 0 ;
4687 
4688  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4689  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4690  if (!SWIG_IsOK(res1)) {
4691  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4692  }
4693  arg1 = (PLGraphicsIn *)(argp1);
4694  ecode2 = SWIG_AsVal_double(obj1, &val2);
4695  if (!SWIG_IsOK(ecode2)) {
4696  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4697  }
4698  arg2 = (PLFLT)(val2);
4699  if (arg1) (arg1)->dX = arg2;
4700  resultobj = SWIG_Py_Void();
4701  return resultobj;
4702 fail:
4703  return NULL;
4704 }
4705 
4706 
4707 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4708  PyObject *resultobj = 0;
4709  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4710  void *argp1 = 0 ;
4711  int res1 = 0 ;
4712  PyObject * obj0 = 0 ;
4713  PLFLT result;
4714 
4715  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4716  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4717  if (!SWIG_IsOK(res1)) {
4718  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4719  }
4720  arg1 = (PLGraphicsIn *)(argp1);
4721  result = (PLFLT) ((arg1)->dX);
4722  resultobj = SWIG_From_double((double)(result));
4723  return resultobj;
4724 fail:
4725  return NULL;
4726 }
4727 
4728 
4729 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4730  PyObject *resultobj = 0;
4731  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4732  PLFLT arg2 ;
4733  void *argp1 = 0 ;
4734  int res1 = 0 ;
4735  double val2 ;
4736  int ecode2 = 0 ;
4737  PyObject * obj0 = 0 ;
4738  PyObject * obj1 = 0 ;
4739 
4740  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4741  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4742  if (!SWIG_IsOK(res1)) {
4743  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4744  }
4745  arg1 = (PLGraphicsIn *)(argp1);
4746  ecode2 = SWIG_AsVal_double(obj1, &val2);
4747  if (!SWIG_IsOK(ecode2)) {
4748  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4749  }
4750  arg2 = (PLFLT)(val2);
4751  if (arg1) (arg1)->dY = arg2;
4752  resultobj = SWIG_Py_Void();
4753  return resultobj;
4754 fail:
4755  return NULL;
4756 }
4757 
4758 
4759 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4760  PyObject *resultobj = 0;
4761  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4762  void *argp1 = 0 ;
4763  int res1 = 0 ;
4764  PyObject * obj0 = 0 ;
4765  PLFLT result;
4766 
4767  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4768  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4769  if (!SWIG_IsOK(res1)) {
4770  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4771  }
4772  arg1 = (PLGraphicsIn *)(argp1);
4773  result = (PLFLT) ((arg1)->dY);
4774  resultobj = SWIG_From_double((double)(result));
4775  return resultobj;
4776 fail:
4777  return NULL;
4778 }
4779 
4780 
4781 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4782  PyObject *resultobj = 0;
4783  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4784  PLFLT arg2 ;
4785  void *argp1 = 0 ;
4786  int res1 = 0 ;
4787  double val2 ;
4788  int ecode2 = 0 ;
4789  PyObject * obj0 = 0 ;
4790  PyObject * obj1 = 0 ;
4791 
4792  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4793  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4794  if (!SWIG_IsOK(res1)) {
4795  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4796  }
4797  arg1 = (PLGraphicsIn *)(argp1);
4798  ecode2 = SWIG_AsVal_double(obj1, &val2);
4799  if (!SWIG_IsOK(ecode2)) {
4800  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4801  }
4802  arg2 = (PLFLT)(val2);
4803  if (arg1) (arg1)->wX = arg2;
4804  resultobj = SWIG_Py_Void();
4805  return resultobj;
4806 fail:
4807  return NULL;
4808 }
4809 
4810 
4811 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4812  PyObject *resultobj = 0;
4813  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4814  void *argp1 = 0 ;
4815  int res1 = 0 ;
4816  PyObject * obj0 = 0 ;
4817  PLFLT result;
4818 
4819  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4820  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4821  if (!SWIG_IsOK(res1)) {
4822  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4823  }
4824  arg1 = (PLGraphicsIn *)(argp1);
4825  result = (PLFLT) ((arg1)->wX);
4826  resultobj = SWIG_From_double((double)(result));
4827  return resultobj;
4828 fail:
4829  return NULL;
4830 }
4831 
4832 
4833 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4834  PyObject *resultobj = 0;
4835  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4836  PLFLT arg2 ;
4837  void *argp1 = 0 ;
4838  int res1 = 0 ;
4839  double val2 ;
4840  int ecode2 = 0 ;
4841  PyObject * obj0 = 0 ;
4842  PyObject * obj1 = 0 ;
4843 
4844  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4845  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4846  if (!SWIG_IsOK(res1)) {
4847  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4848  }
4849  arg1 = (PLGraphicsIn *)(argp1);
4850  ecode2 = SWIG_AsVal_double(obj1, &val2);
4851  if (!SWIG_IsOK(ecode2)) {
4852  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4853  }
4854  arg2 = (PLFLT)(val2);
4855  if (arg1) (arg1)->wY = arg2;
4856  resultobj = SWIG_Py_Void();
4857  return resultobj;
4858 fail:
4859  return NULL;
4860 }
4861 
4862 
4863 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4864  PyObject *resultobj = 0;
4865  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4866  void *argp1 = 0 ;
4867  int res1 = 0 ;
4868  PyObject * obj0 = 0 ;
4869  PLFLT result;
4870 
4871  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4872  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4873  if (!SWIG_IsOK(res1)) {
4874  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4875  }
4876  arg1 = (PLGraphicsIn *)(argp1);
4877  result = (PLFLT) ((arg1)->wY);
4878  resultobj = SWIG_From_double((double)(result));
4879  return resultobj;
4880 fail:
4881  return NULL;
4882 }
4883 
4884 
4885 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4886  PyObject *resultobj = 0;
4887  PLGraphicsIn *result = 0 ;
4888 
4889  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4890  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4892  return resultobj;
4893 fail:
4894  return NULL;
4895 }
4896 
4897 
4898 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4899  PyObject *resultobj = 0;
4900  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4901  void *argp1 = 0 ;
4902  int res1 = 0 ;
4903  PyObject * obj0 = 0 ;
4904 
4905  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4906  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4907  if (!SWIG_IsOK(res1)) {
4908  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4909  }
4910  arg1 = (PLGraphicsIn *)(argp1);
4911  free((char *) arg1);
4912  resultobj = SWIG_Py_Void();
4913  return resultobj;
4914 fail:
4915  return NULL;
4916 }
4917 
4918 
4919 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4920  PyObject *obj;
4921  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
4923  return SWIG_Py_Void();
4924 }
4925 
4926 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4927  PyObject *resultobj = 0;
4928  PLINT arg1 ;
4929  int val1 ;
4930  int ecode1 = 0 ;
4931  PyObject * obj0 = 0 ;
4932 
4933  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4934  ecode1 = SWIG_AsVal_int(obj0, &val1);
4935  if (!SWIG_IsOK(ecode1)) {
4936  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4937  }
4938  arg1 = (PLINT)(val1);
4939  plsxwin(arg1);
4940  resultobj = SWIG_Py_Void();
4941  return resultobj;
4942 fail:
4943  return NULL;
4944 }
4945 
4946 
4947 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4948  PyObject *resultobj = 0;
4949  PLINT arg1 ;
4950  PLINT arg2 ;
4951  int val1 ;
4952  int ecode1 = 0 ;
4953  int val2 ;
4954  int ecode2 = 0 ;
4955  PyObject * obj0 = 0 ;
4956  PyObject * obj1 = 0 ;
4957 
4958  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4959  ecode1 = SWIG_AsVal_int(obj0, &val1);
4960  if (!SWIG_IsOK(ecode1)) {
4961  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4962  }
4963  arg1 = (PLINT)(val1);
4964  ecode2 = SWIG_AsVal_int(obj1, &val2);
4965  if (!SWIG_IsOK(ecode2)) {
4966  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4967  }
4968  arg2 = (PLINT)(val2);
4969  pl_setcontlabelformat(arg1,arg2);
4970  resultobj = SWIG_Py_Void();
4971  return resultobj;
4972 fail:
4973  return NULL;
4974 }
4975 
4976 
4977 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4978  PyObject *resultobj = 0;
4979  PLFLT arg1 ;
4980  PLFLT arg2 ;
4981  PLFLT arg3 ;
4982  PLINT arg4 ;
4983  double val1 ;
4984  int ecode1 = 0 ;
4985  double val2 ;
4986  int ecode2 = 0 ;
4987  double val3 ;
4988  int ecode3 = 0 ;
4989  int val4 ;
4990  int ecode4 = 0 ;
4991  PyObject * obj0 = 0 ;
4992  PyObject * obj1 = 0 ;
4993  PyObject * obj2 = 0 ;
4994  PyObject * obj3 = 0 ;
4995 
4996  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4997  ecode1 = SWIG_AsVal_double(obj0, &val1);
4998  if (!SWIG_IsOK(ecode1)) {
4999  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5000  }
5001  arg1 = (PLFLT)(val1);
5002  ecode2 = SWIG_AsVal_double(obj1, &val2);
5003  if (!SWIG_IsOK(ecode2)) {
5004  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5005  }
5006  arg2 = (PLFLT)(val2);
5007  ecode3 = SWIG_AsVal_double(obj2, &val3);
5008  if (!SWIG_IsOK(ecode3)) {
5009  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5010  }
5011  arg3 = (PLFLT)(val3);
5012  ecode4 = SWIG_AsVal_int(obj3, &val4);
5013  if (!SWIG_IsOK(ecode4)) {
5014  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5015  }
5016  arg4 = (PLINT)(val4);
5017  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5018  resultobj = SWIG_Py_Void();
5019  return resultobj;
5020 fail:
5021  return NULL;
5022 }
5023 
5024 
5025 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026  PyObject *resultobj = 0;
5027  PLINT arg1 ;
5028  int val1 ;
5029  int ecode1 = 0 ;
5030  PyObject * obj0 = 0 ;
5031 
5032  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
5033  ecode1 = SWIG_AsVal_int(obj0, &val1);
5034  if (!SWIG_IsOK(ecode1)) {
5035  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5036  }
5037  arg1 = (PLINT)(val1);
5038  pladv(arg1);
5039  resultobj = SWIG_Py_Void();
5040  return resultobj;
5041 fail:
5042  return NULL;
5043 }
5044 
5045 
5046 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047  PyObject *resultobj = 0;
5048  PLFLT arg1 ;
5049  PLFLT arg2 ;
5050  PLFLT arg3 ;
5051  PLFLT arg4 ;
5052  PLFLT arg5 ;
5053  PLFLT arg6 ;
5054  PLFLT arg7 ;
5055  PLBOOL arg8 ;
5056  double val1 ;
5057  int ecode1 = 0 ;
5058  double val2 ;
5059  int ecode2 = 0 ;
5060  double val3 ;
5061  int ecode3 = 0 ;
5062  double val4 ;
5063  int ecode4 = 0 ;
5064  double val5 ;
5065  int ecode5 = 0 ;
5066  double val6 ;
5067  int ecode6 = 0 ;
5068  double val7 ;
5069  int ecode7 = 0 ;
5070  int val8 ;
5071  int ecode8 = 0 ;
5072  PyObject * obj0 = 0 ;
5073  PyObject * obj1 = 0 ;
5074  PyObject * obj2 = 0 ;
5075  PyObject * obj3 = 0 ;
5076  PyObject * obj4 = 0 ;
5077  PyObject * obj5 = 0 ;
5078  PyObject * obj6 = 0 ;
5079  PyObject * obj7 = 0 ;
5080 
5081  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5082  ecode1 = SWIG_AsVal_double(obj0, &val1);
5083  if (!SWIG_IsOK(ecode1)) {
5084  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5085  }
5086  arg1 = (PLFLT)(val1);
5087  ecode2 = SWIG_AsVal_double(obj1, &val2);
5088  if (!SWIG_IsOK(ecode2)) {
5089  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5090  }
5091  arg2 = (PLFLT)(val2);
5092  ecode3 = SWIG_AsVal_double(obj2, &val3);
5093  if (!SWIG_IsOK(ecode3)) {
5094  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5095  }
5096  arg3 = (PLFLT)(val3);
5097  ecode4 = SWIG_AsVal_double(obj3, &val4);
5098  if (!SWIG_IsOK(ecode4)) {
5099  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5100  }
5101  arg4 = (PLFLT)(val4);
5102  ecode5 = SWIG_AsVal_double(obj4, &val5);
5103  if (!SWIG_IsOK(ecode5)) {
5104  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5105  }
5106  arg5 = (PLFLT)(val5);
5107  ecode6 = SWIG_AsVal_double(obj5, &val6);
5108  if (!SWIG_IsOK(ecode6)) {
5109  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5110  }
5111  arg6 = (PLFLT)(val6);
5112  ecode7 = SWIG_AsVal_double(obj6, &val7);
5113  if (!SWIG_IsOK(ecode7)) {
5114  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5115  }
5116  arg7 = (PLFLT)(val7);
5117  ecode8 = SWIG_AsVal_int(obj7, &val8);
5118  if (!SWIG_IsOK(ecode8)) {
5119  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5120  }
5121  arg8 = (PLBOOL)(val8);
5122  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5123  resultobj = SWIG_Py_Void();
5124  return resultobj;
5125 fail:
5126  return NULL;
5127 }
5128 
5129 
5130 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5131  PyObject *resultobj = 0;
5132  PLFLT arg1 ;
5133  PLFLT arg2 ;
5134  char *arg3 = (char *) 0 ;
5135  PLFLT arg4 ;
5136  PLINT arg5 ;
5137  char *arg6 = (char *) 0 ;
5138  PLFLT arg7 ;
5139  PLINT arg8 ;
5140  double val1 ;
5141  int ecode1 = 0 ;
5142  double val2 ;
5143  int ecode2 = 0 ;
5144  int res3 ;
5145  char *buf3 = 0 ;
5146  int alloc3 = 0 ;
5147  double val4 ;
5148  int ecode4 = 0 ;
5149  int val5 ;
5150  int ecode5 = 0 ;
5151  int res6 ;
5152  char *buf6 = 0 ;
5153  int alloc6 = 0 ;
5154  double val7 ;
5155  int ecode7 = 0 ;
5156  int val8 ;
5157  int ecode8 = 0 ;
5158  PyObject * obj0 = 0 ;
5159  PyObject * obj1 = 0 ;
5160  PyObject * obj2 = 0 ;
5161  PyObject * obj3 = 0 ;
5162  PyObject * obj4 = 0 ;
5163  PyObject * obj5 = 0 ;
5164  PyObject * obj6 = 0 ;
5165  PyObject * obj7 = 0 ;
5166 
5167  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5168  ecode1 = SWIG_AsVal_double(obj0, &val1);
5169  if (!SWIG_IsOK(ecode1)) {
5170  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5171  }
5172  arg1 = (PLFLT)(val1);
5173  ecode2 = SWIG_AsVal_double(obj1, &val2);
5174  if (!SWIG_IsOK(ecode2)) {
5175  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5176  }
5177  arg2 = (PLFLT)(val2);
5178  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5179  if (!SWIG_IsOK(res3)) {
5180  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5181  }
5182  arg3 = (char *)(buf3);
5183  ecode4 = SWIG_AsVal_double(obj3, &val4);
5184  if (!SWIG_IsOK(ecode4)) {
5185  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5186  }
5187  arg4 = (PLFLT)(val4);
5188  ecode5 = SWIG_AsVal_int(obj4, &val5);
5189  if (!SWIG_IsOK(ecode5)) {
5190  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5191  }
5192  arg5 = (PLINT)(val5);
5193  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5194  if (!SWIG_IsOK(res6)) {
5195  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5196  }
5197  arg6 = (char *)(buf6);
5198  ecode7 = SWIG_AsVal_double(obj6, &val7);
5199  if (!SWIG_IsOK(ecode7)) {
5200  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5201  }
5202  arg7 = (PLFLT)(val7);
5203  ecode8 = SWIG_AsVal_int(obj7, &val8);
5204  if (!SWIG_IsOK(ecode8)) {
5205  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5206  }
5207  arg8 = (PLINT)(val8);
5208  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5209  resultobj = SWIG_Py_Void();
5210  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5211  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5212  return resultobj;
5213 fail:
5214  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5215  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5216  return NULL;
5217 }
5218 
5219 
5220 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5221  PyObject *resultobj = 0;
5222  PLINT arg1 ;
5223  PLFLT *arg2 = (PLFLT *) 0 ;
5224  PLFLT *arg3 = (PLFLT *) 0 ;
5225  PLINT arg4 ;
5226  PyArrayObject *tmp1 = NULL ;
5227  PyArrayObject *tmp3 = NULL ;
5228  int val4 ;
5229  int ecode4 = 0 ;
5230  PyObject * obj0 = 0 ;
5231  PyObject * obj1 = 0 ;
5232  PyObject * obj2 = 0 ;
5233 
5234  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5235  {
5236  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5237  if ( tmp1 == NULL )
5238  return NULL;
5239  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5240  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5241  }
5242  {
5243  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5244  if ( tmp3 == NULL )
5245  return NULL;
5246  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5247  {
5248  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5249  return NULL;
5250  }
5251  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5252  }
5253  ecode4 = SWIG_AsVal_int(obj2, &val4);
5254  if (!SWIG_IsOK(ecode4)) {
5255  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5256  }
5257  arg4 = (PLINT)(val4);
5258  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5259  resultobj = SWIG_Py_Void();
5260  {
5261  Py_CLEAR( tmp1 );
5262  }
5263  {
5264  Py_CLEAR( tmp3 );
5265  }
5266  return resultobj;
5267 fail:
5268  {
5269  Py_CLEAR( tmp1 );
5270  }
5271  {
5272  Py_CLEAR( tmp3 );
5273  }
5274  return NULL;
5275 }
5276 
5277 
5278 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5279  PyObject *resultobj = 0;
5280  PLINT *arg1 = (PLINT *) 0 ;
5281  PLINT *arg2 = (PLINT *) 0 ;
5282  PLINT *arg3 = (PLINT *) 0 ;
5283  PLINT *arg4 = (PLINT *) 0 ;
5284  PLINT *arg5 = (PLINT *) 0 ;
5285  PLFLT *arg6 = (PLFLT *) 0 ;
5286  PLFLT arg7 ;
5287  PLINT temp1 ;
5288  int res1 = SWIG_TMPOBJ ;
5289  PLINT temp2 ;
5290  int res2 = SWIG_TMPOBJ ;
5291  PLINT temp3 ;
5292  int res3 = SWIG_TMPOBJ ;
5293  PLINT temp4 ;
5294  int res4 = SWIG_TMPOBJ ;
5295  PLINT temp5 ;
5296  int res5 = SWIG_TMPOBJ ;
5297  PLFLT temp6 ;
5298  int res6 = SWIG_TMPOBJ ;
5299  double val7 ;
5300  int ecode7 = 0 ;
5301  PyObject * obj0 = 0 ;
5302 
5303  arg1 = &temp1;
5304  arg2 = &temp2;
5305  arg3 = &temp3;
5306  arg4 = &temp4;
5307  arg5 = &temp5;
5308  arg6 = &temp6;
5309  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5310  ecode7 = SWIG_AsVal_double(obj0, &val7);
5311  if (!SWIG_IsOK(ecode7)) {
5312  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5313  }
5314  arg7 = (PLFLT)(val7);
5315  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5316  resultobj = SWIG_Py_Void();
5317  if (SWIG_IsTmpObj(res1)) {
5318  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5319  } else {
5320  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5321  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5322  }
5323  if (SWIG_IsTmpObj(res2)) {
5324  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5325  } else {
5326  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5327  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5328  }
5329  if (SWIG_IsTmpObj(res3)) {
5330  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5331  } else {
5332  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5333  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5334  }
5335  if (SWIG_IsTmpObj(res4)) {
5336  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5337  } else {
5338  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5339  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5340  }
5341  if (SWIG_IsTmpObj(res5)) {
5342  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5343  } else {
5344  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5345  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5346  }
5347  if (SWIG_IsTmpObj(res6)) {
5348  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5349  } else {
5350  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5351  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5352  }
5353  return resultobj;
5354 fail:
5355  return NULL;
5356 }
5357 
5358 
5359 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5360  PyObject *resultobj = 0;
5361 
5362  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5363  plbop();
5364  resultobj = SWIG_Py_Void();
5365  return resultobj;
5366 fail:
5367  return NULL;
5368 }
5369 
5370 
5371 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5372  PyObject *resultobj = 0;
5373  char *arg1 = (char *) 0 ;
5374  PLFLT arg2 ;
5375  PLINT arg3 ;
5376  char *arg4 = (char *) 0 ;
5377  PLFLT arg5 ;
5378  PLINT arg6 ;
5379  int res1 ;
5380  char *buf1 = 0 ;
5381  int alloc1 = 0 ;
5382  double val2 ;
5383  int ecode2 = 0 ;
5384  int val3 ;
5385  int ecode3 = 0 ;
5386  int res4 ;
5387  char *buf4 = 0 ;
5388  int alloc4 = 0 ;
5389  double val5 ;
5390  int ecode5 = 0 ;
5391  int val6 ;
5392  int ecode6 = 0 ;
5393  PyObject * obj0 = 0 ;
5394  PyObject * obj1 = 0 ;
5395  PyObject * obj2 = 0 ;
5396  PyObject * obj3 = 0 ;
5397  PyObject * obj4 = 0 ;
5398  PyObject * obj5 = 0 ;
5399 
5400  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5401  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5402  if (!SWIG_IsOK(res1)) {
5403  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5404  }
5405  arg1 = (char *)(buf1);
5406  ecode2 = SWIG_AsVal_double(obj1, &val2);
5407  if (!SWIG_IsOK(ecode2)) {
5408  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5409  }
5410  arg2 = (PLFLT)(val2);
5411  ecode3 = SWIG_AsVal_int(obj2, &val3);
5412  if (!SWIG_IsOK(ecode3)) {
5413  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5414  }
5415  arg3 = (PLINT)(val3);
5416  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5417  if (!SWIG_IsOK(res4)) {
5418  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5419  }
5420  arg4 = (char *)(buf4);
5421  ecode5 = SWIG_AsVal_double(obj4, &val5);
5422  if (!SWIG_IsOK(ecode5)) {
5423  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5424  }
5425  arg5 = (PLFLT)(val5);
5426  ecode6 = SWIG_AsVal_int(obj5, &val6);
5427  if (!SWIG_IsOK(ecode6)) {
5428  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5429  }
5430  arg6 = (PLINT)(val6);
5431  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5432  resultobj = SWIG_Py_Void();
5433  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5434  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5435  return resultobj;
5436 fail:
5437  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5438  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5439  return NULL;
5440 }
5441 
5442 
5443 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5444  PyObject *resultobj = 0;
5445  char *arg1 = (char *) 0 ;
5446  char *arg2 = (char *) 0 ;
5447  PLFLT arg3 ;
5448  PLINT arg4 ;
5449  char *arg5 = (char *) 0 ;
5450  char *arg6 = (char *) 0 ;
5451  PLFLT arg7 ;
5452  PLINT arg8 ;
5453  char *arg9 = (char *) 0 ;
5454  char *arg10 = (char *) 0 ;
5455  PLFLT arg11 ;
5456  PLINT arg12 ;
5457  int res1 ;
5458  char *buf1 = 0 ;
5459  int alloc1 = 0 ;
5460  int res2 ;
5461  char *buf2 = 0 ;
5462  int alloc2 = 0 ;
5463  double val3 ;
5464  int ecode3 = 0 ;
5465  int val4 ;
5466  int ecode4 = 0 ;
5467  int res5 ;
5468  char *buf5 = 0 ;
5469  int alloc5 = 0 ;
5470  int res6 ;
5471  char *buf6 = 0 ;
5472  int alloc6 = 0 ;
5473  double val7 ;
5474  int ecode7 = 0 ;
5475  int val8 ;
5476  int ecode8 = 0 ;
5477  int res9 ;
5478  char *buf9 = 0 ;
5479  int alloc9 = 0 ;
5480  int res10 ;
5481  char *buf10 = 0 ;
5482  int alloc10 = 0 ;
5483  double val11 ;
5484  int ecode11 = 0 ;
5485  int val12 ;
5486  int ecode12 = 0 ;
5487  PyObject * obj0 = 0 ;
5488  PyObject * obj1 = 0 ;
5489  PyObject * obj2 = 0 ;
5490  PyObject * obj3 = 0 ;
5491  PyObject * obj4 = 0 ;
5492  PyObject * obj5 = 0 ;
5493  PyObject * obj6 = 0 ;
5494  PyObject * obj7 = 0 ;
5495  PyObject * obj8 = 0 ;
5496  PyObject * obj9 = 0 ;
5497  PyObject * obj10 = 0 ;
5498  PyObject * obj11 = 0 ;
5499 
5500  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5501  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5502  if (!SWIG_IsOK(res1)) {
5503  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5504  }
5505  arg1 = (char *)(buf1);
5506  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5507  if (!SWIG_IsOK(res2)) {
5508  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5509  }
5510  arg2 = (char *)(buf2);
5511  ecode3 = SWIG_AsVal_double(obj2, &val3);
5512  if (!SWIG_IsOK(ecode3)) {
5513  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5514  }
5515  arg3 = (PLFLT)(val3);
5516  ecode4 = SWIG_AsVal_int(obj3, &val4);
5517  if (!SWIG_IsOK(ecode4)) {
5518  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5519  }
5520  arg4 = (PLINT)(val4);
5521  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5522  if (!SWIG_IsOK(res5)) {
5523  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5524  }
5525  arg5 = (char *)(buf5);
5526  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5527  if (!SWIG_IsOK(res6)) {
5528  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5529  }
5530  arg6 = (char *)(buf6);
5531  ecode7 = SWIG_AsVal_double(obj6, &val7);
5532  if (!SWIG_IsOK(ecode7)) {
5533  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5534  }
5535  arg7 = (PLFLT)(val7);
5536  ecode8 = SWIG_AsVal_int(obj7, &val8);
5537  if (!SWIG_IsOK(ecode8)) {
5538  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5539  }
5540  arg8 = (PLINT)(val8);
5541  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5542  if (!SWIG_IsOK(res9)) {
5543  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5544  }
5545  arg9 = (char *)(buf9);
5546  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5547  if (!SWIG_IsOK(res10)) {
5548  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5549  }
5550  arg10 = (char *)(buf10);
5551  ecode11 = SWIG_AsVal_double(obj10, &val11);
5552  if (!SWIG_IsOK(ecode11)) {
5553  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5554  }
5555  arg11 = (PLFLT)(val11);
5556  ecode12 = SWIG_AsVal_int(obj11, &val12);
5557  if (!SWIG_IsOK(ecode12)) {
5558  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5559  }
5560  arg12 = (PLINT)(val12);
5561  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);
5562  resultobj = SWIG_Py_Void();
5563  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5564  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5565  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5566  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5567  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5568  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5569  return resultobj;
5570 fail:
5571  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5572  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5573  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5574  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5575  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5576  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5577  return NULL;
5578 }
5579 
5580 
5581 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5582  PyObject *resultobj = 0;
5583  PLFLT arg1 ;
5584  PLFLT arg2 ;
5585  PLFLT *arg3 = (PLFLT *) 0 ;
5586  PLFLT *arg4 = (PLFLT *) 0 ;
5587  PLINT *arg5 = (PLINT *) 0 ;
5588  double val1 ;
5589  int ecode1 = 0 ;
5590  double val2 ;
5591  int ecode2 = 0 ;
5592  PLFLT temp3 ;
5593  int res3 = SWIG_TMPOBJ ;
5594  PLFLT temp4 ;
5595  int res4 = SWIG_TMPOBJ ;
5596  PLINT temp5 ;
5597  int res5 = SWIG_TMPOBJ ;
5598  PyObject * obj0 = 0 ;
5599  PyObject * obj1 = 0 ;
5600 
5601  arg3 = &temp3;
5602  arg4 = &temp4;
5603  arg5 = &temp5;
5604  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5605  ecode1 = SWIG_AsVal_double(obj0, &val1);
5606  if (!SWIG_IsOK(ecode1)) {
5607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5608  }
5609  arg1 = (PLFLT)(val1);
5610  ecode2 = SWIG_AsVal_double(obj1, &val2);
5611  if (!SWIG_IsOK(ecode2)) {
5612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5613  }
5614  arg2 = (PLFLT)(val2);
5615  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5616  resultobj = SWIG_Py_Void();
5617  if (SWIG_IsTmpObj(res3)) {
5618  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5619  } else {
5620  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5621  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5622  }
5623  if (SWIG_IsTmpObj(res4)) {
5624  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5625  } else {
5626  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5627  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5628  }
5629  if (SWIG_IsTmpObj(res5)) {
5630  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5631  } else {
5632  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5633  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5634  }
5635  return resultobj;
5636 fail:
5637  return NULL;
5638 }
5639 
5640 
5641 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642  PyObject *resultobj = 0;
5643 
5644  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5645  plclear();
5646  resultobj = SWIG_Py_Void();
5647  return resultobj;
5648 fail:
5649  return NULL;
5650 }
5651 
5652 
5653 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5654  PyObject *resultobj = 0;
5655  PLINT arg1 ;
5656  int val1 ;
5657  int ecode1 = 0 ;
5658  PyObject * obj0 = 0 ;
5659 
5660  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5661  ecode1 = SWIG_AsVal_int(obj0, &val1);
5662  if (!SWIG_IsOK(ecode1)) {
5663  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5664  }
5665  arg1 = (PLINT)(val1);
5666  plcol0(arg1);
5667  resultobj = SWIG_Py_Void();
5668  return resultobj;
5669 fail:
5670  return NULL;
5671 }
5672 
5673 
5674 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675  PyObject *resultobj = 0;
5676  PLFLT arg1 ;
5677  double val1 ;
5678  int ecode1 = 0 ;
5679  PyObject * obj0 = 0 ;
5680 
5681  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5682  ecode1 = SWIG_AsVal_double(obj0, &val1);
5683  if (!SWIG_IsOK(ecode1)) {
5684  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5685  }
5686  arg1 = (PLFLT)(val1);
5687  plcol1(arg1);
5688  resultobj = SWIG_Py_Void();
5689  return resultobj;
5690 fail:
5691  return NULL;
5692 }
5693 
5694 
5695 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696  PyObject *resultobj = 0;
5697  PLFLT arg1 ;
5698  PLFLT arg2 ;
5699  PLFLT arg3 ;
5700  PLINT arg4 ;
5701  PLBOOL arg5 ;
5702  PLINT arg6 ;
5703  PLINT arg7 ;
5704  PLINT arg8 ;
5705  PLINT arg9 ;
5706  PLINT arg10 ;
5707  PLFLT arg11 ;
5708  double val1 ;
5709  int ecode1 = 0 ;
5710  double val2 ;
5711  int ecode2 = 0 ;
5712  double val3 ;
5713  int ecode3 = 0 ;
5714  int val4 ;
5715  int ecode4 = 0 ;
5716  int val5 ;
5717  int ecode5 = 0 ;
5718  int val6 ;
5719  int ecode6 = 0 ;
5720  int val7 ;
5721  int ecode7 = 0 ;
5722  int val8 ;
5723  int ecode8 = 0 ;
5724  int val9 ;
5725  int ecode9 = 0 ;
5726  int val10 ;
5727  int ecode10 = 0 ;
5728  double val11 ;
5729  int ecode11 = 0 ;
5730  PyObject * obj0 = 0 ;
5731  PyObject * obj1 = 0 ;
5732  PyObject * obj2 = 0 ;
5733  PyObject * obj3 = 0 ;
5734  PyObject * obj4 = 0 ;
5735  PyObject * obj5 = 0 ;
5736  PyObject * obj6 = 0 ;
5737  PyObject * obj7 = 0 ;
5738  PyObject * obj8 = 0 ;
5739  PyObject * obj9 = 0 ;
5740  PyObject * obj10 = 0 ;
5741 
5742  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5743  ecode1 = SWIG_AsVal_double(obj0, &val1);
5744  if (!SWIG_IsOK(ecode1)) {
5745  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5746  }
5747  arg1 = (PLFLT)(val1);
5748  ecode2 = SWIG_AsVal_double(obj1, &val2);
5749  if (!SWIG_IsOK(ecode2)) {
5750  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5751  }
5752  arg2 = (PLFLT)(val2);
5753  ecode3 = SWIG_AsVal_double(obj2, &val3);
5754  if (!SWIG_IsOK(ecode3)) {
5755  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5756  }
5757  arg3 = (PLFLT)(val3);
5758  ecode4 = SWIG_AsVal_int(obj3, &val4);
5759  if (!SWIG_IsOK(ecode4)) {
5760  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5761  }
5762  arg4 = (PLINT)(val4);
5763  ecode5 = SWIG_AsVal_int(obj4, &val5);
5764  if (!SWIG_IsOK(ecode5)) {
5765  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5766  }
5767  arg5 = (PLBOOL)(val5);
5768  ecode6 = SWIG_AsVal_int(obj5, &val6);
5769  if (!SWIG_IsOK(ecode6)) {
5770  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5771  }
5772  arg6 = (PLINT)(val6);
5773  ecode7 = SWIG_AsVal_int(obj6, &val7);
5774  if (!SWIG_IsOK(ecode7)) {
5775  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5776  }
5777  arg7 = (PLINT)(val7);
5778  ecode8 = SWIG_AsVal_int(obj7, &val8);
5779  if (!SWIG_IsOK(ecode8)) {
5780  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5781  }
5782  arg8 = (PLINT)(val8);
5783  ecode9 = SWIG_AsVal_int(obj8, &val9);
5784  if (!SWIG_IsOK(ecode9)) {
5785  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5786  }
5787  arg9 = (PLINT)(val9);
5788  ecode10 = SWIG_AsVal_int(obj9, &val10);
5789  if (!SWIG_IsOK(ecode10)) {
5790  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5791  }
5792  arg10 = (PLINT)(val10);
5793  ecode11 = SWIG_AsVal_double(obj10, &val11);
5794  if (!SWIG_IsOK(ecode11)) {
5795  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5796  }
5797  arg11 = (PLFLT)(val11);
5798  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5799  resultobj = SWIG_Py_Void();
5800  return resultobj;
5801 fail:
5802  return NULL;
5803 }
5804 
5805 
5806 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5807  PyObject *resultobj = 0;
5808  PLFLT **arg1 = (PLFLT **) 0 ;
5809  PLINT arg2 ;
5810  PLINT arg3 ;
5811  PLINT arg4 ;
5812  PLINT arg5 ;
5813  PLINT arg6 ;
5814  PLINT arg7 ;
5815  PLFLT *arg8 = (PLFLT *) 0 ;
5816  PLINT arg9 ;
5817  pltr_func arg10 = (pltr_func) 0 ;
5818  PLPointer arg11 = (PLPointer) 0 ;
5819  PyArrayObject *tmp1 = NULL ;
5820  int val4 ;
5821  int ecode4 = 0 ;
5822  int val5 ;
5823  int ecode5 = 0 ;
5824  int val6 ;
5825  int ecode6 = 0 ;
5826  int val7 ;
5827  int ecode7 = 0 ;
5828  PyArrayObject *tmp8 = NULL ;
5829  PyObject * obj0 = 0 ;
5830  PyObject * obj1 = 0 ;
5831  PyObject * obj2 = 0 ;
5832  PyObject * obj3 = 0 ;
5833  PyObject * obj4 = 0 ;
5834  PyObject * obj5 = 0 ;
5835  PyObject * obj6 = 0 ;
5836  PyObject * obj7 = 0 ;
5837 
5838  {
5839  python_pltr = 0;
5840  arg10 = NULL;
5841  }
5842  {
5843  arg11 = NULL;
5844  }
5845  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5846  {
5847  int i, size;
5848  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5849  if ( tmp1 == NULL )
5850  return NULL;
5851  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5852  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5853  size = arg3;
5854  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5855  for ( i = 0; i < arg2; i++ )
5856  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5857  }
5858  ecode4 = SWIG_AsVal_int(obj1, &val4);
5859  if (!SWIG_IsOK(ecode4)) {
5860  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5861  }
5862  arg4 = (PLINT)(val4);
5863  ecode5 = SWIG_AsVal_int(obj2, &val5);
5864  if (!SWIG_IsOK(ecode5)) {
5865  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5866  }
5867  arg5 = (PLINT)(val5);
5868  ecode6 = SWIG_AsVal_int(obj3, &val6);
5869  if (!SWIG_IsOK(ecode6)) {
5870  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5871  }
5872  arg6 = (PLINT)(val6);
5873  ecode7 = SWIG_AsVal_int(obj4, &val7);
5874  if (!SWIG_IsOK(ecode7)) {
5875  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5876  }
5877  arg7 = (PLINT)(val7);
5878  {
5879  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5880  if ( tmp8 == NULL )
5881  return NULL;
5882  arg9 = PyArray_DIMS( tmp8 )[0];
5883  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5884  }
5885  if (obj6) {
5886  {
5887  // it must be a callable or None
5888  if ( obj6 == Py_None )
5889  {
5890  arg10 = NULL;
5891  }
5892  else
5893  {
5894  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5895  {
5896  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5897  return NULL;
5898  }
5899  arg10 = marshal_pltr( obj6 );
5900  }
5901  }
5902  }
5903  if (obj7) {
5904  {
5905  if ( obj7 == Py_None )
5906  arg11 = NULL;
5907  else
5908  {
5909  arg11 = marshal_PLPointer( obj7, 0 );
5910  }
5911  }
5912  }
5913  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5914  resultobj = SWIG_Py_Void();
5915  {
5916  Py_CLEAR( tmp1 );
5917  free( arg1 );
5918  }
5919  {
5920  Py_CLEAR( tmp8 );
5921  }
5922  {
5923  cleanup_pltr();
5924  }
5925  {
5927  }
5928  return resultobj;
5929 fail:
5930  {
5931  Py_CLEAR( tmp1 );
5932  free( arg1 );
5933  }
5934  {
5935  Py_CLEAR( tmp8 );
5936  }
5937  {
5938  cleanup_pltr();
5939  }
5940  {
5942  }
5943  return NULL;
5944 }
5945 
5946 
5947 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5948  PyObject *resultobj = 0;
5949  PLINT arg1 ;
5950  PLINT arg2 ;
5951  PLINT arg3 ;
5952  PLINT arg4 ;
5953  PLINT arg5 ;
5954  PLFLT arg6 ;
5955  PLFLT *arg7 = (PLFLT *) 0 ;
5956  int val1 ;
5957  int ecode1 = 0 ;
5958  int val2 ;
5959  int ecode2 = 0 ;
5960  int val3 ;
5961  int ecode3 = 0 ;
5962  int val4 ;
5963  int ecode4 = 0 ;
5964  int val5 ;
5965  int ecode5 = 0 ;
5966  double val6 ;
5967  int ecode6 = 0 ;
5968  PLFLT temp7 ;
5969  int res7 = SWIG_TMPOBJ ;
5970  PyObject * obj0 = 0 ;
5971  PyObject * obj1 = 0 ;
5972  PyObject * obj2 = 0 ;
5973  PyObject * obj3 = 0 ;
5974  PyObject * obj4 = 0 ;
5975  PyObject * obj5 = 0 ;
5976 
5977  arg7 = &temp7;
5978  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5979  ecode1 = SWIG_AsVal_int(obj0, &val1);
5980  if (!SWIG_IsOK(ecode1)) {
5981  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5982  }
5983  arg1 = (PLINT)(val1);
5984  ecode2 = SWIG_AsVal_int(obj1, &val2);
5985  if (!SWIG_IsOK(ecode2)) {
5986  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5987  }
5988  arg2 = (PLINT)(val2);
5989  ecode3 = SWIG_AsVal_int(obj2, &val3);
5990  if (!SWIG_IsOK(ecode3)) {
5991  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5992  }
5993  arg3 = (PLINT)(val3);
5994  ecode4 = SWIG_AsVal_int(obj3, &val4);
5995  if (!SWIG_IsOK(ecode4)) {
5996  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5997  }
5998  arg4 = (PLINT)(val4);
5999  ecode5 = SWIG_AsVal_int(obj4, &val5);
6000  if (!SWIG_IsOK(ecode5)) {
6001  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6002  }
6003  arg5 = (PLINT)(val5);
6004  ecode6 = SWIG_AsVal_double(obj5, &val6);
6005  if (!SWIG_IsOK(ecode6)) {
6006  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6007  }
6008  arg6 = (PLFLT)(val6);
6009  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6010  resultobj = SWIG_Py_Void();
6011  if (SWIG_IsTmpObj(res7)) {
6012  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6013  } else {
6014  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6015  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6016  }
6017  return resultobj;
6018 fail:
6019  return NULL;
6020 }
6021 
6022 
6023 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6024  PyObject *resultobj = 0;
6025  PLINT arg1 ;
6026  PLBOOL arg2 ;
6027  int val1 ;
6028  int ecode1 = 0 ;
6029  int val2 ;
6030  int ecode2 = 0 ;
6031  PyObject * obj0 = 0 ;
6032  PyObject * obj1 = 0 ;
6033 
6034  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
6035  ecode1 = SWIG_AsVal_int(obj0, &val1);
6036  if (!SWIG_IsOK(ecode1)) {
6037  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6038  }
6039  arg1 = (PLINT)(val1);
6040  ecode2 = SWIG_AsVal_int(obj1, &val2);
6041  if (!SWIG_IsOK(ecode2)) {
6042  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6043  }
6044  arg2 = (PLBOOL)(val2);
6045  plcpstrm(arg1,arg2);
6046  resultobj = SWIG_Py_Void();
6047  return resultobj;
6048 fail:
6049  return NULL;
6050 }
6051 
6052 
6053 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6054  PyObject *resultobj = 0;
6055 
6056  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
6057  plend();
6058  resultobj = SWIG_Py_Void();
6059  return resultobj;
6060 fail:
6061  return NULL;
6062 }
6063 
6064 
6065 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6066  PyObject *resultobj = 0;
6067 
6068  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
6069  plend1();
6070  resultobj = SWIG_Py_Void();
6071  return resultobj;
6072 fail:
6073  return NULL;
6074 }
6075 
6076 
6077 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078  PyObject *resultobj = 0;
6079  PLFLT arg1 ;
6080  PLFLT arg2 ;
6081  PLFLT arg3 ;
6082  PLFLT arg4 ;
6083  PLINT arg5 ;
6084  PLINT arg6 ;
6085  double val1 ;
6086  int ecode1 = 0 ;
6087  double val2 ;
6088  int ecode2 = 0 ;
6089  double val3 ;
6090  int ecode3 = 0 ;
6091  double val4 ;
6092  int ecode4 = 0 ;
6093  int val5 ;
6094  int ecode5 = 0 ;
6095  int val6 ;
6096  int ecode6 = 0 ;
6097  PyObject * obj0 = 0 ;
6098  PyObject * obj1 = 0 ;
6099  PyObject * obj2 = 0 ;
6100  PyObject * obj3 = 0 ;
6101  PyObject * obj4 = 0 ;
6102  PyObject * obj5 = 0 ;
6103 
6104  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6105  ecode1 = SWIG_AsVal_double(obj0, &val1);
6106  if (!SWIG_IsOK(ecode1)) {
6107  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6108  }
6109  arg1 = (PLFLT)(val1);
6110  ecode2 = SWIG_AsVal_double(obj1, &val2);
6111  if (!SWIG_IsOK(ecode2)) {
6112  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6113  }
6114  arg2 = (PLFLT)(val2);
6115  ecode3 = SWIG_AsVal_double(obj2, &val3);
6116  if (!SWIG_IsOK(ecode3)) {
6117  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6118  }
6119  arg3 = (PLFLT)(val3);
6120  ecode4 = SWIG_AsVal_double(obj3, &val4);
6121  if (!SWIG_IsOK(ecode4)) {
6122  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6123  }
6124  arg4 = (PLFLT)(val4);
6125  ecode5 = SWIG_AsVal_int(obj4, &val5);
6126  if (!SWIG_IsOK(ecode5)) {
6127  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6128  }
6129  arg5 = (PLINT)(val5);
6130  ecode6 = SWIG_AsVal_int(obj5, &val6);
6131  if (!SWIG_IsOK(ecode6)) {
6132  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6133  }
6134  arg6 = (PLINT)(val6);
6135  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6136  resultobj = SWIG_Py_Void();
6137  return resultobj;
6138 fail:
6139  return NULL;
6140 }
6141 
6142 
6143 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6144  PyObject *resultobj = 0;
6145  PLFLT arg1 ;
6146  PLFLT arg2 ;
6147  PLFLT arg3 ;
6148  PLFLT arg4 ;
6149  PLINT arg5 ;
6150  PLINT arg6 ;
6151  double val1 ;
6152  int ecode1 = 0 ;
6153  double val2 ;
6154  int ecode2 = 0 ;
6155  double val3 ;
6156  int ecode3 = 0 ;
6157  double val4 ;
6158  int ecode4 = 0 ;
6159  int val5 ;
6160  int ecode5 = 0 ;
6161  int val6 ;
6162  int ecode6 = 0 ;
6163  PyObject * obj0 = 0 ;
6164  PyObject * obj1 = 0 ;
6165  PyObject * obj2 = 0 ;
6166  PyObject * obj3 = 0 ;
6167  PyObject * obj4 = 0 ;
6168  PyObject * obj5 = 0 ;
6169 
6170  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6171  ecode1 = SWIG_AsVal_double(obj0, &val1);
6172  if (!SWIG_IsOK(ecode1)) {
6173  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6174  }
6175  arg1 = (PLFLT)(val1);
6176  ecode2 = SWIG_AsVal_double(obj1, &val2);
6177  if (!SWIG_IsOK(ecode2)) {
6178  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6179  }
6180  arg2 = (PLFLT)(val2);
6181  ecode3 = SWIG_AsVal_double(obj2, &val3);
6182  if (!SWIG_IsOK(ecode3)) {
6183  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6184  }
6185  arg3 = (PLFLT)(val3);
6186  ecode4 = SWIG_AsVal_double(obj3, &val4);
6187  if (!SWIG_IsOK(ecode4)) {
6188  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6189  }
6190  arg4 = (PLFLT)(val4);
6191  ecode5 = SWIG_AsVal_int(obj4, &val5);
6192  if (!SWIG_IsOK(ecode5)) {
6193  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6194  }
6195  arg5 = (PLINT)(val5);
6196  ecode6 = SWIG_AsVal_int(obj5, &val6);
6197  if (!SWIG_IsOK(ecode6)) {
6198  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6199  }
6200  arg6 = (PLINT)(val6);
6201  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6202  resultobj = SWIG_Py_Void();
6203  return resultobj;
6204 fail:
6205  return NULL;
6206 }
6207 
6208 
6209 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6210  PyObject *resultobj = 0;
6211 
6212  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6213  pleop();
6214  resultobj = SWIG_Py_Void();
6215  return resultobj;
6216 fail:
6217  return NULL;
6218 }
6219 
6220 
6221 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6222  PyObject *resultobj = 0;
6223  PLINT arg1 ;
6224  PLFLT *arg2 = (PLFLT *) 0 ;
6225  PLFLT *arg3 = (PLFLT *) 0 ;
6226  PLFLT *arg4 = (PLFLT *) 0 ;
6227  PyArrayObject *tmp1 = NULL ;
6228  PyArrayObject *tmp3 = NULL ;
6229  PyArrayObject *tmp4 = NULL ;
6230  PyObject * obj0 = 0 ;
6231  PyObject * obj1 = 0 ;
6232  PyObject * obj2 = 0 ;
6233 
6234  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6235  {
6236  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6237  if ( tmp1 == NULL )
6238  return NULL;
6239  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6240  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6241  }
6242  {
6243  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6244  if ( tmp3 == NULL )
6245  return NULL;
6246  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6247  {
6248  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6249  return NULL;
6250  }
6251  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6252  }
6253  {
6254  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6255  if ( tmp4 == NULL )
6256  return NULL;
6257  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6258  {
6259  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6260  return NULL;
6261  }
6262  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6263  }
6264  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6265  resultobj = SWIG_Py_Void();
6266  {
6267  Py_CLEAR( tmp1 );
6268  }
6269  {
6270  Py_CLEAR( tmp3 );
6271  }
6272  {
6273  Py_CLEAR( tmp4 );
6274  }
6275  return resultobj;
6276 fail:
6277  {
6278  Py_CLEAR( tmp1 );
6279  }
6280  {
6281  Py_CLEAR( tmp3 );
6282  }
6283  {
6284  Py_CLEAR( tmp4 );
6285  }
6286  return NULL;
6287 }
6288 
6289 
6290 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6291  PyObject *resultobj = 0;
6292  PLINT arg1 ;
6293  PLFLT *arg2 = (PLFLT *) 0 ;
6294  PLFLT *arg3 = (PLFLT *) 0 ;
6295  PLFLT *arg4 = (PLFLT *) 0 ;
6296  PyArrayObject *tmp1 = NULL ;
6297  PyArrayObject *tmp3 = NULL ;
6298  PyArrayObject *tmp4 = NULL ;
6299  PyObject * obj0 = 0 ;
6300  PyObject * obj1 = 0 ;
6301  PyObject * obj2 = 0 ;
6302 
6303  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6304  {
6305  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6306  if ( tmp1 == NULL )
6307  return NULL;
6308  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6309  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6310  }
6311  {
6312  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6313  if ( tmp3 == NULL )
6314  return NULL;
6315  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6316  {
6317  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6318  return NULL;
6319  }
6320  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6321  }
6322  {
6323  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6324  if ( tmp4 == NULL )
6325  return NULL;
6326  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6327  {
6328  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6329  return NULL;
6330  }
6331  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6332  }
6333  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6334  resultobj = SWIG_Py_Void();
6335  {
6336  Py_CLEAR( tmp1 );
6337  }
6338  {
6339  Py_CLEAR( tmp3 );
6340  }
6341  {
6342  Py_CLEAR( tmp4 );
6343  }
6344  return resultobj;
6345 fail:
6346  {
6347  Py_CLEAR( tmp1 );
6348  }
6349  {
6350  Py_CLEAR( tmp3 );
6351  }
6352  {
6353  Py_CLEAR( tmp4 );
6354  }
6355  return NULL;
6356 }
6357 
6358 
6359 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6360  PyObject *resultobj = 0;
6361 
6362  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6363  plfamadv();
6364  resultobj = SWIG_Py_Void();
6365  return resultobj;
6366 fail:
6367  return NULL;
6368 }
6369 
6370 
6371 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372  PyObject *resultobj = 0;
6373  PLINT arg1 ;
6374  PLFLT *arg2 = (PLFLT *) 0 ;
6375  PLFLT *arg3 = (PLFLT *) 0 ;
6376  PyArrayObject *tmp1 = NULL ;
6377  PyArrayObject *tmp3 = NULL ;
6378  PyObject * obj0 = 0 ;
6379  PyObject * obj1 = 0 ;
6380 
6381  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6382  {
6383  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6384  if ( tmp1 == NULL )
6385  return NULL;
6386  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6387  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6388  }
6389  {
6390  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6391  if ( tmp3 == NULL )
6392  return NULL;
6393  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6394  {
6395  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6396  return NULL;
6397  }
6398  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6399  }
6400  plfill(arg1,(double const *)arg2,(double const *)arg3);
6401  resultobj = SWIG_Py_Void();
6402  {
6403  Py_CLEAR( tmp1 );
6404  }
6405  {
6406  Py_CLEAR( tmp3 );
6407  }
6408  return resultobj;
6409 fail:
6410  {
6411  Py_CLEAR( tmp1 );
6412  }
6413  {
6414  Py_CLEAR( tmp3 );
6415  }
6416  return NULL;
6417 }
6418 
6419 
6420 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6421  PyObject *resultobj = 0;
6422  PLINT arg1 ;
6423  PLFLT *arg2 = (PLFLT *) 0 ;
6424  PLFLT *arg3 = (PLFLT *) 0 ;
6425  PLFLT *arg4 = (PLFLT *) 0 ;
6426  PyArrayObject *tmp1 = NULL ;
6427  PyArrayObject *tmp3 = NULL ;
6428  PyArrayObject *tmp4 = NULL ;
6429  PyObject * obj0 = 0 ;
6430  PyObject * obj1 = 0 ;
6431  PyObject * obj2 = 0 ;
6432 
6433  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6434  {
6435  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6436  if ( tmp1 == NULL )
6437  return NULL;
6438  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6439  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6440  }
6441  {
6442  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6443  if ( tmp3 == NULL )
6444  return NULL;
6445  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6446  {
6447  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6448  return NULL;
6449  }
6450  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6451  }
6452  {
6453  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6454  if ( tmp4 == NULL )
6455  return NULL;
6456  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6457  {
6458  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6459  return NULL;
6460  }
6461  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6462  }
6463  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6464  resultobj = SWIG_Py_Void();
6465  {
6466  Py_CLEAR( tmp1 );
6467  }
6468  {
6469  Py_CLEAR( tmp3 );
6470  }
6471  {
6472  Py_CLEAR( tmp4 );
6473  }
6474  return resultobj;
6475 fail:
6476  {
6477  Py_CLEAR( tmp1 );
6478  }
6479  {
6480  Py_CLEAR( tmp3 );
6481  }
6482  {
6483  Py_CLEAR( tmp4 );
6484  }
6485  return NULL;
6486 }
6487 
6488 
6489 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6490  PyObject *resultobj = 0;
6491  PLINT arg1 ;
6492  PLFLT *arg2 = (PLFLT *) 0 ;
6493  PLFLT *arg3 = (PLFLT *) 0 ;
6494  PLFLT arg4 ;
6495  PyArrayObject *tmp1 = NULL ;
6496  PyArrayObject *tmp3 = NULL ;
6497  double val4 ;
6498  int ecode4 = 0 ;
6499  PyObject * obj0 = 0 ;
6500  PyObject * obj1 = 0 ;
6501  PyObject * obj2 = 0 ;
6502 
6503  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6504  {
6505  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6506  if ( tmp1 == NULL )
6507  return NULL;
6508  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6509  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6510  }
6511  {
6512  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6513  if ( tmp3 == NULL )
6514  return NULL;
6515  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6516  {
6517  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6518  return NULL;
6519  }
6520  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6521  }
6522  ecode4 = SWIG_AsVal_double(obj2, &val4);
6523  if (!SWIG_IsOK(ecode4)) {
6524  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6525  }
6526  arg4 = (PLFLT)(val4);
6527  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6528  resultobj = SWIG_Py_Void();
6529  {
6530  Py_CLEAR( tmp1 );
6531  }
6532  {
6533  Py_CLEAR( tmp3 );
6534  }
6535  return resultobj;
6536 fail:
6537  {
6538  Py_CLEAR( tmp1 );
6539  }
6540  {
6541  Py_CLEAR( tmp3 );
6542  }
6543  return NULL;
6544 }
6545 
6546 
6547 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6548  PyObject *resultobj = 0;
6549 
6550  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6551  plflush();
6552  resultobj = SWIG_Py_Void();
6553  return resultobj;
6554 fail:
6555  return NULL;
6556 }
6557 
6558 
6559 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6560  PyObject *resultobj = 0;
6561  PLINT arg1 ;
6562  int val1 ;
6563  int ecode1 = 0 ;
6564  PyObject * obj0 = 0 ;
6565 
6566  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6567  ecode1 = SWIG_AsVal_int(obj0, &val1);
6568  if (!SWIG_IsOK(ecode1)) {
6569  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6570  }
6571  arg1 = (PLINT)(val1);
6572  plfont(arg1);
6573  resultobj = SWIG_Py_Void();
6574  return resultobj;
6575 fail:
6576  return NULL;
6577 }
6578 
6579 
6580 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6581  PyObject *resultobj = 0;
6582  PLINT arg1 ;
6583  int val1 ;
6584  int ecode1 = 0 ;
6585  PyObject * obj0 = 0 ;
6586 
6587  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6588  ecode1 = SWIG_AsVal_int(obj0, &val1);
6589  if (!SWIG_IsOK(ecode1)) {
6590  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6591  }
6592  arg1 = (PLINT)(val1);
6593  plfontld(arg1);
6594  resultobj = SWIG_Py_Void();
6595  return resultobj;
6596 fail:
6597  return NULL;
6598 }
6599 
6600 
6601 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6602  PyObject *resultobj = 0;
6603  PLFLT *arg1 = (PLFLT *) 0 ;
6604  PLFLT *arg2 = (PLFLT *) 0 ;
6605  PLFLT temp1 ;
6606  int res1 = SWIG_TMPOBJ ;
6607  PLFLT temp2 ;
6608  int res2 = SWIG_TMPOBJ ;
6609 
6610  arg1 = &temp1;
6611  arg2 = &temp2;
6612  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6613  plgchr(arg1,arg2);
6614  resultobj = SWIG_Py_Void();
6615  if (SWIG_IsTmpObj(res1)) {
6616  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6617  } else {
6618  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6619  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6620  }
6621  if (SWIG_IsTmpObj(res2)) {
6622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6623  } else {
6624  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6625  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6626  }
6627  return resultobj;
6628 fail:
6629  return NULL;
6630 }
6631 
6632 
6633 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6634  PyObject *resultobj = 0;
6635  PLINT arg1 ;
6636  PLINT *arg2 = (PLINT *) 0 ;
6637  PLINT *arg3 = (PLINT *) 0 ;
6638  PLINT *arg4 = (PLINT *) 0 ;
6639  int val1 ;
6640  int ecode1 = 0 ;
6641  PLINT temp2 ;
6642  int res2 = SWIG_TMPOBJ ;
6643  PLINT temp3 ;
6644  int res3 = SWIG_TMPOBJ ;
6645  PLINT temp4 ;
6646  int res4 = SWIG_TMPOBJ ;
6647  PyObject * obj0 = 0 ;
6648 
6649  arg2 = &temp2;
6650  arg3 = &temp3;
6651  arg4 = &temp4;
6652  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6653  ecode1 = SWIG_AsVal_int(obj0, &val1);
6654  if (!SWIG_IsOK(ecode1)) {
6655  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6656  }
6657  arg1 = (PLINT)(val1);
6658  plgcol0(arg1,arg2,arg3,arg4);
6659  resultobj = SWIG_Py_Void();
6660  if (SWIG_IsTmpObj(res2)) {
6661  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6662  } else {
6663  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6664  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6665  }
6666  if (SWIG_IsTmpObj(res3)) {
6667  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6668  } else {
6669  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6670  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6671  }
6672  if (SWIG_IsTmpObj(res4)) {
6673  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6674  } else {
6675  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6676  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6677  }
6678  return resultobj;
6679 fail:
6680  return NULL;
6681 }
6682 
6683 
6684 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685  PyObject *resultobj = 0;
6686  PLINT arg1 ;
6687  PLINT *arg2 = (PLINT *) 0 ;
6688  PLINT *arg3 = (PLINT *) 0 ;
6689  PLINT *arg4 = (PLINT *) 0 ;
6690  PLFLT *arg5 = (PLFLT *) 0 ;
6691  int val1 ;
6692  int ecode1 = 0 ;
6693  PLINT temp2 ;
6694  int res2 = SWIG_TMPOBJ ;
6695  PLINT temp3 ;
6696  int res3 = SWIG_TMPOBJ ;
6697  PLINT temp4 ;
6698  int res4 = SWIG_TMPOBJ ;
6699  PLFLT temp5 ;
6700  int res5 = SWIG_TMPOBJ ;
6701  PyObject * obj0 = 0 ;
6702 
6703  arg2 = &temp2;
6704  arg3 = &temp3;
6705  arg4 = &temp4;
6706  arg5 = &temp5;
6707  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6708  ecode1 = SWIG_AsVal_int(obj0, &val1);
6709  if (!SWIG_IsOK(ecode1)) {
6710  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6711  }
6712  arg1 = (PLINT)(val1);
6713  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6714  resultobj = SWIG_Py_Void();
6715  if (SWIG_IsTmpObj(res2)) {
6716  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6717  } else {
6718  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6719  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6720  }
6721  if (SWIG_IsTmpObj(res3)) {
6722  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6723  } else {
6724  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6725  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6726  }
6727  if (SWIG_IsTmpObj(res4)) {
6728  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6729  } else {
6730  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6731  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6732  }
6733  if (SWIG_IsTmpObj(res5)) {
6734  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6735  } else {
6736  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6737  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6738  }
6739  return resultobj;
6740 fail:
6741  return NULL;
6742 }
6743 
6744 
6745 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746  PyObject *resultobj = 0;
6747  PLINT *arg1 = (PLINT *) 0 ;
6748  PLINT *arg2 = (PLINT *) 0 ;
6749  PLINT *arg3 = (PLINT *) 0 ;
6750  PLINT temp1 ;
6751  int res1 = SWIG_TMPOBJ ;
6752  PLINT temp2 ;
6753  int res2 = SWIG_TMPOBJ ;
6754  PLINT temp3 ;
6755  int res3 = SWIG_TMPOBJ ;
6756 
6757  arg1 = &temp1;
6758  arg2 = &temp2;
6759  arg3 = &temp3;
6760  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6761  plgcolbg(arg1,arg2,arg3);
6762  resultobj = SWIG_Py_Void();
6763  if (SWIG_IsTmpObj(res1)) {
6764  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6765  } else {
6766  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6767  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6768  }
6769  if (SWIG_IsTmpObj(res2)) {
6770  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6771  } else {
6772  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6773  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6774  }
6775  if (SWIG_IsTmpObj(res3)) {
6776  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6777  } else {
6778  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6779  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6780  }
6781  return resultobj;
6782 fail:
6783  return NULL;
6784 }
6785 
6786 
6787 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788  PyObject *resultobj = 0;
6789  PLINT *arg1 = (PLINT *) 0 ;
6790  PLINT *arg2 = (PLINT *) 0 ;
6791  PLINT *arg3 = (PLINT *) 0 ;
6792  PLFLT *arg4 = (PLFLT *) 0 ;
6793  PLINT temp1 ;
6794  int res1 = SWIG_TMPOBJ ;
6795  PLINT temp2 ;
6796  int res2 = SWIG_TMPOBJ ;
6797  PLINT temp3 ;
6798  int res3 = SWIG_TMPOBJ ;
6799  PLFLT temp4 ;
6800  int res4 = SWIG_TMPOBJ ;
6801 
6802  arg1 = &temp1;
6803  arg2 = &temp2;
6804  arg3 = &temp3;
6805  arg4 = &temp4;
6806  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6807  plgcolbga(arg1,arg2,arg3,arg4);
6808  resultobj = SWIG_Py_Void();
6809  if (SWIG_IsTmpObj(res1)) {
6810  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags));
6814  }
6815  if (SWIG_IsTmpObj(res2)) {
6816  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6817  } else {
6818  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6820  }
6821  if (SWIG_IsTmpObj(res3)) {
6822  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6823  } else {
6824  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6826  }
6827  if (SWIG_IsTmpObj(res4)) {
6828  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6829  } else {
6830  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6831  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6832  }
6833  return resultobj;
6834 fail:
6835  return NULL;
6836 }
6837 
6838 
6839 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6840  PyObject *resultobj = 0;
6841  PLINT *arg1 = (PLINT *) 0 ;
6842  PLINT temp1 ;
6843  int res1 = SWIG_TMPOBJ ;
6844 
6845  arg1 = &temp1;
6846  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6847  plgcompression(arg1);
6848  resultobj = SWIG_Py_Void();
6849  if (SWIG_IsTmpObj(res1)) {
6850  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6851  } else {
6852  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6854  }
6855  return resultobj;
6856 fail:
6857  return NULL;
6858 }
6859 
6860 
6861 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6862  PyObject *resultobj = 0;
6863  char *arg1 = (char *) 0 ;
6864  char buff1[1000] ;
6865 
6866  {
6867  arg1 = buff1;
6868  }
6869  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6870  plgdev(arg1);
6871  resultobj = SWIG_Py_Void();
6872  {
6873  PyObject *o = PyString_FromString( arg1 );
6874  resultobj = t_output_helper( resultobj, o );
6875  }
6876  return resultobj;
6877 fail:
6878  return NULL;
6879 }
6880 
6881 
6882 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883  PyObject *resultobj = 0;
6884  PLFLT *arg1 = (PLFLT *) 0 ;
6885  PLFLT *arg2 = (PLFLT *) 0 ;
6886  PLFLT *arg3 = (PLFLT *) 0 ;
6887  PLFLT *arg4 = (PLFLT *) 0 ;
6888  PLFLT temp1 ;
6889  int res1 = SWIG_TMPOBJ ;
6890  PLFLT temp2 ;
6891  int res2 = SWIG_TMPOBJ ;
6892  PLFLT temp3 ;
6893  int res3 = SWIG_TMPOBJ ;
6894  PLFLT temp4 ;
6895  int res4 = SWIG_TMPOBJ ;
6896 
6897  arg1 = &temp1;
6898  arg2 = &temp2;
6899  arg3 = &temp3;
6900  arg4 = &temp4;
6901  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6902  plgdidev(arg1,arg2,arg3,arg4);
6903  resultobj = SWIG_Py_Void();
6904  if (SWIG_IsTmpObj(res1)) {
6905  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6906  } else {
6907  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6908  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6909  }
6910  if (SWIG_IsTmpObj(res2)) {
6911  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6912  } else {
6913  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6914  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6915  }
6916  if (SWIG_IsTmpObj(res3)) {
6917  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6918  } else {
6919  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6920  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6921  }
6922  if (SWIG_IsTmpObj(res4)) {
6923  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6924  } else {
6925  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6926  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6927  }
6928  return resultobj;
6929 fail:
6930  return NULL;
6931 }
6932 
6933 
6934 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6935  PyObject *resultobj = 0;
6936  PLFLT *arg1 = (PLFLT *) 0 ;
6937  PLFLT temp1 ;
6938  int res1 = SWIG_TMPOBJ ;
6939 
6940  arg1 = &temp1;
6941  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6942  plgdiori(arg1);
6943  resultobj = SWIG_Py_Void();
6944  if (SWIG_IsTmpObj(res1)) {
6945  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6946  } else {
6947  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6948  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6949  }
6950  return resultobj;
6951 fail:
6952  return NULL;
6953 }
6954 
6955 
6956 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6957  PyObject *resultobj = 0;
6958  PLFLT *arg1 = (PLFLT *) 0 ;
6959  PLFLT *arg2 = (PLFLT *) 0 ;
6960  PLFLT *arg3 = (PLFLT *) 0 ;
6961  PLFLT *arg4 = (PLFLT *) 0 ;
6962  PLFLT temp1 ;
6963  int res1 = SWIG_TMPOBJ ;
6964  PLFLT temp2 ;
6965  int res2 = SWIG_TMPOBJ ;
6966  PLFLT temp3 ;
6967  int res3 = SWIG_TMPOBJ ;
6968  PLFLT temp4 ;
6969  int res4 = SWIG_TMPOBJ ;
6970 
6971  arg1 = &temp1;
6972  arg2 = &temp2;
6973  arg3 = &temp3;
6974  arg4 = &temp4;
6975  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6976  plgdiplt(arg1,arg2,arg3,arg4);
6977  resultobj = SWIG_Py_Void();
6978  if (SWIG_IsTmpObj(res1)) {
6979  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6980  } else {
6981  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6982  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6983  }
6984  if (SWIG_IsTmpObj(res2)) {
6985  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6986  } else {
6987  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6988  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6989  }
6990  if (SWIG_IsTmpObj(res3)) {
6991  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6992  } else {
6993  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6994  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6995  }
6996  if (SWIG_IsTmpObj(res4)) {
6997  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6998  } else {
6999  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7000  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7001  }
7002  return resultobj;
7003 fail:
7004  return NULL;
7005 }
7006 
7007 
7008 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009  PyObject *resultobj = 0;
7010  PLINT *arg1 = (PLINT *) 0 ;
7011  PLINT *arg2 = (PLINT *) 0 ;
7012  PLINT *arg3 = (PLINT *) 0 ;
7013  PLINT temp1 ;
7014  int res1 = SWIG_TMPOBJ ;
7015  PLINT temp2 ;
7016  int res2 = SWIG_TMPOBJ ;
7017  PLINT temp3 ;
7018  int res3 = SWIG_TMPOBJ ;
7019 
7020  arg1 = &temp1;
7021  arg2 = &temp2;
7022  arg3 = &temp3;
7023  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
7024  plgfam(arg1,arg2,arg3);
7025  resultobj = SWIG_Py_Void();
7026  if (SWIG_IsTmpObj(res1)) {
7027  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7028  } else {
7029  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7030  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7031  }
7032  if (SWIG_IsTmpObj(res2)) {
7033  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7034  } else {
7035  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7036  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7037  }
7038  if (SWIG_IsTmpObj(res3)) {
7039  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7040  } else {
7041  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7042  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7043  }
7044  return resultobj;
7045 fail:
7046  return NULL;
7047 }
7048 
7049 
7050 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051  PyObject *resultobj = 0;
7052  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7053  PLUNICODE temp1 ;
7054  int res1 = SWIG_TMPOBJ ;
7055 
7056  arg1 = &temp1;
7057  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
7058  plgfci(arg1);
7059  resultobj = SWIG_Py_Void();
7060  if (SWIG_IsTmpObj(res1)) {
7061  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7062  } else {
7063  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7064  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7065  }
7066  return resultobj;
7067 fail:
7068  return NULL;
7069 }
7070 
7071 
7072 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7073  PyObject *resultobj = 0;
7074  char *arg1 = (char *) 0 ;
7075  char buff1[1000] ;
7076 
7077  {
7078  arg1 = buff1;
7079  }
7080  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
7081  plgfnam(arg1);
7082  resultobj = SWIG_Py_Void();
7083  {
7084  PyObject *o = PyString_FromString( arg1 );
7085  resultobj = t_output_helper( resultobj, o );
7086  }
7087  return resultobj;
7088 fail:
7089  return NULL;
7090 }
7091 
7092 
7093 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7094  PyObject *resultobj = 0;
7095  PLINT *arg1 = (PLINT *) 0 ;
7096  PLINT *arg2 = (PLINT *) 0 ;
7097  PLINT *arg3 = (PLINT *) 0 ;
7098  PLINT temp1 ;
7099  int res1 = SWIG_TMPOBJ ;
7100  PLINT temp2 ;
7101  int res2 = SWIG_TMPOBJ ;
7102  PLINT temp3 ;
7103  int res3 = SWIG_TMPOBJ ;
7104 
7105  arg1 = &temp1;
7106  arg2 = &temp2;
7107  arg3 = &temp3;
7108  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
7109  plgfont(arg1,arg2,arg3);
7110  resultobj = SWIG_Py_Void();
7111  if (SWIG_IsTmpObj(res1)) {
7112  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7113  } else {
7114  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7115  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7116  }
7117  if (SWIG_IsTmpObj(res2)) {
7118  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7119  } else {
7120  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7121  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7122  }
7123  if (SWIG_IsTmpObj(res3)) {
7124  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7125  } else {
7126  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7127  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7128  }
7129  return resultobj;
7130 fail:
7131  return NULL;
7132 }
7133 
7134 
7135 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7136  PyObject *resultobj = 0;
7137  PLINT *arg1 = (PLINT *) 0 ;
7138  PLINT temp1 ;
7139  int res1 = SWIG_TMPOBJ ;
7140 
7141  arg1 = &temp1;
7142  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7143  plglevel(arg1);
7144  resultobj = SWIG_Py_Void();
7145  if (SWIG_IsTmpObj(res1)) {
7146  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7147  } else {
7148  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7149  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7150  }
7151  return resultobj;
7152 fail:
7153  return NULL;
7154 }
7155 
7156 
7157 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158  PyObject *resultobj = 0;
7159  PLFLT *arg1 = (PLFLT *) 0 ;
7160  PLFLT *arg2 = (PLFLT *) 0 ;
7161  PLINT *arg3 = (PLINT *) 0 ;
7162  PLINT *arg4 = (PLINT *) 0 ;
7163  PLINT *arg5 = (PLINT *) 0 ;
7164  PLINT *arg6 = (PLINT *) 0 ;
7165  PLFLT temp1 ;
7166  int res1 = SWIG_TMPOBJ ;
7167  PLFLT temp2 ;
7168  int res2 = SWIG_TMPOBJ ;
7169  PLINT temp3 ;
7170  int res3 = SWIG_TMPOBJ ;
7171  PLINT temp4 ;
7172  int res4 = SWIG_TMPOBJ ;
7173  PLINT temp5 ;
7174  int res5 = SWIG_TMPOBJ ;
7175  PLINT temp6 ;
7176  int res6 = SWIG_TMPOBJ ;
7177 
7178  arg1 = &temp1;
7179  arg2 = &temp2;
7180  arg3 = &temp3;
7181  arg4 = &temp4;
7182  arg5 = &temp5;
7183  arg6 = &temp6;
7184  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7185  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7186  resultobj = SWIG_Py_Void();
7187  if (SWIG_IsTmpObj(res1)) {
7188  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7189  } else {
7190  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7191  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7192  }
7193  if (SWIG_IsTmpObj(res2)) {
7194  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7195  } else {
7196  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7197  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7198  }
7199  if (SWIG_IsTmpObj(res3)) {
7200  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7201  } else {
7202  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7203  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7204  }
7205  if (SWIG_IsTmpObj(res4)) {
7206  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7207  } else {
7208  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7209  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7210  }
7211  if (SWIG_IsTmpObj(res5)) {
7212  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7213  } else {
7214  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7215  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7216  }
7217  if (SWIG_IsTmpObj(res6)) {
7218  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7219  } else {
7220  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7221  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7222  }
7223  return resultobj;
7224 fail:
7225  return NULL;
7226 }
7227 
7228 
7229 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7230  PyObject *resultobj = 0;
7231 
7232  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7233  plgra();
7234  resultobj = SWIG_Py_Void();
7235  return resultobj;
7236 fail:
7237  return NULL;
7238 }
7239 
7240 
7241 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7242  PyObject *resultobj = 0;
7243  PLFLT *arg1 = (PLFLT *) 0 ;
7244  PLFLT *arg2 = (PLFLT *) 0 ;
7245  PLFLT *arg3 = (PLFLT *) 0 ;
7246  PLINT arg4 ;
7247  PLFLT *arg5 = (PLFLT *) 0 ;
7248  PLINT arg6 ;
7249  PLFLT *arg7 = (PLFLT *) 0 ;
7250  PLINT arg8 ;
7251  PLFLT **arg9 = (PLFLT **) 0 ;
7252  PLINT arg10 ;
7253  PLFLT arg11 ;
7254  PyArrayObject *tmp1 = NULL ;
7255  PyArrayObject *tmp2 = NULL ;
7256  PyArrayObject *tmp3 = NULL ;
7257  PyArrayObject *tmp5 = NULL ;
7258  PyArrayObject *tmp7 = NULL ;
7259  PyObject *array7 = NULL ;
7260  int val10 ;
7261  int ecode10 = 0 ;
7262  double val11 ;
7263  int ecode11 = 0 ;
7264  PyObject * obj0 = 0 ;
7265  PyObject * obj1 = 0 ;
7266  PyObject * obj2 = 0 ;
7267  PyObject * obj3 = 0 ;
7268  PyObject * obj4 = 0 ;
7269  PyObject * obj5 = 0 ;
7270  PyObject * obj6 = 0 ;
7271 
7272  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7273  {
7274  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7275  if ( tmp1 == NULL )
7276  return NULL;
7277  Alen = PyArray_DIMS( tmp1 )[0];
7278  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7279  }
7280  {
7281  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7282  if ( tmp2 == NULL )
7283  return NULL;
7284  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7285  {
7286  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7287  return NULL;
7288  }
7289  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7290  }
7291  {
7292  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7293  if ( tmp3 == NULL )
7294  return NULL;
7295  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7296  {
7297  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7298  return NULL;
7299  }
7300  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7301  arg4 = PyArray_DIMS( tmp3 )[0];
7302  }
7303  {
7304  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7305  if ( tmp5 == NULL )
7306  return NULL;
7307  Xlen = PyArray_DIMS( tmp5 )[0];
7308  arg6 = Xlen;
7309  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7310  }
7311  {
7312  int i, size;
7313  npy_intp dims[2];
7314  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7315  if ( tmp7 == NULL )
7316  return NULL;
7317  Ylen = PyArray_DIMS( tmp7 )[0];
7318  arg8 = Ylen;
7319  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7320  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7321  // list and this ArrayY.
7322  dims[0] = Xlen;
7323  dims[1] = Ylen;
7324  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7325  if ( !array7 )
7326  return NULL;
7327  size = Ylen;
7328  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7329  for ( i = 0; i < Xlen; i++ )
7330  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7331  }
7332  ecode10 = SWIG_AsVal_int(obj5, &val10);
7333  if (!SWIG_IsOK(ecode10)) {
7334  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7335  }
7336  arg10 = (PLINT)(val10);
7337  ecode11 = SWIG_AsVal_double(obj6, &val11);
7338  if (!SWIG_IsOK(ecode11)) {
7339  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7340  }
7341  arg11 = (PLFLT)(val11);
7342  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7343  resultobj = SWIG_Py_Void();
7344  {
7345  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7346  }
7347  {
7348  Py_CLEAR( tmp1 );
7349  }
7350  {
7351  Py_CLEAR( tmp2 );
7352  }
7353  {
7354  Py_CLEAR( tmp3 );
7355  }
7356  {
7357  Py_CLEAR( tmp5 );
7358  }
7359  {
7360  Py_CLEAR( tmp7 );
7361  free( arg9 );
7362  }
7363  return resultobj;
7364 fail:
7365  {
7366  Py_CLEAR( tmp1 );
7367  }
7368  {
7369  Py_CLEAR( tmp2 );
7370  }
7371  {
7372  Py_CLEAR( tmp3 );
7373  }
7374  {
7375  Py_CLEAR( tmp5 );
7376  }
7377  {
7378  Py_CLEAR( tmp7 );
7379  free( arg9 );
7380  }
7381  return NULL;
7382 }
7383 
7384 
7385 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7386  PyObject *resultobj = 0;
7387  PLFLT *arg1 = (PLFLT *) 0 ;
7388  PLFLT *arg2 = (PLFLT *) 0 ;
7389  PLFLT *arg3 = (PLFLT *) 0 ;
7390  PLFLT *arg4 = (PLFLT *) 0 ;
7391  PLFLT temp1 ;
7392  int res1 = SWIG_TMPOBJ ;
7393  PLFLT temp2 ;
7394  int res2 = SWIG_TMPOBJ ;
7395  PLFLT temp3 ;
7396  int res3 = SWIG_TMPOBJ ;
7397  PLFLT temp4 ;
7398  int res4 = SWIG_TMPOBJ ;
7399 
7400  arg1 = &temp1;
7401  arg2 = &temp2;
7402  arg3 = &temp3;
7403  arg4 = &temp4;
7404  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7405  plgspa(arg1,arg2,arg3,arg4);
7406  resultobj = SWIG_Py_Void();
7407  if (SWIG_IsTmpObj(res1)) {
7408  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7409  } else {
7410  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7411  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7412  }
7413  if (SWIG_IsTmpObj(res2)) {
7414  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7415  } else {
7416  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7417  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7418  }
7419  if (SWIG_IsTmpObj(res3)) {
7420  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7421  } else {
7422  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7423  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7424  }
7425  if (SWIG_IsTmpObj(res4)) {
7426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7427  } else {
7428  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7430  }
7431  return resultobj;
7432 fail:
7433  return NULL;
7434 }
7435 
7436 
7437 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7438  PyObject *resultobj = 0;
7439  PLINT *arg1 = (PLINT *) 0 ;
7440  PLINT temp1 ;
7441  int res1 = SWIG_TMPOBJ ;
7442 
7443  arg1 = &temp1;
7444  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7445  plgstrm(arg1);
7446  resultobj = SWIG_Py_Void();
7447  if (SWIG_IsTmpObj(res1)) {
7448  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7449  } else {
7450  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7451  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7452  }
7453  return resultobj;
7454 fail:
7455  return NULL;
7456 }
7457 
7458 
7459 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7460  PyObject *resultobj = 0;
7461  char *arg1 = (char *) 0 ;
7462  char buff1[1000] ;
7463 
7464  {
7465  arg1 = buff1;
7466  }
7467  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7468  plgver(arg1);
7469  resultobj = SWIG_Py_Void();
7470  {
7471  PyObject *o = PyString_FromString( arg1 );
7472  resultobj = t_output_helper( resultobj, o );
7473  }
7474  return resultobj;
7475 fail:
7476  return NULL;
7477 }
7478 
7479 
7480 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7481  PyObject *resultobj = 0;
7482  PLFLT *arg1 = (PLFLT *) 0 ;
7483  PLFLT *arg2 = (PLFLT *) 0 ;
7484  PLFLT *arg3 = (PLFLT *) 0 ;
7485  PLFLT *arg4 = (PLFLT *) 0 ;
7486  PLFLT temp1 ;
7487  int res1 = SWIG_TMPOBJ ;
7488  PLFLT temp2 ;
7489  int res2 = SWIG_TMPOBJ ;
7490  PLFLT temp3 ;
7491  int res3 = SWIG_TMPOBJ ;
7492  PLFLT temp4 ;
7493  int res4 = SWIG_TMPOBJ ;
7494 
7495  arg1 = &temp1;
7496  arg2 = &temp2;
7497  arg3 = &temp3;
7498  arg4 = &temp4;
7499  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7500  plgvpd(arg1,arg2,arg3,arg4);
7501  resultobj = SWIG_Py_Void();
7502  if (SWIG_IsTmpObj(res1)) {
7503  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7504  } else {
7505  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7506  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7507  }
7508  if (SWIG_IsTmpObj(res2)) {
7509  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7510  } else {
7511  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7512  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7513  }
7514  if (SWIG_IsTmpObj(res3)) {
7515  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7516  } else {
7517  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7518  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7519  }
7520  if (SWIG_IsTmpObj(res4)) {
7521  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7522  } else {
7523  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7524  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7525  }
7526  return resultobj;
7527 fail:
7528  return NULL;
7529 }
7530 
7531 
7532 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533  PyObject *resultobj = 0;
7534  PLFLT *arg1 = (PLFLT *) 0 ;
7535  PLFLT *arg2 = (PLFLT *) 0 ;
7536  PLFLT *arg3 = (PLFLT *) 0 ;
7537  PLFLT *arg4 = (PLFLT *) 0 ;
7538  PLFLT temp1 ;
7539  int res1 = SWIG_TMPOBJ ;
7540  PLFLT temp2 ;
7541  int res2 = SWIG_TMPOBJ ;
7542  PLFLT temp3 ;
7543  int res3 = SWIG_TMPOBJ ;
7544  PLFLT temp4 ;
7545  int res4 = SWIG_TMPOBJ ;
7546 
7547  arg1 = &temp1;
7548  arg2 = &temp2;
7549  arg3 = &temp3;
7550  arg4 = &temp4;
7551  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7552  plgvpw(arg1,arg2,arg3,arg4);
7553  resultobj = SWIG_Py_Void();
7554  if (SWIG_IsTmpObj(res1)) {
7555  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7556  } else {
7557  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7558  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7559  }
7560  if (SWIG_IsTmpObj(res2)) {
7561  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7562  } else {
7563  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7564  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7565  }
7566  if (SWIG_IsTmpObj(res3)) {
7567  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7568  } else {
7569  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7570  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7571  }
7572  if (SWIG_IsTmpObj(res4)) {
7573  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7574  } else {
7575  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7576  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7577  }
7578  return resultobj;
7579 fail:
7580  return NULL;
7581 }
7582 
7583 
7584 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7585  PyObject *resultobj = 0;
7586  PLINT *arg1 = (PLINT *) 0 ;
7587  PLINT *arg2 = (PLINT *) 0 ;
7588  PLINT temp1 ;
7589  int res1 = SWIG_TMPOBJ ;
7590  PLINT temp2 ;
7591  int res2 = SWIG_TMPOBJ ;
7592 
7593  arg1 = &temp1;
7594  arg2 = &temp2;
7595  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7596  plgxax(arg1,arg2);
7597  resultobj = SWIG_Py_Void();
7598  if (SWIG_IsTmpObj(res1)) {
7599  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7600  } else {
7601  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7602  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7603  }
7604  if (SWIG_IsTmpObj(res2)) {
7605  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7606  } else {
7607  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7608  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7609  }
7610  return resultobj;
7611 fail:
7612  return NULL;
7613 }
7614 
7615 
7616 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7617  PyObject *resultobj = 0;
7618  PLINT *arg1 = (PLINT *) 0 ;
7619  PLINT *arg2 = (PLINT *) 0 ;
7620  PLINT temp1 ;
7621  int res1 = SWIG_TMPOBJ ;
7622  PLINT temp2 ;
7623  int res2 = SWIG_TMPOBJ ;
7624 
7625  arg1 = &temp1;
7626  arg2 = &temp2;
7627  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7628  plgyax(arg1,arg2);
7629  resultobj = SWIG_Py_Void();
7630  if (SWIG_IsTmpObj(res1)) {
7631  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7632  } else {
7633  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7634  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7635  }
7636  if (SWIG_IsTmpObj(res2)) {
7637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7638  } else {
7639  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7640  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7641  }
7642  return resultobj;
7643 fail:
7644  return NULL;
7645 }
7646 
7647 
7648 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7649  PyObject *resultobj = 0;
7650  PLINT *arg1 = (PLINT *) 0 ;
7651  PLINT *arg2 = (PLINT *) 0 ;
7652  PLINT temp1 ;
7653  int res1 = SWIG_TMPOBJ ;
7654  PLINT temp2 ;
7655  int res2 = SWIG_TMPOBJ ;
7656 
7657  arg1 = &temp1;
7658  arg2 = &temp2;
7659  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7660  plgzax(arg1,arg2);
7661  resultobj = SWIG_Py_Void();
7662  if (SWIG_IsTmpObj(res1)) {
7663  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7664  } else {
7665  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7666  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7667  }
7668  if (SWIG_IsTmpObj(res2)) {
7669  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7670  } else {
7671  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7672  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7673  }
7674  return resultobj;
7675 fail:
7676  return NULL;
7677 }
7678 
7679 
7680 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681  PyObject *resultobj = 0;
7682  PLINT arg1 ;
7683  PLFLT *arg2 = (PLFLT *) 0 ;
7684  PLFLT arg3 ;
7685  PLFLT arg4 ;
7686  PLINT arg5 ;
7687  PLINT arg6 ;
7688  PyArrayObject *tmp1 = NULL ;
7689  double val3 ;
7690  int ecode3 = 0 ;
7691  double val4 ;
7692  int ecode4 = 0 ;
7693  int val5 ;
7694  int ecode5 = 0 ;
7695  int val6 ;
7696  int ecode6 = 0 ;
7697  PyObject * obj0 = 0 ;
7698  PyObject * obj1 = 0 ;
7699  PyObject * obj2 = 0 ;
7700  PyObject * obj3 = 0 ;
7701  PyObject * obj4 = 0 ;
7702 
7703  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7704  {
7705  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7706  if ( tmp1 == NULL )
7707  return NULL;
7708  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7709  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7710  }
7711  ecode3 = SWIG_AsVal_double(obj1, &val3);
7712  if (!SWIG_IsOK(ecode3)) {
7713  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7714  }
7715  arg3 = (PLFLT)(val3);
7716  ecode4 = SWIG_AsVal_double(obj2, &val4);
7717  if (!SWIG_IsOK(ecode4)) {
7718  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7719  }
7720  arg4 = (PLFLT)(val4);
7721  ecode5 = SWIG_AsVal_int(obj3, &val5);
7722  if (!SWIG_IsOK(ecode5)) {
7723  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7724  }
7725  arg5 = (PLINT)(val5);
7726  ecode6 = SWIG_AsVal_int(obj4, &val6);
7727  if (!SWIG_IsOK(ecode6)) {
7728  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7729  }
7730  arg6 = (PLINT)(val6);
7731  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7732  resultobj = SWIG_Py_Void();
7733  {
7734  Py_CLEAR( tmp1 );
7735  }
7736  return resultobj;
7737 fail:
7738  {
7739  Py_CLEAR( tmp1 );
7740  }
7741  return NULL;
7742 }
7743 
7744 
7745 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7746  PyObject *resultobj = 0;
7747  PLFLT arg1 ;
7748  PLFLT arg2 ;
7749  PLFLT arg3 ;
7750  PLFLT *arg4 = (PLFLT *) 0 ;
7751  PLFLT *arg5 = (PLFLT *) 0 ;
7752  PLFLT *arg6 = (PLFLT *) 0 ;
7753  double val1 ;
7754  int ecode1 = 0 ;
7755  double val2 ;
7756  int ecode2 = 0 ;
7757  double val3 ;
7758  int ecode3 = 0 ;
7759  PLFLT temp4 ;
7760  int res4 = SWIG_TMPOBJ ;
7761  PLFLT temp5 ;
7762  int res5 = SWIG_TMPOBJ ;
7763  PLFLT temp6 ;
7764  int res6 = SWIG_TMPOBJ ;
7765  PyObject * obj0 = 0 ;
7766  PyObject * obj1 = 0 ;
7767  PyObject * obj2 = 0 ;
7768 
7769  arg4 = &temp4;
7770  arg5 = &temp5;
7771  arg6 = &temp6;
7772  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7773  ecode1 = SWIG_AsVal_double(obj0, &val1);
7774  if (!SWIG_IsOK(ecode1)) {
7775  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7776  }
7777  arg1 = (PLFLT)(val1);
7778  ecode2 = SWIG_AsVal_double(obj1, &val2);
7779  if (!SWIG_IsOK(ecode2)) {
7780  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7781  }
7782  arg2 = (PLFLT)(val2);
7783  ecode3 = SWIG_AsVal_double(obj2, &val3);
7784  if (!SWIG_IsOK(ecode3)) {
7785  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7786  }
7787  arg3 = (PLFLT)(val3);
7788  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7789  resultobj = SWIG_Py_Void();
7790  if (SWIG_IsTmpObj(res4)) {
7791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7792  } else {
7793  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7794  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7795  }
7796  if (SWIG_IsTmpObj(res5)) {
7797  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7798  } else {
7799  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7800  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7801  }
7802  if (SWIG_IsTmpObj(res6)) {
7803  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7804  } else {
7805  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7806  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7807  }
7808  return resultobj;
7809 fail:
7810  return NULL;
7811 }
7812 
7813 
7814 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815  PyObject *resultobj = 0;
7816 
7817  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7818  plinit();
7819  resultobj = SWIG_Py_Void();
7820  return resultobj;
7821 fail:
7822  return NULL;
7823 }
7824 
7825 
7826 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7827  PyObject *resultobj = 0;
7828  PLFLT arg1 ;
7829  PLFLT arg2 ;
7830  PLFLT arg3 ;
7831  PLFLT arg4 ;
7832  double val1 ;
7833  int ecode1 = 0 ;
7834  double val2 ;
7835  int ecode2 = 0 ;
7836  double val3 ;
7837  int ecode3 = 0 ;
7838  double val4 ;
7839  int ecode4 = 0 ;
7840  PyObject * obj0 = 0 ;
7841  PyObject * obj1 = 0 ;
7842  PyObject * obj2 = 0 ;
7843  PyObject * obj3 = 0 ;
7844 
7845  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7846  ecode1 = SWIG_AsVal_double(obj0, &val1);
7847  if (!SWIG_IsOK(ecode1)) {
7848  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7849  }
7850  arg1 = (PLFLT)(val1);
7851  ecode2 = SWIG_AsVal_double(obj1, &val2);
7852  if (!SWIG_IsOK(ecode2)) {
7853  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7854  }
7855  arg2 = (PLFLT)(val2);
7856  ecode3 = SWIG_AsVal_double(obj2, &val3);
7857  if (!SWIG_IsOK(ecode3)) {
7858  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7859  }
7860  arg3 = (PLFLT)(val3);
7861  ecode4 = SWIG_AsVal_double(obj3, &val4);
7862  if (!SWIG_IsOK(ecode4)) {
7863  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7864  }
7865  arg4 = (PLFLT)(val4);
7866  pljoin(arg1,arg2,arg3,arg4);
7867  resultobj = SWIG_Py_Void();
7868  return resultobj;
7869 fail:
7870  return NULL;
7871 }
7872 
7873 
7874 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7875  PyObject *resultobj = 0;
7876  char *arg1 = (char *) 0 ;
7877  char *arg2 = (char *) 0 ;
7878  char *arg3 = (char *) 0 ;
7879  int res1 ;
7880  char *buf1 = 0 ;
7881  int alloc1 = 0 ;
7882  int res2 ;
7883  char *buf2 = 0 ;
7884  int alloc2 = 0 ;
7885  int res3 ;
7886  char *buf3 = 0 ;
7887  int alloc3 = 0 ;
7888  PyObject * obj0 = 0 ;
7889  PyObject * obj1 = 0 ;
7890  PyObject * obj2 = 0 ;
7891 
7892  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7893  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7894  if (!SWIG_IsOK(res1)) {
7895  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7896  }
7897  arg1 = (char *)(buf1);
7898  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7899  if (!SWIG_IsOK(res2)) {
7900  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7901  }
7902  arg2 = (char *)(buf2);
7903  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7904  if (!SWIG_IsOK(res3)) {
7905  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7906  }
7907  arg3 = (char *)(buf3);
7908  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7909  resultobj = SWIG_Py_Void();
7910  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7911  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7912  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7913  return resultobj;
7914 fail:
7915  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7916  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7917  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7918  return NULL;
7919 }
7920 
7921 
7922 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923  PyObject *resultobj = 0;
7924  PLFLT *arg1 = (PLFLT *) 0 ;
7925  PLFLT *arg2 = (PLFLT *) 0 ;
7926  PLINT arg3 ;
7927  PLINT arg4 ;
7928  PLFLT arg5 ;
7929  PLFLT arg6 ;
7930  PLFLT arg7 ;
7931  PLINT arg8 ;
7932  PLINT arg9 ;
7933  PLINT arg10 ;
7934  PLINT arg11 ;
7935  PLINT arg12 ;
7936  PLINT arg13 ;
7937  PLINT *arg14 = (PLINT *) 0 ;
7938  PLFLT arg15 ;
7939  PLFLT arg16 ;
7940  PLFLT arg17 ;
7941  PLFLT arg18 ;
7942  PLINT *arg19 = (PLINT *) 0 ;
7943  char **arg20 = (char **) 0 ;
7944  PLINT *arg21 = (PLINT *) 0 ;
7945  PLINT *arg22 = (PLINT *) 0 ;
7946  PLFLT *arg23 = (PLFLT *) 0 ;
7947  PLFLT *arg24 = (PLFLT *) 0 ;
7948  PLINT *arg25 = (PLINT *) 0 ;
7949  PLINT *arg26 = (PLINT *) 0 ;
7950  PLFLT *arg27 = (PLFLT *) 0 ;
7951  PLINT *arg28 = (PLINT *) 0 ;
7952  PLFLT *arg29 = (PLFLT *) 0 ;
7953  PLINT *arg30 = (PLINT *) 0 ;
7954  char **arg31 = (char **) 0 ;
7955  PLFLT temp1 ;
7956  int res1 = SWIG_TMPOBJ ;
7957  PLFLT temp2 ;
7958  int res2 = SWIG_TMPOBJ ;
7959  int val3 ;
7960  int ecode3 = 0 ;
7961  int val4 ;
7962  int ecode4 = 0 ;
7963  double val5 ;
7964  int ecode5 = 0 ;
7965  double val6 ;
7966  int ecode6 = 0 ;
7967  double val7 ;
7968  int ecode7 = 0 ;
7969  int val8 ;
7970  int ecode8 = 0 ;
7971  int val9 ;
7972  int ecode9 = 0 ;
7973  int val10 ;
7974  int ecode10 = 0 ;
7975  int val11 ;
7976  int ecode11 = 0 ;
7977  int val12 ;
7978  int ecode12 = 0 ;
7979  PyArrayObject *tmp13 = NULL ;
7980  double val15 ;
7981  int ecode15 = 0 ;
7982  double val16 ;
7983  int ecode16 = 0 ;
7984  double val17 ;
7985  int ecode17 = 0 ;
7986  double val18 ;
7987  int ecode18 = 0 ;
7988  PyArrayObject *tmp19 = NULL ;
7989  PyArrayObject *tmp20 = NULL ;
7990  PyArrayObject *tmp21 = NULL ;
7991  PyArrayObject *tmp22 = NULL ;
7992  PyArrayObject *tmp23 = NULL ;
7993  PyArrayObject *tmp24 = NULL ;
7994  PyArrayObject *tmp25 = NULL ;
7995  PyArrayObject *tmp26 = NULL ;
7996  PyArrayObject *tmp27 = NULL ;
7997  PyArrayObject *tmp28 = NULL ;
7998  PyArrayObject *tmp29 = NULL ;
7999  PyArrayObject *tmp30 = NULL ;
8000  PyArrayObject *tmp31 = NULL ;
8001  PyObject * obj0 = 0 ;
8002  PyObject * obj1 = 0 ;
8003  PyObject * obj2 = 0 ;
8004  PyObject * obj3 = 0 ;
8005  PyObject * obj4 = 0 ;
8006  PyObject * obj5 = 0 ;
8007  PyObject * obj6 = 0 ;
8008  PyObject * obj7 = 0 ;
8009  PyObject * obj8 = 0 ;
8010  PyObject * obj9 = 0 ;
8011  PyObject * obj10 = 0 ;
8012  PyObject * obj11 = 0 ;
8013  PyObject * obj12 = 0 ;
8014  PyObject * obj13 = 0 ;
8015  PyObject * obj14 = 0 ;
8016  PyObject * obj15 = 0 ;
8017  PyObject * obj16 = 0 ;
8018  PyObject * obj17 = 0 ;
8019  PyObject * obj18 = 0 ;
8020  PyObject * obj19 = 0 ;
8021  PyObject * obj20 = 0 ;
8022  PyObject * obj21 = 0 ;
8023  PyObject * obj22 = 0 ;
8024  PyObject * obj23 = 0 ;
8025  PyObject * obj24 = 0 ;
8026  PyObject * obj25 = 0 ;
8027  PyObject * obj26 = 0 ;
8028  PyObject * obj27 = 0 ;
8029 
8030  arg1 = &temp1;
8031  arg2 = &temp2;
8032  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;
8033  ecode3 = SWIG_AsVal_int(obj0, &val3);
8034  if (!SWIG_IsOK(ecode3)) {
8035  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8036  }
8037  arg3 = (PLINT)(val3);
8038  ecode4 = SWIG_AsVal_int(obj1, &val4);
8039  if (!SWIG_IsOK(ecode4)) {
8040  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8041  }
8042  arg4 = (PLINT)(val4);
8043  ecode5 = SWIG_AsVal_double(obj2, &val5);
8044  if (!SWIG_IsOK(ecode5)) {
8045  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8046  }
8047  arg5 = (PLFLT)(val5);
8048  ecode6 = SWIG_AsVal_double(obj3, &val6);
8049  if (!SWIG_IsOK(ecode6)) {
8050  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8051  }
8052  arg6 = (PLFLT)(val6);
8053  ecode7 = SWIG_AsVal_double(obj4, &val7);
8054  if (!SWIG_IsOK(ecode7)) {
8055  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8056  }
8057  arg7 = (PLFLT)(val7);
8058  ecode8 = SWIG_AsVal_int(obj5, &val8);
8059  if (!SWIG_IsOK(ecode8)) {
8060  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8061  }
8062  arg8 = (PLINT)(val8);
8063  ecode9 = SWIG_AsVal_int(obj6, &val9);
8064  if (!SWIG_IsOK(ecode9)) {
8065  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8066  }
8067  arg9 = (PLINT)(val9);
8068  ecode10 = SWIG_AsVal_int(obj7, &val10);
8069  if (!SWIG_IsOK(ecode10)) {
8070  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8071  }
8072  arg10 = (PLINT)(val10);
8073  ecode11 = SWIG_AsVal_int(obj8, &val11);
8074  if (!SWIG_IsOK(ecode11)) {
8075  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8076  }
8077  arg11 = (PLINT)(val11);
8078  ecode12 = SWIG_AsVal_int(obj9, &val12);
8079  if (!SWIG_IsOK(ecode12)) {
8080  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8081  }
8082  arg12 = (PLINT)(val12);
8083  {
8084  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
8085  if ( tmp13 == NULL )
8086  return NULL;
8087  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8088  arg14 = (PLINT *) PyArray_DATA( tmp13 );
8089  }
8090  ecode15 = SWIG_AsVal_double(obj11, &val15);
8091  if (!SWIG_IsOK(ecode15)) {
8092  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8093  }
8094  arg15 = (PLFLT)(val15);
8095  ecode16 = SWIG_AsVal_double(obj12, &val16);
8096  if (!SWIG_IsOK(ecode16)) {
8097  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8098  }
8099  arg16 = (PLFLT)(val16);
8100  ecode17 = SWIG_AsVal_double(obj13, &val17);
8101  if (!SWIG_IsOK(ecode17)) {
8102  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8103  }
8104  arg17 = (PLFLT)(val17);
8105  ecode18 = SWIG_AsVal_double(obj14, &val18);
8106  if (!SWIG_IsOK(ecode18)) {
8107  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8108  }
8109  arg18 = (PLFLT)(val18);
8110  {
8111  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
8112  if ( tmp19 == NULL )
8113  return NULL;
8114  if ( PyArray_DIMS( tmp19 )[0] != Alen )
8115  {
8116  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8117  return NULL;
8118  }
8119  arg19 = (PLINT *) PyArray_DATA( tmp19 );
8120  }
8121  {
8122  int i;
8123  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
8124  if ( tmp20 == NULL )
8125  return NULL;
8126  if ( PyArray_DIMS( tmp20 )[0] != Alen )
8127  {
8128  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8129  return NULL;
8130  }
8131  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8132  for ( i = 0; i < Alen; i++ )
8133  {
8134  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8135  if ( arg20[i] == NULL )
8136  {
8137  free( arg20 );
8138  return NULL;
8139  }
8140  }
8141  }
8142  {
8143  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8144  if ( tmp21 == NULL )
8145  return NULL;
8146  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8147  {
8148  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8149  return NULL;
8150  }
8151  arg21 = (PLINT *) PyArray_DATA( tmp21 );
8152  }
8153  {
8154  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8155  if ( tmp22 == NULL )
8156  return NULL;
8157  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8158  {
8159  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8160  return NULL;
8161  }
8162  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8163  }
8164  {
8165  if ( obj19 != Py_None )
8166  {
8167  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8168  if ( tmp23 == NULL )
8169  return NULL;
8170  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8171  {
8172  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8173  return NULL;
8174  }
8175  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8176  }
8177  else
8178  {
8179  arg23 = NULL;
8180  }
8181  }
8182  {
8183  if ( obj20 != Py_None )
8184  {
8185  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8186  if ( tmp24 == NULL )
8187  return NULL;
8188  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8189  {
8190  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8191  return NULL;
8192  }
8193  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8194  }
8195  else
8196  {
8197  arg24 = NULL;
8198  }
8199  }
8200  {
8201  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8202  if ( tmp25 == NULL )
8203  return NULL;
8204  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8205  {
8206  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8207  return NULL;
8208  }
8209  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8210  }
8211  {
8212  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8213  if ( tmp26 == NULL )
8214  return NULL;
8215  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8216  {
8217  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8218  return NULL;
8219  }
8220  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8221  }
8222  {
8223  if ( obj23 != Py_None )
8224  {
8225  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8226  if ( tmp27 == NULL )
8227  return NULL;
8228  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8229  {
8230  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8231  return NULL;
8232  }
8233  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8234  }
8235  else
8236  {
8237  arg27 = NULL;
8238  }
8239  }
8240  {
8241  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8242  if ( tmp28 == NULL )
8243  return NULL;
8244  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8245  {
8246  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8247  return NULL;
8248  }
8249  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8250  }
8251  {
8252  if ( obj25 != Py_None )
8253  {
8254  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8255  if ( tmp29 == NULL )
8256  return NULL;
8257  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8258  {
8259  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8260  return NULL;
8261  }
8262  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8263  }
8264  else
8265  {
8266  arg29 = NULL;
8267  }
8268  }
8269  {
8270  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8271  if ( tmp30 == NULL )
8272  return NULL;
8273  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8274  {
8275  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8276  return NULL;
8277  }
8278  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8279  }
8280  {
8281  int i;
8282  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8283  if ( tmp31 == NULL )
8284  return NULL;
8285  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8286  {
8287  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8288  return NULL;
8289  }
8290  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8291  for ( i = 0; i < Alen; i++ )
8292  {
8293  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8294  if ( arg31[i] == NULL )
8295  {
8296  free( arg31 );
8297  return NULL;
8298  }
8299  }
8300  }
8301  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);
8302  resultobj = SWIG_Py_Void();
8303  if (SWIG_IsTmpObj(res1)) {
8304  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8305  } else {
8306  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8307  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8308  }
8309  if (SWIG_IsTmpObj(res2)) {
8310  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8311  } else {
8312  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8313  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8314  }
8315  {
8316  Py_CLEAR( tmp13 );
8317  }
8318  {
8319  Py_CLEAR( tmp19 );
8320  }
8321  {
8322  Py_CLEAR( tmp20 ); free( arg20 );
8323  }
8324  {
8325  Py_CLEAR( tmp21 );
8326  }
8327  {
8328  Py_CLEAR( tmp22 );
8329  }
8330  {
8331  Py_CLEAR( tmp23 );
8332  }
8333  {
8334  Py_CLEAR( tmp24 );
8335  }
8336  {
8337  Py_CLEAR( tmp25 );
8338  }
8339  {
8340  Py_CLEAR( tmp26 );
8341  }
8342  {
8343  Py_CLEAR( tmp27 );
8344  }
8345  {
8346  Py_CLEAR( tmp28 );
8347  }
8348  {
8349  Py_CLEAR( tmp29 );
8350  }
8351  {
8352  Py_CLEAR( tmp30 );
8353  }
8354  {
8355  Py_CLEAR( tmp31 ); free( arg31 );
8356  }
8357  return resultobj;
8358 fail:
8359  {
8360  Py_CLEAR( tmp13 );
8361  }
8362  {
8363  Py_CLEAR( tmp19 );
8364  }
8365  {
8366  Py_CLEAR( tmp20 ); free( arg20 );
8367  }
8368  {
8369  Py_CLEAR( tmp21 );
8370  }
8371  {
8372  Py_CLEAR( tmp22 );
8373  }
8374  {
8375  Py_CLEAR( tmp23 );
8376  }
8377  {
8378  Py_CLEAR( tmp24 );
8379  }
8380  {
8381  Py_CLEAR( tmp25 );
8382  }
8383  {
8384  Py_CLEAR( tmp26 );
8385  }
8386  {
8387  Py_CLEAR( tmp27 );
8388  }
8389  {
8390  Py_CLEAR( tmp28 );
8391  }
8392  {
8393  Py_CLEAR( tmp29 );
8394  }
8395  {
8396  Py_CLEAR( tmp30 );
8397  }
8398  {
8399  Py_CLEAR( tmp31 ); free( arg31 );
8400  }
8401  return NULL;
8402 }
8403 
8404 
8405 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406  PyObject *resultobj = 0;
8407  PLFLT *arg1 = (PLFLT *) 0 ;
8408  PLFLT *arg2 = (PLFLT *) 0 ;
8409  PLINT arg3 ;
8410  PLINT arg4 ;
8411  PLFLT arg5 ;
8412  PLFLT arg6 ;
8413  PLFLT arg7 ;
8414  PLFLT arg8 ;
8415  PLINT arg9 ;
8416  PLINT arg10 ;
8417  PLINT arg11 ;
8418  PLFLT arg12 ;
8419  PLFLT arg13 ;
8420  PLINT arg14 ;
8421  PLFLT arg15 ;
8422  PLINT arg16 ;
8423  PLINT *arg17 = (PLINT *) 0 ;
8424  char **arg18 = (char **) 0 ;
8425  PLINT arg19 ;
8426  char **arg20 = (char **) 0 ;
8427  PLFLT *arg21 = (PLFLT *) 0 ;
8428  PLINT *arg22 = (PLINT *) 0 ;
8429  PLINT *arg23 = (PLINT *) 0 ;
8430  PLFLT **arg24 = (PLFLT **) 0 ;
8431  PLFLT temp1 ;
8432  int res1 = SWIG_TMPOBJ ;
8433  PLFLT temp2 ;
8434  int res2 = SWIG_TMPOBJ ;
8435  int val3 ;
8436  int ecode3 = 0 ;
8437  int val4 ;
8438  int ecode4 = 0 ;
8439  double val5 ;
8440  int ecode5 = 0 ;
8441  double val6 ;
8442  int ecode6 = 0 ;
8443  double val7 ;
8444  int ecode7 = 0 ;
8445  double val8 ;
8446  int ecode8 = 0 ;
8447  int val9 ;
8448  int ecode9 = 0 ;
8449  int val10 ;
8450  int ecode10 = 0 ;
8451  int val11 ;
8452  int ecode11 = 0 ;
8453  double val12 ;
8454  int ecode12 = 0 ;
8455  double val13 ;
8456  int ecode13 = 0 ;
8457  int val14 ;
8458  int ecode14 = 0 ;
8459  double val15 ;
8460  int ecode15 = 0 ;
8461  PyArrayObject *tmp16 = NULL ;
8462  PyArrayObject *tmp18 = NULL ;
8463  PyArrayObject *tmp19 = NULL ;
8464  PyArrayObject *tmp21 = NULL ;
8465  PyArrayObject *tmp22 = NULL ;
8466  PyArrayObject *tmp23 = NULL ;
8467  PyArrayObject *tmp24 = NULL ;
8468  PyObject * obj0 = 0 ;
8469  PyObject * obj1 = 0 ;
8470  PyObject * obj2 = 0 ;
8471  PyObject * obj3 = 0 ;
8472  PyObject * obj4 = 0 ;
8473  PyObject * obj5 = 0 ;
8474  PyObject * obj6 = 0 ;
8475  PyObject * obj7 = 0 ;
8476  PyObject * obj8 = 0 ;
8477  PyObject * obj9 = 0 ;
8478  PyObject * obj10 = 0 ;
8479  PyObject * obj11 = 0 ;
8480  PyObject * obj12 = 0 ;
8481  PyObject * obj13 = 0 ;
8482  PyObject * obj14 = 0 ;
8483  PyObject * obj15 = 0 ;
8484  PyObject * obj16 = 0 ;
8485  PyObject * obj17 = 0 ;
8486  PyObject * obj18 = 0 ;
8487  PyObject * obj19 = 0 ;
8488 
8489  arg1 = &temp1;
8490  arg2 = &temp2;
8491  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;
8492  ecode3 = SWIG_AsVal_int(obj0, &val3);
8493  if (!SWIG_IsOK(ecode3)) {
8494  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8495  }
8496  arg3 = (PLINT)(val3);
8497  ecode4 = SWIG_AsVal_int(obj1, &val4);
8498  if (!SWIG_IsOK(ecode4)) {
8499  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8500  }
8501  arg4 = (PLINT)(val4);
8502  ecode5 = SWIG_AsVal_double(obj2, &val5);
8503  if (!SWIG_IsOK(ecode5)) {
8504  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8505  }
8506  arg5 = (PLFLT)(val5);
8507  ecode6 = SWIG_AsVal_double(obj3, &val6);
8508  if (!SWIG_IsOK(ecode6)) {
8509  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8510  }
8511  arg6 = (PLFLT)(val6);
8512  ecode7 = SWIG_AsVal_double(obj4, &val7);
8513  if (!SWIG_IsOK(ecode7)) {
8514  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8515  }
8516  arg7 = (PLFLT)(val7);
8517  ecode8 = SWIG_AsVal_double(obj5, &val8);
8518  if (!SWIG_IsOK(ecode8)) {
8519  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8520  }
8521  arg8 = (PLFLT)(val8);
8522  ecode9 = SWIG_AsVal_int(obj6, &val9);
8523  if (!SWIG_IsOK(ecode9)) {
8524  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8525  }
8526  arg9 = (PLINT)(val9);
8527  ecode10 = SWIG_AsVal_int(obj7, &val10);
8528  if (!SWIG_IsOK(ecode10)) {
8529  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8530  }
8531  arg10 = (PLINT)(val10);
8532  ecode11 = SWIG_AsVal_int(obj8, &val11);
8533  if (!SWIG_IsOK(ecode11)) {
8534  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8535  }
8536  arg11 = (PLINT)(val11);
8537  ecode12 = SWIG_AsVal_double(obj9, &val12);
8538  if (!SWIG_IsOK(ecode12)) {
8539  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8540  }
8541  arg12 = (PLFLT)(val12);
8542  ecode13 = SWIG_AsVal_double(obj10, &val13);
8543  if (!SWIG_IsOK(ecode13)) {
8544  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8545  }
8546  arg13 = (PLFLT)(val13);
8547  ecode14 = SWIG_AsVal_int(obj11, &val14);
8548  if (!SWIG_IsOK(ecode14)) {
8549  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8550  }
8551  arg14 = (PLINT)(val14);
8552  ecode15 = SWIG_AsVal_double(obj12, &val15);
8553  if (!SWIG_IsOK(ecode15)) {
8554  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8555  }
8556  arg15 = (PLFLT)(val15);
8557  {
8558  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8559  if ( tmp16 == NULL )
8560  return NULL;
8561  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8562  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8563  }
8564  {
8565  int i;
8566  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8567  if ( tmp18 == NULL )
8568  return NULL;
8569  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8570  {
8571  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8572  return NULL;
8573  }
8574  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8575  for ( i = 0; i < Alen; i++ )
8576  {
8577  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8578  if ( arg18[i] == NULL )
8579  {
8580  free( arg18 );
8581  return NULL;
8582  }
8583  }
8584  }
8585  {
8586  int i;
8587  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8588  if ( tmp19 == NULL )
8589  return NULL;
8590  Alen = PyArray_DIMS( tmp19 )[0];
8591  arg19 = Alen;
8592  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8593  for ( i = 0; i < Alen; i++ )
8594  {
8595  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8596  if ( arg20[i] == NULL )
8597  {
8598  free( arg20 );
8599  return NULL;
8600  }
8601  }
8602  }
8603  {
8604  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8605  if ( tmp21 == NULL )
8606  return NULL;
8607  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8608  {
8609  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8610  return NULL;
8611  }
8612  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8613  }
8614  {
8615  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8616  if ( tmp22 == NULL )
8617  return NULL;
8618  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8619  {
8620  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8621  return NULL;
8622  }
8623  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8624  }
8625  {
8626  int i;
8627  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8628  if ( tmp23 == NULL )
8629  return NULL;
8630  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8631  {
8632  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8633  return NULL;
8634  }
8635  Xlen = PyArray_DIMS( tmp23 )[0];
8636  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8637  Ylen = -1;
8638  for ( i = 0; i < Xlen; i++ )
8639  if ( arg23[i] > Ylen )
8640  Ylen = arg23[i];
8641  }
8642  {
8643  int i, size;
8644  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8645  if ( tmp24 == NULL )
8646  return NULL;
8647  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8648  {
8649  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8650  return NULL;
8651  }
8652  size = Ylen;
8653  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8654  for ( i = 0; i < Xlen; i++ )
8655  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8656  }
8657  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);
8658  resultobj = SWIG_Py_Void();
8659  if (SWIG_IsTmpObj(res1)) {
8660  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8661  } else {
8662  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8663  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8664  }
8665  if (SWIG_IsTmpObj(res2)) {
8666  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8667  } else {
8668  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8669  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8670  }
8671  {
8672  Py_CLEAR( tmp16 );
8673  }
8674  {
8675  Py_CLEAR( tmp18 ); free( arg18 );
8676  }
8677  {
8678  Py_CLEAR( tmp19 ); free( arg20 );
8679  }
8680  {
8681  Py_CLEAR( tmp21 );
8682  }
8683  {
8684  Py_CLEAR( tmp22 );
8685  }
8686  {
8687  Py_CLEAR( tmp23 );
8688  }
8689  {
8690  Py_CLEAR( tmp24 );
8691  free( arg24 );
8692  }
8693  return resultobj;
8694 fail:
8695  {
8696  Py_CLEAR( tmp16 );
8697  }
8698  {
8699  Py_CLEAR( tmp18 ); free( arg18 );
8700  }
8701  {
8702  Py_CLEAR( tmp19 ); free( arg20 );
8703  }
8704  {
8705  Py_CLEAR( tmp21 );
8706  }
8707  {
8708  Py_CLEAR( tmp22 );
8709  }
8710  {
8711  Py_CLEAR( tmp23 );
8712  }
8713  {
8714  Py_CLEAR( tmp24 );
8715  free( arg24 );
8716  }
8717  return NULL;
8718 }
8719 
8720 
8721 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8722  PyObject *resultobj = 0;
8723  PLFLT arg1 ;
8724  PLFLT arg2 ;
8725  PLFLT arg3 ;
8726  double val1 ;
8727  int ecode1 = 0 ;
8728  double val2 ;
8729  int ecode2 = 0 ;
8730  double val3 ;
8731  int ecode3 = 0 ;
8732  PyObject * obj0 = 0 ;
8733  PyObject * obj1 = 0 ;
8734  PyObject * obj2 = 0 ;
8735 
8736  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8737  ecode1 = SWIG_AsVal_double(obj0, &val1);
8738  if (!SWIG_IsOK(ecode1)) {
8739  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8740  }
8741  arg1 = (PLFLT)(val1);
8742  ecode2 = SWIG_AsVal_double(obj1, &val2);
8743  if (!SWIG_IsOK(ecode2)) {
8744  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8745  }
8746  arg2 = (PLFLT)(val2);
8747  ecode3 = SWIG_AsVal_double(obj2, &val3);
8748  if (!SWIG_IsOK(ecode3)) {
8749  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8750  }
8751  arg3 = (PLFLT)(val3);
8752  pllightsource(arg1,arg2,arg3);
8753  resultobj = SWIG_Py_Void();
8754  return resultobj;
8755 fail:
8756  return NULL;
8757 }
8758 
8759 
8760 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8761  PyObject *resultobj = 0;
8762  PLINT arg1 ;
8763  PLFLT *arg2 = (PLFLT *) 0 ;
8764  PLFLT *arg3 = (PLFLT *) 0 ;
8765  PyArrayObject *tmp1 = NULL ;
8766  PyArrayObject *tmp3 = NULL ;
8767  PyObject * obj0 = 0 ;
8768  PyObject * obj1 = 0 ;
8769 
8770  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8771  {
8772  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8773  if ( tmp1 == NULL )
8774  return NULL;
8775  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8776  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8777  }
8778  {
8779  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8780  if ( tmp3 == NULL )
8781  return NULL;
8782  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8783  {
8784  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8785  return NULL;
8786  }
8787  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8788  }
8789  plline(arg1,(double const *)arg2,(double const *)arg3);
8790  resultobj = SWIG_Py_Void();
8791  {
8792  Py_CLEAR( tmp1 );
8793  }
8794  {
8795  Py_CLEAR( tmp3 );
8796  }
8797  return resultobj;
8798 fail:
8799  {
8800  Py_CLEAR( tmp1 );
8801  }
8802  {
8803  Py_CLEAR( tmp3 );
8804  }
8805  return NULL;
8806 }
8807 
8808 
8809 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8810  PyObject *resultobj = 0;
8811  PLINT arg1 ;
8812  PLFLT *arg2 = (PLFLT *) 0 ;
8813  PLFLT *arg3 = (PLFLT *) 0 ;
8814  PLFLT *arg4 = (PLFLT *) 0 ;
8815  PyArrayObject *tmp1 = NULL ;
8816  PyArrayObject *tmp3 = NULL ;
8817  PyArrayObject *tmp4 = NULL ;
8818  PyObject * obj0 = 0 ;
8819  PyObject * obj1 = 0 ;
8820  PyObject * obj2 = 0 ;
8821 
8822  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8823  {
8824  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8825  if ( tmp1 == NULL )
8826  return NULL;
8827  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8828  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8829  }
8830  {
8831  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8832  if ( tmp3 == NULL )
8833  return NULL;
8834  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8835  {
8836  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8837  return NULL;
8838  }
8839  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8840  }
8841  {
8842  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8843  if ( tmp4 == NULL )
8844  return NULL;
8845  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8846  {
8847  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8848  return NULL;
8849  }
8850  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8851  }
8852  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8853  resultobj = SWIG_Py_Void();
8854  {
8855  Py_CLEAR( tmp1 );
8856  }
8857  {
8858  Py_CLEAR( tmp3 );
8859  }
8860  {
8861  Py_CLEAR( tmp4 );
8862  }
8863  return resultobj;
8864 fail:
8865  {
8866  Py_CLEAR( tmp1 );
8867  }
8868  {
8869  Py_CLEAR( tmp3 );
8870  }
8871  {
8872  Py_CLEAR( tmp4 );
8873  }
8874  return NULL;
8875 }
8876 
8877 
8878 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8879  PyObject *resultobj = 0;
8880  PLINT arg1 ;
8881  int val1 ;
8882  int ecode1 = 0 ;
8883  PyObject * obj0 = 0 ;
8884 
8885  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8886  ecode1 = SWIG_AsVal_int(obj0, &val1);
8887  if (!SWIG_IsOK(ecode1)) {
8888  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8889  }
8890  arg1 = (PLINT)(val1);
8891  pllsty(arg1);
8892  resultobj = SWIG_Py_Void();
8893  return resultobj;
8894 fail:
8895  return NULL;
8896 }
8897 
8898 
8899 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900  PyObject *resultobj = 0;
8901  PLFLT *arg1 = (PLFLT *) 0 ;
8902  PLFLT *arg2 = (PLFLT *) 0 ;
8903  PLFLT **arg3 = (PLFLT **) 0 ;
8904  PLINT arg4 ;
8905  PLINT arg5 ;
8906  PLINT arg6 ;
8907  PyArrayObject *tmp1 = NULL ;
8908  PyArrayObject *tmp2 = NULL ;
8909  PyArrayObject *tmp3 = NULL ;
8910  int val6 ;
8911  int ecode6 = 0 ;
8912  PyObject * obj0 = 0 ;
8913  PyObject * obj1 = 0 ;
8914  PyObject * obj2 = 0 ;
8915  PyObject * obj3 = 0 ;
8916 
8917  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8918  {
8919  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8920  if ( tmp1 == NULL )
8921  return NULL;
8922  Xlen = PyArray_DIMS( tmp1 )[0];
8923  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8924  }
8925  {
8926  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8927  if ( tmp2 == NULL )
8928  return NULL;
8929  Ylen = PyArray_DIMS( tmp2 )[0];
8930  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8931  }
8932  {
8933  int i, size;
8934  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8935  if ( tmp3 == NULL )
8936  return NULL;
8937  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8938  {
8939  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8940  return NULL;
8941  }
8942  arg4 = PyArray_DIMS( tmp3 )[0];
8943  arg5 = PyArray_DIMS( tmp3 )[1];
8944  size = arg5;
8945  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8946  for ( i = 0; i < arg4; i++ )
8947  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8948  }
8949  ecode6 = SWIG_AsVal_int(obj3, &val6);
8950  if (!SWIG_IsOK(ecode6)) {
8951  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8952  }
8953  arg6 = (PLINT)(val6);
8954  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8955  resultobj = SWIG_Py_Void();
8956  {
8957  Py_CLEAR( tmp1 );
8958  }
8959  {
8960  Py_CLEAR( tmp2 );
8961  }
8962  {
8963  Py_CLEAR( tmp3 );
8964  free( arg3 );
8965  }
8966  return resultobj;
8967 fail:
8968  {
8969  Py_CLEAR( tmp1 );
8970  }
8971  {
8972  Py_CLEAR( tmp2 );
8973  }
8974  {
8975  Py_CLEAR( tmp3 );
8976  free( arg3 );
8977  }
8978  return NULL;
8979 }
8980 
8981 
8982 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8983  PyObject *resultobj = 0;
8984  PLFLT *arg1 = (PLFLT *) 0 ;
8985  PLFLT *arg2 = (PLFLT *) 0 ;
8986  PLFLT **arg3 = (PLFLT **) 0 ;
8987  PLINT arg4 ;
8988  PLINT arg5 ;
8989  PLINT arg6 ;
8990  PLFLT *arg7 = (PLFLT *) 0 ;
8991  PLINT arg8 ;
8992  PyArrayObject *tmp1 = NULL ;
8993  PyArrayObject *tmp2 = NULL ;
8994  PyArrayObject *tmp3 = NULL ;
8995  int val6 ;
8996  int ecode6 = 0 ;
8997  PyArrayObject *tmp7 = NULL ;
8998  PyObject * obj0 = 0 ;
8999  PyObject * obj1 = 0 ;
9000  PyObject * obj2 = 0 ;
9001  PyObject * obj3 = 0 ;
9002  PyObject * obj4 = 0 ;
9003 
9004  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9005  {
9006  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9007  if ( tmp1 == NULL )
9008  return NULL;
9009  Xlen = PyArray_DIMS( tmp1 )[0];
9010  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9011  }
9012  {
9013  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9014  if ( tmp2 == NULL )
9015  return NULL;
9016  Ylen = PyArray_DIMS( tmp2 )[0];
9017  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9018  }
9019  {
9020  int i, size;
9021  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9022  if ( tmp3 == NULL )
9023  return NULL;
9024  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9025  {
9026  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9027  return NULL;
9028  }
9029  arg4 = PyArray_DIMS( tmp3 )[0];
9030  arg5 = PyArray_DIMS( tmp3 )[1];
9031  size = arg5;
9032  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9033  for ( i = 0; i < arg4; i++ )
9034  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9035  }
9036  ecode6 = SWIG_AsVal_int(obj3, &val6);
9037  if (!SWIG_IsOK(ecode6)) {
9038  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9039  }
9040  arg6 = (PLINT)(val6);
9041  {
9042  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9043  if ( tmp7 == NULL )
9044  return NULL;
9045  arg8 = PyArray_DIMS( tmp7 )[0];
9046  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9047  }
9048  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9049  resultobj = SWIG_Py_Void();
9050  {
9051  Py_CLEAR( tmp1 );
9052  }
9053  {
9054  Py_CLEAR( tmp2 );
9055  }
9056  {
9057  Py_CLEAR( tmp3 );
9058  free( arg3 );
9059  }
9060  {
9061  Py_CLEAR( tmp7 );
9062  }
9063  return resultobj;
9064 fail:
9065  {
9066  Py_CLEAR( tmp1 );
9067  }
9068  {
9069  Py_CLEAR( tmp2 );
9070  }
9071  {
9072  Py_CLEAR( tmp3 );
9073  free( arg3 );
9074  }
9075  {
9076  Py_CLEAR( tmp7 );
9077  }
9078  return NULL;
9079 }
9080 
9081 
9082 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083  PyObject *resultobj = 0;
9084  PLINT *arg1 = (PLINT *) 0 ;
9085  PLINT temp1 ;
9086  int res1 = SWIG_TMPOBJ ;
9087 
9088  arg1 = &temp1;
9089  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
9090  plmkstrm(arg1);
9091  resultobj = SWIG_Py_Void();
9092  if (SWIG_IsTmpObj(res1)) {
9093  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9094  } else {
9095  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9096  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9097  }
9098  return resultobj;
9099 fail:
9100  return NULL;
9101 }
9102 
9103 
9104 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105  PyObject *resultobj = 0;
9106  char *arg1 = (char *) 0 ;
9107  PLFLT arg2 ;
9108  PLFLT arg3 ;
9109  PLFLT arg4 ;
9110  char *arg5 = (char *) 0 ;
9111  int res1 ;
9112  char *buf1 = 0 ;
9113  int alloc1 = 0 ;
9114  double val2 ;
9115  int ecode2 = 0 ;
9116  double val3 ;
9117  int ecode3 = 0 ;
9118  double val4 ;
9119  int ecode4 = 0 ;
9120  int res5 ;
9121  char *buf5 = 0 ;
9122  int alloc5 = 0 ;
9123  PyObject * obj0 = 0 ;
9124  PyObject * obj1 = 0 ;
9125  PyObject * obj2 = 0 ;
9126  PyObject * obj3 = 0 ;
9127  PyObject * obj4 = 0 ;
9128 
9129  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9130  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9131  if (!SWIG_IsOK(res1)) {
9132  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9133  }
9134  arg1 = (char *)(buf1);
9135  ecode2 = SWIG_AsVal_double(obj1, &val2);
9136  if (!SWIG_IsOK(ecode2)) {
9137  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9138  }
9139  arg2 = (PLFLT)(val2);
9140  ecode3 = SWIG_AsVal_double(obj2, &val3);
9141  if (!SWIG_IsOK(ecode3)) {
9142  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9143  }
9144  arg3 = (PLFLT)(val3);
9145  ecode4 = SWIG_AsVal_double(obj3, &val4);
9146  if (!SWIG_IsOK(ecode4)) {
9147  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9148  }
9149  arg4 = (PLFLT)(val4);
9150  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9151  if (!SWIG_IsOK(res5)) {
9152  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9153  }
9154  arg5 = (char *)(buf5);
9155  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9156  resultobj = SWIG_Py_Void();
9157  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9158  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9159  return resultobj;
9160 fail:
9161  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9162  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9163  return NULL;
9164 }
9165 
9166 
9167 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9168  PyObject *resultobj = 0;
9169  char *arg1 = (char *) 0 ;
9170  PLFLT arg2 ;
9171  PLFLT arg3 ;
9172  PLFLT arg4 ;
9173  char *arg5 = (char *) 0 ;
9174  int res1 ;
9175  char *buf1 = 0 ;
9176  int alloc1 = 0 ;
9177  double val2 ;
9178  int ecode2 = 0 ;
9179  double val3 ;
9180  int ecode3 = 0 ;
9181  double val4 ;
9182  int ecode4 = 0 ;
9183  int res5 ;
9184  char *buf5 = 0 ;
9185  int alloc5 = 0 ;
9186  PyObject * obj0 = 0 ;
9187  PyObject * obj1 = 0 ;
9188  PyObject * obj2 = 0 ;
9189  PyObject * obj3 = 0 ;
9190  PyObject * obj4 = 0 ;
9191 
9192  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9193  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9194  if (!SWIG_IsOK(res1)) {
9195  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9196  }
9197  arg1 = (char *)(buf1);
9198  ecode2 = SWIG_AsVal_double(obj1, &val2);
9199  if (!SWIG_IsOK(ecode2)) {
9200  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9201  }
9202  arg2 = (PLFLT)(val2);
9203  ecode3 = SWIG_AsVal_double(obj2, &val3);
9204  if (!SWIG_IsOK(ecode3)) {
9205  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9206  }
9207  arg3 = (PLFLT)(val3);
9208  ecode4 = SWIG_AsVal_double(obj3, &val4);
9209  if (!SWIG_IsOK(ecode4)) {
9210  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9211  }
9212  arg4 = (PLFLT)(val4);
9213  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9214  if (!SWIG_IsOK(res5)) {
9215  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9216  }
9217  arg5 = (char *)(buf5);
9218  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9219  resultobj = SWIG_Py_Void();
9220  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9221  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9222  return resultobj;
9223 fail:
9224  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9225  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9226  return NULL;
9227 }
9228 
9229 
9230 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231  PyObject *resultobj = 0;
9232  PLFLT *arg1 = (PLFLT *) 0 ;
9233  PLFLT *arg2 = (PLFLT *) 0 ;
9234  PLFLT **arg3 = (PLFLT **) 0 ;
9235  PLINT arg4 ;
9236  PLINT arg5 ;
9237  PLINT arg6 ;
9238  PLBOOL arg7 ;
9239  PyArrayObject *tmp1 = NULL ;
9240  PyArrayObject *tmp2 = NULL ;
9241  PyArrayObject *tmp3 = NULL ;
9242  int val6 ;
9243  int ecode6 = 0 ;
9244  int val7 ;
9245  int ecode7 = 0 ;
9246  PyObject * obj0 = 0 ;
9247  PyObject * obj1 = 0 ;
9248  PyObject * obj2 = 0 ;
9249  PyObject * obj3 = 0 ;
9250  PyObject * obj4 = 0 ;
9251 
9252  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9253  {
9254  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9255  if ( tmp1 == NULL )
9256  return NULL;
9257  Xlen = PyArray_DIMS( tmp1 )[0];
9258  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9259  }
9260  {
9261  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9262  if ( tmp2 == NULL )
9263  return NULL;
9264  Ylen = PyArray_DIMS( tmp2 )[0];
9265  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9266  }
9267  {
9268  int i, size;
9269  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9270  if ( tmp3 == NULL )
9271  return NULL;
9272  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9273  {
9274  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9275  return NULL;
9276  }
9277  arg4 = PyArray_DIMS( tmp3 )[0];
9278  arg5 = PyArray_DIMS( tmp3 )[1];
9279  size = arg5;
9280  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9281  for ( i = 0; i < arg4; i++ )
9282  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9283  }
9284  ecode6 = SWIG_AsVal_int(obj3, &val6);
9285  if (!SWIG_IsOK(ecode6)) {
9286  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9287  }
9288  arg6 = (PLINT)(val6);
9289  ecode7 = SWIG_AsVal_int(obj4, &val7);
9290  if (!SWIG_IsOK(ecode7)) {
9291  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9292  }
9293  arg7 = (PLBOOL)(val7);
9294  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9295  resultobj = SWIG_Py_Void();
9296  {
9297  Py_CLEAR( tmp1 );
9298  }
9299  {
9300  Py_CLEAR( tmp2 );
9301  }
9302  {
9303  Py_CLEAR( tmp3 );
9304  free( arg3 );
9305  }
9306  return resultobj;
9307 fail:
9308  {
9309  Py_CLEAR( tmp1 );
9310  }
9311  {
9312  Py_CLEAR( tmp2 );
9313  }
9314  {
9315  Py_CLEAR( tmp3 );
9316  free( arg3 );
9317  }
9318  return NULL;
9319 }
9320 
9321 
9322 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323  PyObject *resultobj = 0;
9324  PLFLT *arg1 = (PLFLT *) 0 ;
9325  PLFLT *arg2 = (PLFLT *) 0 ;
9326  PLFLT **arg3 = (PLFLT **) 0 ;
9327  PLINT arg4 ;
9328  PLINT arg5 ;
9329  PLINT arg6 ;
9330  PLFLT *arg7 = (PLFLT *) 0 ;
9331  PLINT arg8 ;
9332  PyArrayObject *tmp1 = NULL ;
9333  PyArrayObject *tmp2 = NULL ;
9334  PyArrayObject *tmp3 = NULL ;
9335  int val6 ;
9336  int ecode6 = 0 ;
9337  PyArrayObject *tmp7 = NULL ;
9338  PyObject * obj0 = 0 ;
9339  PyObject * obj1 = 0 ;
9340  PyObject * obj2 = 0 ;
9341  PyObject * obj3 = 0 ;
9342  PyObject * obj4 = 0 ;
9343 
9344  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9345  {
9346  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9347  if ( tmp1 == NULL )
9348  return NULL;
9349  Xlen = PyArray_DIMS( tmp1 )[0];
9350  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9351  }
9352  {
9353  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9354  if ( tmp2 == NULL )
9355  return NULL;
9356  Ylen = PyArray_DIMS( tmp2 )[0];
9357  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9358  }
9359  {
9360  int i, size;
9361  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9362  if ( tmp3 == NULL )
9363  return NULL;
9364  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9365  {
9366  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9367  return NULL;
9368  }
9369  arg4 = PyArray_DIMS( tmp3 )[0];
9370  arg5 = PyArray_DIMS( tmp3 )[1];
9371  size = arg5;
9372  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9373  for ( i = 0; i < arg4; i++ )
9374  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9375  }
9376  ecode6 = SWIG_AsVal_int(obj3, &val6);
9377  if (!SWIG_IsOK(ecode6)) {
9378  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9379  }
9380  arg6 = (PLINT)(val6);
9381  {
9382  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9383  if ( tmp7 == NULL )
9384  return NULL;
9385  arg8 = PyArray_DIMS( tmp7 )[0];
9386  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9387  }
9388  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9389  resultobj = SWIG_Py_Void();
9390  {
9391  Py_CLEAR( tmp1 );
9392  }
9393  {
9394  Py_CLEAR( tmp2 );
9395  }
9396  {
9397  Py_CLEAR( tmp3 );
9398  free( arg3 );
9399  }
9400  {
9401  Py_CLEAR( tmp7 );
9402  }
9403  return resultobj;
9404 fail:
9405  {
9406  Py_CLEAR( tmp1 );
9407  }
9408  {
9409  Py_CLEAR( tmp2 );
9410  }
9411  {
9412  Py_CLEAR( tmp3 );
9413  free( arg3 );
9414  }
9415  {
9416  Py_CLEAR( tmp7 );
9417  }
9418  return NULL;
9419 }
9420 
9421 
9422 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9423  PyObject *resultobj = 0;
9424  PLFLT *arg1 = (PLFLT *) 0 ;
9425  PLFLT *arg2 = (PLFLT *) 0 ;
9426  PLFLT **arg3 = (PLFLT **) 0 ;
9427  PLINT arg4 ;
9428  PLINT arg5 ;
9429  PLINT arg6 ;
9430  PLFLT *arg7 = (PLFLT *) 0 ;
9431  PLINT arg8 ;
9432  PLINT arg9 ;
9433  PLINT arg10 ;
9434  PLINT *arg11 = (PLINT *) 0 ;
9435  PLINT *arg12 = (PLINT *) 0 ;
9436  PyArrayObject *tmp1 = NULL ;
9437  PyArrayObject *tmp2 = NULL ;
9438  PyArrayObject *tmp3 = NULL ;
9439  int val6 ;
9440  int ecode6 = 0 ;
9441  PyArrayObject *tmp7 = NULL ;
9442  int val9 ;
9443  int ecode9 = 0 ;
9444  PyArrayObject *tmp10 = NULL ;
9445  PyArrayObject *tmp12 = NULL ;
9446  PyObject * obj0 = 0 ;
9447  PyObject * obj1 = 0 ;
9448  PyObject * obj2 = 0 ;
9449  PyObject * obj3 = 0 ;
9450  PyObject * obj4 = 0 ;
9451  PyObject * obj5 = 0 ;
9452  PyObject * obj6 = 0 ;
9453  PyObject * obj7 = 0 ;
9454 
9455  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) 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 '" "plot3dcl" "', 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  ecode9 = SWIG_AsVal_int(obj5, &val9);
9500  if (!SWIG_IsOK(ecode9)) {
9501  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9502  }
9503  arg9 = (PLINT)(val9);
9504  {
9505  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9506  if ( tmp10 == NULL )
9507  return NULL;
9508  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9509  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9510  }
9511  {
9512  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9513  if ( tmp12 == NULL )
9514  return NULL;
9515  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9516  {
9517  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9518  return NULL;
9519  }
9520  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9521  }
9522  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);
9523  resultobj = SWIG_Py_Void();
9524  {
9525  Py_CLEAR( tmp1 );
9526  }
9527  {
9528  Py_CLEAR( tmp2 );
9529  }
9530  {
9531  Py_CLEAR( tmp3 );
9532  free( arg3 );
9533  }
9534  {
9535  Py_CLEAR( tmp7 );
9536  }
9537  {
9538  Py_CLEAR( tmp10 );
9539  }
9540  {
9541  Py_CLEAR( tmp12 );
9542  }
9543  return resultobj;
9544 fail:
9545  {
9546  Py_CLEAR( tmp1 );
9547  }
9548  {
9549  Py_CLEAR( tmp2 );
9550  }
9551  {
9552  Py_CLEAR( tmp3 );
9553  free( arg3 );
9554  }
9555  {
9556  Py_CLEAR( tmp7 );
9557  }
9558  {
9559  Py_CLEAR( tmp10 );
9560  }
9561  {
9562  Py_CLEAR( tmp12 );
9563  }
9564  return NULL;
9565 }
9566 
9567 
9568 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569  PyObject *resultobj = 0;
9570  PLFLT *arg1 = (PLFLT *) 0 ;
9571  PLFLT *arg2 = (PLFLT *) 0 ;
9572  PLFLT **arg3 = (PLFLT **) 0 ;
9573  PLINT arg4 ;
9574  PLINT arg5 ;
9575  PLINT arg6 ;
9576  PLFLT *arg7 = (PLFLT *) 0 ;
9577  PLINT arg8 ;
9578  PyArrayObject *tmp1 = NULL ;
9579  PyArrayObject *tmp2 = NULL ;
9580  PyArrayObject *tmp3 = NULL ;
9581  int val6 ;
9582  int ecode6 = 0 ;
9583  PyArrayObject *tmp7 = NULL ;
9584  PyObject * obj0 = 0 ;
9585  PyObject * obj1 = 0 ;
9586  PyObject * obj2 = 0 ;
9587  PyObject * obj3 = 0 ;
9588  PyObject * obj4 = 0 ;
9589 
9590  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9591  {
9592  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9593  if ( tmp1 == NULL )
9594  return NULL;
9595  Xlen = PyArray_DIMS( tmp1 )[0];
9596  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9597  }
9598  {
9599  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9600  if ( tmp2 == NULL )
9601  return NULL;
9602  Ylen = PyArray_DIMS( tmp2 )[0];
9603  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9604  }
9605  {
9606  int i, size;
9607  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9608  if ( tmp3 == NULL )
9609  return NULL;
9610  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9611  {
9612  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9613  return NULL;
9614  }
9615  arg4 = PyArray_DIMS( tmp3 )[0];
9616  arg5 = PyArray_DIMS( tmp3 )[1];
9617  size = arg5;
9618  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9619  for ( i = 0; i < arg4; i++ )
9620  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9621  }
9622  ecode6 = SWIG_AsVal_int(obj3, &val6);
9623  if (!SWIG_IsOK(ecode6)) {
9624  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9625  }
9626  arg6 = (PLINT)(val6);
9627  {
9628  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9629  if ( tmp7 == NULL )
9630  return NULL;
9631  arg8 = PyArray_DIMS( tmp7 )[0];
9632  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9633  }
9634  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9635  resultobj = SWIG_Py_Void();
9636  {
9637  Py_CLEAR( tmp1 );
9638  }
9639  {
9640  Py_CLEAR( tmp2 );
9641  }
9642  {
9643  Py_CLEAR( tmp3 );
9644  free( arg3 );
9645  }
9646  {
9647  Py_CLEAR( tmp7 );
9648  }
9649  return resultobj;
9650 fail:
9651  {
9652  Py_CLEAR( tmp1 );
9653  }
9654  {
9655  Py_CLEAR( tmp2 );
9656  }
9657  {
9658  Py_CLEAR( tmp3 );
9659  free( arg3 );
9660  }
9661  {
9662  Py_CLEAR( tmp7 );
9663  }
9664  return NULL;
9665 }
9666 
9667 
9668 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669  PyObject *resultobj = 0;
9670  PLFLT *arg1 = (PLFLT *) 0 ;
9671  PLFLT *arg2 = (PLFLT *) 0 ;
9672  PLFLT **arg3 = (PLFLT **) 0 ;
9673  PLINT arg4 ;
9674  PLINT arg5 ;
9675  PLINT arg6 ;
9676  PLFLT *arg7 = (PLFLT *) 0 ;
9677  PLINT arg8 ;
9678  PLINT arg9 ;
9679  PLINT arg10 ;
9680  PLINT *arg11 = (PLINT *) 0 ;
9681  PLINT *arg12 = (PLINT *) 0 ;
9682  PyArrayObject *tmp1 = NULL ;
9683  PyArrayObject *tmp2 = NULL ;
9684  PyArrayObject *tmp3 = NULL ;
9685  int val6 ;
9686  int ecode6 = 0 ;
9687  PyArrayObject *tmp7 = NULL ;
9688  int val9 ;
9689  int ecode9 = 0 ;
9690  PyArrayObject *tmp10 = NULL ;
9691  PyArrayObject *tmp12 = NULL ;
9692  PyObject * obj0 = 0 ;
9693  PyObject * obj1 = 0 ;
9694  PyObject * obj2 = 0 ;
9695  PyObject * obj3 = 0 ;
9696  PyObject * obj4 = 0 ;
9697  PyObject * obj5 = 0 ;
9698  PyObject * obj6 = 0 ;
9699  PyObject * obj7 = 0 ;
9700 
9701  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9702  {
9703  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9704  if ( tmp1 == NULL )
9705  return NULL;
9706  Xlen = PyArray_DIMS( tmp1 )[0];
9707  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9708  }
9709  {
9710  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9711  if ( tmp2 == NULL )
9712  return NULL;
9713  Ylen = PyArray_DIMS( tmp2 )[0];
9714  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9715  }
9716  {
9717  int i, size;
9718  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9719  if ( tmp3 == NULL )
9720  return NULL;
9721  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9722  {
9723  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9724  return NULL;
9725  }
9726  arg4 = PyArray_DIMS( tmp3 )[0];
9727  arg5 = PyArray_DIMS( tmp3 )[1];
9728  size = arg5;
9729  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9730  for ( i = 0; i < arg4; i++ )
9731  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9732  }
9733  ecode6 = SWIG_AsVal_int(obj3, &val6);
9734  if (!SWIG_IsOK(ecode6)) {
9735  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9736  }
9737  arg6 = (PLINT)(val6);
9738  {
9739  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9740  if ( tmp7 == NULL )
9741  return NULL;
9742  arg8 = PyArray_DIMS( tmp7 )[0];
9743  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9744  }
9745  ecode9 = SWIG_AsVal_int(obj5, &val9);
9746  if (!SWIG_IsOK(ecode9)) {
9747  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9748  }
9749  arg9 = (PLINT)(val9);
9750  {
9751  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9752  if ( tmp10 == NULL )
9753  return NULL;
9754  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9755  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9756  }
9757  {
9758  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9759  if ( tmp12 == NULL )
9760  return NULL;
9761  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9762  {
9763  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9764  return NULL;
9765  }
9766  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9767  }
9768  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);
9769  resultobj = SWIG_Py_Void();
9770  {
9771  Py_CLEAR( tmp1 );
9772  }
9773  {
9774  Py_CLEAR( tmp2 );
9775  }
9776  {
9777  Py_CLEAR( tmp3 );
9778  free( arg3 );
9779  }
9780  {
9781  Py_CLEAR( tmp7 );
9782  }
9783  {
9784  Py_CLEAR( tmp10 );
9785  }
9786  {
9787  Py_CLEAR( tmp12 );
9788  }
9789  return resultobj;
9790 fail:
9791  {
9792  Py_CLEAR( tmp1 );
9793  }
9794  {
9795  Py_CLEAR( tmp2 );
9796  }
9797  {
9798  Py_CLEAR( tmp3 );
9799  free( arg3 );
9800  }
9801  {
9802  Py_CLEAR( tmp7 );
9803  }
9804  {
9805  Py_CLEAR( tmp10 );
9806  }
9807  {
9808  Py_CLEAR( tmp12 );
9809  }
9810  return NULL;
9811 }
9812 
9813 
9814 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815  PyObject *resultobj = 0;
9816  int *arg1 = (int *) 0 ;
9817  char **arg2 = (char **) 0 ;
9818  PLINT arg3 ;
9819  int tmp1 ;
9820  int val3 ;
9821  int ecode3 = 0 ;
9822  PyObject * obj0 = 0 ;
9823  PyObject * obj1 = 0 ;
9824  PLINT result;
9825 
9826  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9827  {
9828  int i;
9829  PyObject *unicode_string;
9830 
9831  if ( !PyList_Check( obj0 ) )
9832  {
9833  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9834  return NULL;
9835  }
9836  tmp1 = PyList_Size( obj0 );
9837  arg1 = &tmp1;
9838  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9839  for ( i = 0; i < tmp1; i++ )
9840  {
9841  PyObject *s = PyList_GetItem( obj0, i );
9842  if ( PyString_Check( s ) )
9843  {
9844  arg2[i] = PyString_AsString( s );
9845  }
9846  else if ( PyUnicode_Check( s ) )
9847  {
9848  // unicode_string is never freed? memory leak here?
9849  unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9850  arg2[i] = PyBytes_AS_STRING( unicode_string );
9851  }
9852  else
9853  {
9854  free( arg2 );
9855  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9856  return NULL;
9857  }
9858  }
9859  arg2[i] = 0;
9860  }
9861  ecode3 = SWIG_AsVal_int(obj1, &val3);
9862  if (!SWIG_IsOK(ecode3)) {
9863  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9864  }
9865  arg3 = (PLINT)(val3);
9866  result = (PLINT)plparseopts(arg1,arg2,arg3);
9867  resultobj = SWIG_From_int((int)(result));
9868  {
9869  if ( arg2 )
9870  free( arg2 );
9871  }
9872  return resultobj;
9873 fail:
9874  {
9875  if ( arg2 )
9876  free( arg2 );
9877  }
9878  return NULL;
9879 }
9880 
9881 
9882 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883  PyObject *resultobj = 0;
9884  PLINT arg1 ;
9885  PLINT *arg2 = (PLINT *) 0 ;
9886  PLINT *arg3 = (PLINT *) 0 ;
9887  PyArrayObject *tmp1 = NULL ;
9888  PyArrayObject *tmp3 = NULL ;
9889  PyObject * obj0 = 0 ;
9890  PyObject * obj1 = 0 ;
9891 
9892  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9893  {
9894  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9895  if ( tmp1 == NULL )
9896  return NULL;
9897  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9898  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9899  }
9900  {
9901  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9902  if ( tmp3 == NULL )
9903  return NULL;
9904  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9905  {
9906  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9907  return NULL;
9908  }
9909  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9910  }
9911  plpat(arg1,(int const *)arg2,(int const *)arg3);
9912  resultobj = SWIG_Py_Void();
9913  {
9914  Py_CLEAR( tmp1 );
9915  }
9916  {
9917  Py_CLEAR( tmp3 );
9918  }
9919  return resultobj;
9920 fail:
9921  {
9922  Py_CLEAR( tmp1 );
9923  }
9924  {
9925  Py_CLEAR( tmp3 );
9926  }
9927  return NULL;
9928 }
9929 
9930 
9931 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932  PyObject *resultobj = 0;
9933  PLINT arg1 ;
9934  PLFLT arg2 ;
9935  PLFLT arg3 ;
9936  PLFLT arg4 ;
9937  PLFLT arg5 ;
9938  int val1 ;
9939  int ecode1 = 0 ;
9940  double val2 ;
9941  int ecode2 = 0 ;
9942  double val3 ;
9943  int ecode3 = 0 ;
9944  double val4 ;
9945  int ecode4 = 0 ;
9946  double val5 ;
9947  int ecode5 = 0 ;
9948  PyObject * obj0 = 0 ;
9949  PyObject * obj1 = 0 ;
9950  PyObject * obj2 = 0 ;
9951  PyObject * obj3 = 0 ;
9952  PyObject * obj4 = 0 ;
9953 
9954  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9955  ecode1 = SWIG_AsVal_int(obj0, &val1);
9956  if (!SWIG_IsOK(ecode1)) {
9957  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9958  }
9959  arg1 = (PLINT)(val1);
9960  ecode2 = SWIG_AsVal_double(obj1, &val2);
9961  if (!SWIG_IsOK(ecode2)) {
9962  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9963  }
9964  arg2 = (PLFLT)(val2);
9965  ecode3 = SWIG_AsVal_double(obj2, &val3);
9966  if (!SWIG_IsOK(ecode3)) {
9967  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9968  }
9969  arg3 = (PLFLT)(val3);
9970  ecode4 = SWIG_AsVal_double(obj3, &val4);
9971  if (!SWIG_IsOK(ecode4)) {
9972  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9973  }
9974  arg4 = (PLFLT)(val4);
9975  ecode5 = SWIG_AsVal_double(obj4, &val5);
9976  if (!SWIG_IsOK(ecode5)) {
9977  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9978  }
9979  arg5 = (PLFLT)(val5);
9980  plpath(arg1,arg2,arg3,arg4,arg5);
9981  resultobj = SWIG_Py_Void();
9982  return resultobj;
9983 fail:
9984  return NULL;
9985 }
9986 
9987 
9988 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989  PyObject *resultobj = 0;
9990  PLINT arg1 ;
9991  PLFLT *arg2 = (PLFLT *) 0 ;
9992  PLFLT *arg3 = (PLFLT *) 0 ;
9993  PLINT arg4 ;
9994  PyArrayObject *tmp1 = NULL ;
9995  PyArrayObject *tmp3 = NULL ;
9996  int val4 ;
9997  int ecode4 = 0 ;
9998  PyObject * obj0 = 0 ;
9999  PyObject * obj1 = 0 ;
10000  PyObject * obj2 = 0 ;
10001 
10002  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
10003  {
10004  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10005  if ( tmp1 == NULL )
10006  return NULL;
10007  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10008  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10009  }
10010  {
10011  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10012  if ( tmp3 == NULL )
10013  return NULL;
10014  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10015  {
10016  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10017  return NULL;
10018  }
10019  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10020  }
10021  ecode4 = SWIG_AsVal_int(obj2, &val4);
10022  if (!SWIG_IsOK(ecode4)) {
10023  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10024  }
10025  arg4 = (PLINT)(val4);
10026  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10027  resultobj = SWIG_Py_Void();
10028  {
10029  Py_CLEAR( tmp1 );
10030  }
10031  {
10032  Py_CLEAR( tmp3 );
10033  }
10034  return resultobj;
10035 fail:
10036  {
10037  Py_CLEAR( tmp1 );
10038  }
10039  {
10040  Py_CLEAR( tmp3 );
10041  }
10042  return NULL;
10043 }
10044 
10045 
10046 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10047  PyObject *resultobj = 0;
10048  PLINT arg1 ;
10049  PLFLT *arg2 = (PLFLT *) 0 ;
10050  PLFLT *arg3 = (PLFLT *) 0 ;
10051  PLFLT *arg4 = (PLFLT *) 0 ;
10052  PLINT arg5 ;
10053  PyArrayObject *tmp1 = NULL ;
10054  PyArrayObject *tmp3 = NULL ;
10055  PyArrayObject *tmp4 = NULL ;
10056  int val5 ;
10057  int ecode5 = 0 ;
10058  PyObject * obj0 = 0 ;
10059  PyObject * obj1 = 0 ;
10060  PyObject * obj2 = 0 ;
10061  PyObject * obj3 = 0 ;
10062 
10063  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10064  {
10065  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10066  if ( tmp1 == NULL )
10067  return NULL;
10068  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10069  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10070  }
10071  {
10072  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10073  if ( tmp3 == NULL )
10074  return NULL;
10075  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10076  {
10077  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10078  return NULL;
10079  }
10080  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10081  }
10082  {
10083  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10084  if ( tmp4 == NULL )
10085  return NULL;
10086  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10087  {
10088  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10089  return NULL;
10090  }
10091  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10092  }
10093  ecode5 = SWIG_AsVal_int(obj3, &val5);
10094  if (!SWIG_IsOK(ecode5)) {
10095  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10096  }
10097  arg5 = (PLINT)(val5);
10098  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10099  resultobj = SWIG_Py_Void();
10100  {
10101  Py_CLEAR( tmp1 );
10102  }
10103  {
10104  Py_CLEAR( tmp3 );
10105  }
10106  {
10107  Py_CLEAR( tmp4 );
10108  }
10109  return resultobj;
10110 fail:
10111  {
10112  Py_CLEAR( tmp1 );
10113  }
10114  {
10115  Py_CLEAR( tmp3 );
10116  }
10117  {
10118  Py_CLEAR( tmp4 );
10119  }
10120  return NULL;
10121 }
10122 
10123 
10124 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10125  PyObject *resultobj = 0;
10126  PLINT arg1 ;
10127  PLFLT *arg2 = (PLFLT *) 0 ;
10128  PLFLT *arg3 = (PLFLT *) 0 ;
10129  PLFLT *arg4 = (PLFLT *) 0 ;
10130  PLBOOL *arg5 = (PLBOOL *) 0 ;
10131  PLBOOL arg6 ;
10132  PyArrayObject *tmp1 = NULL ;
10133  PyArrayObject *tmp3 = NULL ;
10134  PyArrayObject *tmp4 = NULL ;
10135  PyArrayObject *tmp5 = NULL ;
10136  int val6 ;
10137  int ecode6 = 0 ;
10138  PyObject * obj0 = 0 ;
10139  PyObject * obj1 = 0 ;
10140  PyObject * obj2 = 0 ;
10141  PyObject * obj3 = 0 ;
10142  PyObject * obj4 = 0 ;
10143 
10144  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10145  {
10146  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10147  if ( tmp1 == NULL )
10148  return NULL;
10149  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10150  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10151  }
10152  {
10153  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10154  if ( tmp3 == NULL )
10155  return NULL;
10156  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10157  {
10158  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10159  return NULL;
10160  }
10161  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10162  }
10163  {
10164  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10165  if ( tmp4 == NULL )
10166  return NULL;
10167  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10168  {
10169  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10170  return NULL;
10171  }
10172  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10173  }
10174  {
10175  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10176  if ( tmp5 == NULL )
10177  return NULL;
10178  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10179  {
10180  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10181  return NULL;
10182  }
10183  arg5 = (PLINT *) PyArray_DATA( tmp5 );
10184  }
10185  ecode6 = SWIG_AsVal_int(obj4, &val6);
10186  if (!SWIG_IsOK(ecode6)) {
10187  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10188  }
10189  arg6 = (PLBOOL)(val6);
10190  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10191  resultobj = SWIG_Py_Void();
10192  {
10193  Py_CLEAR( tmp1 );
10194  }
10195  {
10196  Py_CLEAR( tmp3 );
10197  }
10198  {
10199  Py_CLEAR( tmp4 );
10200  }
10201  {
10202  Py_CLEAR( tmp5 );
10203  }
10204  return resultobj;
10205 fail:
10206  {
10207  Py_CLEAR( tmp1 );
10208  }
10209  {
10210  Py_CLEAR( tmp3 );
10211  }
10212  {
10213  Py_CLEAR( tmp4 );
10214  }
10215  {
10216  Py_CLEAR( tmp5 );
10217  }
10218  return NULL;
10219 }
10220 
10221 
10222 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10223  PyObject *resultobj = 0;
10224  PLINT arg1 ;
10225  PLINT arg2 ;
10226  int val1 ;
10227  int ecode1 = 0 ;
10228  int val2 ;
10229  int ecode2 = 0 ;
10230  PyObject * obj0 = 0 ;
10231  PyObject * obj1 = 0 ;
10232 
10233  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10234  ecode1 = SWIG_AsVal_int(obj0, &val1);
10235  if (!SWIG_IsOK(ecode1)) {
10236  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10237  }
10238  arg1 = (PLINT)(val1);
10239  ecode2 = SWIG_AsVal_int(obj1, &val2);
10240  if (!SWIG_IsOK(ecode2)) {
10241  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10242  }
10243  arg2 = (PLINT)(val2);
10244  plprec(arg1,arg2);
10245  resultobj = SWIG_Py_Void();
10246  return resultobj;
10247 fail:
10248  return NULL;
10249 }
10250 
10251 
10252 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10253  PyObject *resultobj = 0;
10254  PLINT arg1 ;
10255  int val1 ;
10256  int ecode1 = 0 ;
10257  PyObject * obj0 = 0 ;
10258 
10259  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10260  ecode1 = SWIG_AsVal_int(obj0, &val1);
10261  if (!SWIG_IsOK(ecode1)) {
10262  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10263  }
10264  arg1 = (PLINT)(val1);
10265  plpsty(arg1);
10266  resultobj = SWIG_Py_Void();
10267  return resultobj;
10268 fail:
10269  return NULL;
10270 }
10271 
10272 
10273 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10274  PyObject *resultobj = 0;
10275  PLFLT arg1 ;
10276  PLFLT arg2 ;
10277  PLFLT arg3 ;
10278  PLFLT arg4 ;
10279  PLFLT arg5 ;
10280  char *arg6 = (char *) 0 ;
10281  double val1 ;
10282  int ecode1 = 0 ;
10283  double val2 ;
10284  int ecode2 = 0 ;
10285  double val3 ;
10286  int ecode3 = 0 ;
10287  double val4 ;
10288  int ecode4 = 0 ;
10289  double val5 ;
10290  int ecode5 = 0 ;
10291  int res6 ;
10292  char *buf6 = 0 ;
10293  int alloc6 = 0 ;
10294  PyObject * obj0 = 0 ;
10295  PyObject * obj1 = 0 ;
10296  PyObject * obj2 = 0 ;
10297  PyObject * obj3 = 0 ;
10298  PyObject * obj4 = 0 ;
10299  PyObject * obj5 = 0 ;
10300 
10301  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10302  ecode1 = SWIG_AsVal_double(obj0, &val1);
10303  if (!SWIG_IsOK(ecode1)) {
10304  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10305  }
10306  arg1 = (PLFLT)(val1);
10307  ecode2 = SWIG_AsVal_double(obj1, &val2);
10308  if (!SWIG_IsOK(ecode2)) {
10309  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10310  }
10311  arg2 = (PLFLT)(val2);
10312  ecode3 = SWIG_AsVal_double(obj2, &val3);
10313  if (!SWIG_IsOK(ecode3)) {
10314  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10315  }
10316  arg3 = (PLFLT)(val3);
10317  ecode4 = SWIG_AsVal_double(obj3, &val4);
10318  if (!SWIG_IsOK(ecode4)) {
10319  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10320  }
10321  arg4 = (PLFLT)(val4);
10322  ecode5 = SWIG_AsVal_double(obj4, &val5);
10323  if (!SWIG_IsOK(ecode5)) {
10324  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10325  }
10326  arg5 = (PLFLT)(val5);
10327  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10328  if (!SWIG_IsOK(res6)) {
10329  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10330  }
10331  arg6 = (char *)(buf6);
10332  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10333  resultobj = SWIG_Py_Void();
10334  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10335  return resultobj;
10336 fail:
10337  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10338  return NULL;
10339 }
10340 
10341 
10342 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10343  PyObject *resultobj = 0;
10344  PLFLT arg1 ;
10345  PLFLT arg2 ;
10346  PLFLT arg3 ;
10347  PLFLT arg4 ;
10348  PLFLT arg5 ;
10349  PLFLT arg6 ;
10350  PLFLT arg7 ;
10351  PLFLT arg8 ;
10352  PLFLT arg9 ;
10353  PLFLT arg10 ;
10354  char *arg11 = (char *) 0 ;
10355  double val1 ;
10356  int ecode1 = 0 ;
10357  double val2 ;
10358  int ecode2 = 0 ;
10359  double val3 ;
10360  int ecode3 = 0 ;
10361  double val4 ;
10362  int ecode4 = 0 ;
10363  double val5 ;
10364  int ecode5 = 0 ;
10365  double val6 ;
10366  int ecode6 = 0 ;
10367  double val7 ;
10368  int ecode7 = 0 ;
10369  double val8 ;
10370  int ecode8 = 0 ;
10371  double val9 ;
10372  int ecode9 = 0 ;
10373  double val10 ;
10374  int ecode10 = 0 ;
10375  int res11 ;
10376  char *buf11 = 0 ;
10377  int alloc11 = 0 ;
10378  PyObject * obj0 = 0 ;
10379  PyObject * obj1 = 0 ;
10380  PyObject * obj2 = 0 ;
10381  PyObject * obj3 = 0 ;
10382  PyObject * obj4 = 0 ;
10383  PyObject * obj5 = 0 ;
10384  PyObject * obj6 = 0 ;
10385  PyObject * obj7 = 0 ;
10386  PyObject * obj8 = 0 ;
10387  PyObject * obj9 = 0 ;
10388  PyObject * obj10 = 0 ;
10389 
10390  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10391  ecode1 = SWIG_AsVal_double(obj0, &val1);
10392  if (!SWIG_IsOK(ecode1)) {
10393  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10394  }
10395  arg1 = (PLFLT)(val1);
10396  ecode2 = SWIG_AsVal_double(obj1, &val2);
10397  if (!SWIG_IsOK(ecode2)) {
10398  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10399  }
10400  arg2 = (PLFLT)(val2);
10401  ecode3 = SWIG_AsVal_double(obj2, &val3);
10402  if (!SWIG_IsOK(ecode3)) {
10403  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10404  }
10405  arg3 = (PLFLT)(val3);
10406  ecode4 = SWIG_AsVal_double(obj3, &val4);
10407  if (!SWIG_IsOK(ecode4)) {
10408  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10409  }
10410  arg4 = (PLFLT)(val4);
10411  ecode5 = SWIG_AsVal_double(obj4, &val5);
10412  if (!SWIG_IsOK(ecode5)) {
10413  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10414  }
10415  arg5 = (PLFLT)(val5);
10416  ecode6 = SWIG_AsVal_double(obj5, &val6);
10417  if (!SWIG_IsOK(ecode6)) {
10418  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10419  }
10420  arg6 = (PLFLT)(val6);
10421  ecode7 = SWIG_AsVal_double(obj6, &val7);
10422  if (!SWIG_IsOK(ecode7)) {
10423  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10424  }
10425  arg7 = (PLFLT)(val7);
10426  ecode8 = SWIG_AsVal_double(obj7, &val8);
10427  if (!SWIG_IsOK(ecode8)) {
10428  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10429  }
10430  arg8 = (PLFLT)(val8);
10431  ecode9 = SWIG_AsVal_double(obj8, &val9);
10432  if (!SWIG_IsOK(ecode9)) {
10433  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10434  }
10435  arg9 = (PLFLT)(val9);
10436  ecode10 = SWIG_AsVal_double(obj9, &val10);
10437  if (!SWIG_IsOK(ecode10)) {
10438  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10439  }
10440  arg10 = (PLFLT)(val10);
10441  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10442  if (!SWIG_IsOK(res11)) {
10443  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10444  }
10445  arg11 = (char *)(buf11);
10446  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10447  resultobj = SWIG_Py_Void();
10448  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10449  return resultobj;
10450 fail:
10451  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10452  return NULL;
10453 }
10454 
10455 
10456 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457  PyObject *resultobj = 0;
10458  PLFLT result;
10459 
10460  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10461  result = (PLFLT)plrandd();
10462  resultobj = SWIG_From_double((double)(result));
10463  return resultobj;
10464 fail:
10465  return NULL;
10466 }
10467 
10468 
10469 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470  PyObject *resultobj = 0;
10471 
10472  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10473  plreplot();
10474  resultobj = SWIG_Py_Void();
10475  return resultobj;
10476 fail:
10477  return NULL;
10478 }
10479 
10480 
10481 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10482  PyObject *resultobj = 0;
10483  PLFLT arg1 ;
10484  PLFLT arg2 ;
10485  PLFLT arg3 ;
10486  PLFLT *arg4 = (PLFLT *) 0 ;
10487  PLFLT *arg5 = (PLFLT *) 0 ;
10488  PLFLT *arg6 = (PLFLT *) 0 ;
10489  double val1 ;
10490  int ecode1 = 0 ;
10491  double val2 ;
10492  int ecode2 = 0 ;
10493  double val3 ;
10494  int ecode3 = 0 ;
10495  PLFLT temp4 ;
10496  int res4 = SWIG_TMPOBJ ;
10497  PLFLT temp5 ;
10498  int res5 = SWIG_TMPOBJ ;
10499  PLFLT temp6 ;
10500  int res6 = SWIG_TMPOBJ ;
10501  PyObject * obj0 = 0 ;
10502  PyObject * obj1 = 0 ;
10503  PyObject * obj2 = 0 ;
10504 
10505  arg4 = &temp4;
10506  arg5 = &temp5;
10507  arg6 = &temp6;
10508  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10509  ecode1 = SWIG_AsVal_double(obj0, &val1);
10510  if (!SWIG_IsOK(ecode1)) {
10511  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10512  }
10513  arg1 = (PLFLT)(val1);
10514  ecode2 = SWIG_AsVal_double(obj1, &val2);
10515  if (!SWIG_IsOK(ecode2)) {
10516  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10517  }
10518  arg2 = (PLFLT)(val2);
10519  ecode3 = SWIG_AsVal_double(obj2, &val3);
10520  if (!SWIG_IsOK(ecode3)) {
10521  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10522  }
10523  arg3 = (PLFLT)(val3);
10524  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10525  resultobj = SWIG_Py_Void();
10526  if (SWIG_IsTmpObj(res4)) {
10527  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10528  } else {
10529  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10530  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10531  }
10532  if (SWIG_IsTmpObj(res5)) {
10533  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10534  } else {
10535  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10536  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10537  }
10538  if (SWIG_IsTmpObj(res6)) {
10539  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10540  } else {
10541  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10542  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10543  }
10544  return resultobj;
10545 fail:
10546  return NULL;
10547 }
10548 
10549 
10550 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10551  PyObject *resultobj = 0;
10552  PLFLT arg1 ;
10553  PLFLT arg2 ;
10554  double val1 ;
10555  int ecode1 = 0 ;
10556  double val2 ;
10557  int ecode2 = 0 ;
10558  PyObject * obj0 = 0 ;
10559  PyObject * obj1 = 0 ;
10560 
10561  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10562  ecode1 = SWIG_AsVal_double(obj0, &val1);
10563  if (!SWIG_IsOK(ecode1)) {
10564  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10565  }
10566  arg1 = (PLFLT)(val1);
10567  ecode2 = SWIG_AsVal_double(obj1, &val2);
10568  if (!SWIG_IsOK(ecode2)) {
10569  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10570  }
10571  arg2 = (PLFLT)(val2);
10572  plschr(arg1,arg2);
10573  resultobj = SWIG_Py_Void();
10574  return resultobj;
10575 fail:
10576  return NULL;
10577 }
10578 
10579 
10580 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10581  PyObject *resultobj = 0;
10582  PLINT *arg1 = (PLINT *) 0 ;
10583  PLINT *arg2 = (PLINT *) 0 ;
10584  PLINT *arg3 = (PLINT *) 0 ;
10585  PLINT arg4 ;
10586  PyArrayObject *tmp1 = NULL ;
10587  PyArrayObject *tmp2 = NULL ;
10588  PyArrayObject *tmp3 = NULL ;
10589  PyObject * obj0 = 0 ;
10590  PyObject * obj1 = 0 ;
10591  PyObject * obj2 = 0 ;
10592 
10593  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10594  {
10595  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10596  if ( tmp1 == NULL )
10597  return NULL;
10598  Alen = PyArray_DIMS( tmp1 )[0];
10599  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10600  }
10601  {
10602  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10603  if ( tmp2 == NULL )
10604  return NULL;
10605  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10606  {
10607  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10608  return NULL;
10609  }
10610  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10611  }
10612  {
10613  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10614  if ( tmp3 == NULL )
10615  return NULL;
10616  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10617  {
10618  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10619  return NULL;
10620  }
10621  arg4 = PyArray_DIMS( tmp3 )[0];
10622  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10623  }
10624  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10625  resultobj = SWIG_Py_Void();
10626  {
10627  Py_CLEAR( tmp1 );
10628  }
10629  {
10630  Py_CLEAR( tmp2 );
10631  }
10632  {
10633  Py_CLEAR( tmp3 );
10634  }
10635  return resultobj;
10636 fail:
10637  {
10638  Py_CLEAR( tmp1 );
10639  }
10640  {
10641  Py_CLEAR( tmp2 );
10642  }
10643  {
10644  Py_CLEAR( tmp3 );
10645  }
10646  return NULL;
10647 }
10648 
10649 
10650 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10651  PyObject *resultobj = 0;
10652  PLINT *arg1 = (PLINT *) 0 ;
10653  PLINT *arg2 = (PLINT *) 0 ;
10654  PLINT *arg3 = (PLINT *) 0 ;
10655  PLFLT *arg4 = (PLFLT *) 0 ;
10656  PLINT arg5 ;
10657  PyArrayObject *tmp1 = NULL ;
10658  PyArrayObject *tmp2 = NULL ;
10659  PyArrayObject *tmp3 = NULL ;
10660  PyArrayObject *tmp4 = NULL ;
10661  PyObject * obj0 = 0 ;
10662  PyObject * obj1 = 0 ;
10663  PyObject * obj2 = 0 ;
10664  PyObject * obj3 = 0 ;
10665 
10666  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10667  {
10668  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10669  if ( tmp1 == NULL )
10670  return NULL;
10671  Alen = PyArray_DIMS( tmp1 )[0];
10672  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10673  }
10674  {
10675  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10676  if ( tmp2 == NULL )
10677  return NULL;
10678  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10679  {
10680  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10681  return NULL;
10682  }
10683  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10684  }
10685  {
10686  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10687  if ( tmp3 == NULL )
10688  return NULL;
10689  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10690  {
10691  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10692  return NULL;
10693  }
10694  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10695  }
10696  {
10697  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10698  if ( tmp4 == NULL )
10699  return NULL;
10700  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10701  {
10702  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10703  return NULL;
10704  }
10705  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10706  arg5 = PyArray_DIMS( tmp4 )[0];
10707  }
10708  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10709  resultobj = SWIG_Py_Void();
10710  {
10711  Py_CLEAR( tmp1 );
10712  }
10713  {
10714  Py_CLEAR( tmp2 );
10715  }
10716  {
10717  Py_CLEAR( tmp3 );
10718  }
10719  {
10720  Py_CLEAR( tmp4 );
10721  }
10722  return resultobj;
10723 fail:
10724  {
10725  Py_CLEAR( tmp1 );
10726  }
10727  {
10728  Py_CLEAR( tmp2 );
10729  }
10730  {
10731  Py_CLEAR( tmp3 );
10732  }
10733  {
10734  Py_CLEAR( tmp4 );
10735  }
10736  return NULL;
10737 }
10738 
10739 
10740 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10741  PyObject *resultobj = 0;
10742  PLINT arg1 ;
10743  int val1 ;
10744  int ecode1 = 0 ;
10745  PyObject * obj0 = 0 ;
10746 
10747  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10748  ecode1 = SWIG_AsVal_int(obj0, &val1);
10749  if (!SWIG_IsOK(ecode1)) {
10750  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10751  }
10752  arg1 = (PLINT)(val1);
10753  plscmap0n(arg1);
10754  resultobj = SWIG_Py_Void();
10755  return resultobj;
10756 fail:
10757  return NULL;
10758 }
10759 
10760 
10761 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10762  PyObject *resultobj = 0;
10763  PLINT *arg1 = (PLINT *) 0 ;
10764  PLINT *arg2 = (PLINT *) 0 ;
10765  PLINT *arg3 = (PLINT *) 0 ;
10766  PLINT arg4 ;
10767  PyArrayObject *tmp1 = NULL ;
10768  PyArrayObject *tmp2 = NULL ;
10769  PyArrayObject *tmp3 = NULL ;
10770  PyObject * obj0 = 0 ;
10771  PyObject * obj1 = 0 ;
10772  PyObject * obj2 = 0 ;
10773 
10774  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10775  {
10776  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10777  if ( tmp1 == NULL )
10778  return NULL;
10779  Alen = PyArray_DIMS( tmp1 )[0];
10780  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10781  }
10782  {
10783  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10784  if ( tmp2 == NULL )
10785  return NULL;
10786  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10787  {
10788  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10789  return NULL;
10790  }
10791  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10792  }
10793  {
10794  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10795  if ( tmp3 == NULL )
10796  return NULL;
10797  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10798  {
10799  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10800  return NULL;
10801  }
10802  arg4 = PyArray_DIMS( tmp3 )[0];
10803  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10804  }
10805  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10806  resultobj = SWIG_Py_Void();
10807  {
10808  Py_CLEAR( tmp1 );
10809  }
10810  {
10811  Py_CLEAR( tmp2 );
10812  }
10813  {
10814  Py_CLEAR( tmp3 );
10815  }
10816  return resultobj;
10817 fail:
10818  {
10819  Py_CLEAR( tmp1 );
10820  }
10821  {
10822  Py_CLEAR( tmp2 );
10823  }
10824  {
10825  Py_CLEAR( tmp3 );
10826  }
10827  return NULL;
10828 }
10829 
10830 
10831 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832  PyObject *resultobj = 0;
10833  PLINT *arg1 = (PLINT *) 0 ;
10834  PLINT *arg2 = (PLINT *) 0 ;
10835  PLINT *arg3 = (PLINT *) 0 ;
10836  PLFLT *arg4 = (PLFLT *) 0 ;
10837  PLINT arg5 ;
10838  PyArrayObject *tmp1 = NULL ;
10839  PyArrayObject *tmp2 = NULL ;
10840  PyArrayObject *tmp3 = NULL ;
10841  PyArrayObject *tmp4 = NULL ;
10842  PyObject * obj0 = 0 ;
10843  PyObject * obj1 = 0 ;
10844  PyObject * obj2 = 0 ;
10845  PyObject * obj3 = 0 ;
10846 
10847  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10848  {
10849  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10850  if ( tmp1 == NULL )
10851  return NULL;
10852  Alen = PyArray_DIMS( tmp1 )[0];
10853  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10854  }
10855  {
10856  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10857  if ( tmp2 == NULL )
10858  return NULL;
10859  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10860  {
10861  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10862  return NULL;
10863  }
10864  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10865  }
10866  {
10867  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10868  if ( tmp3 == NULL )
10869  return NULL;
10870  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10871  {
10872  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10873  return NULL;
10874  }
10875  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10876  }
10877  {
10878  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10879  if ( tmp4 == NULL )
10880  return NULL;
10881  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10882  {
10883  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10884  return NULL;
10885  }
10886  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10887  arg5 = PyArray_DIMS( tmp4 )[0];
10888  }
10889  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10890  resultobj = SWIG_Py_Void();
10891  {
10892  Py_CLEAR( tmp1 );
10893  }
10894  {
10895  Py_CLEAR( tmp2 );
10896  }
10897  {
10898  Py_CLEAR( tmp3 );
10899  }
10900  {
10901  Py_CLEAR( tmp4 );
10902  }
10903  return resultobj;
10904 fail:
10905  {
10906  Py_CLEAR( tmp1 );
10907  }
10908  {
10909  Py_CLEAR( tmp2 );
10910  }
10911  {
10912  Py_CLEAR( tmp3 );
10913  }
10914  {
10915  Py_CLEAR( tmp4 );
10916  }
10917  return NULL;
10918 }
10919 
10920 
10921 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922  PyObject *resultobj = 0;
10923  PLBOOL arg1 ;
10924  PLINT arg2 ;
10925  PLFLT *arg3 = (PLFLT *) 0 ;
10926  PLFLT *arg4 = (PLFLT *) 0 ;
10927  PLFLT *arg5 = (PLFLT *) 0 ;
10928  PLFLT *arg6 = (PLFLT *) 0 ;
10929  PLBOOL *arg7 = (PLBOOL *) 0 ;
10930  int val1 ;
10931  int ecode1 = 0 ;
10932  PyArrayObject *tmp2 = NULL ;
10933  PyArrayObject *tmp4 = NULL ;
10934  PyArrayObject *tmp5 = NULL ;
10935  PyArrayObject *tmp6 = NULL ;
10936  PyArrayObject *tmp7 = NULL ;
10937  PyObject * obj0 = 0 ;
10938  PyObject * obj1 = 0 ;
10939  PyObject * obj2 = 0 ;
10940  PyObject * obj3 = 0 ;
10941  PyObject * obj4 = 0 ;
10942  PyObject * obj5 = 0 ;
10943 
10944  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10945  ecode1 = SWIG_AsVal_int(obj0, &val1);
10946  if (!SWIG_IsOK(ecode1)) {
10947  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10948  }
10949  arg1 = (PLBOOL)(val1);
10950  {
10951  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10952  if ( tmp2 == NULL )
10953  return NULL;
10954  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10955  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10956  }
10957  {
10958  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10959  if ( tmp4 == NULL )
10960  return NULL;
10961  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10962  {
10963  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10964  return NULL;
10965  }
10966  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10967  }
10968  {
10969  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10970  if ( tmp5 == NULL )
10971  return NULL;
10972  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10973  {
10974  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10975  return NULL;
10976  }
10977  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10978  }
10979  {
10980  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10981  if ( tmp6 == NULL )
10982  return NULL;
10983  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10984  {
10985  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10986  return NULL;
10987  }
10988  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10989  }
10990  {
10991  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10992  if ( tmp7 == NULL )
10993  return NULL;
10994  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10995  {
10996  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10997  return NULL;
10998  }
10999  arg7 = (PLINT *) PyArray_DATA( tmp7 );
11000  }
11001  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11002  resultobj = SWIG_Py_Void();
11003  {
11004  Py_CLEAR( tmp2 );
11005  }
11006  {
11007  Py_CLEAR( tmp4 );
11008  }
11009  {
11010  Py_CLEAR( tmp5 );
11011  }
11012  {
11013  Py_CLEAR( tmp6 );
11014  }
11015  {
11016  Py_CLEAR( tmp7 );
11017  }
11018  return resultobj;
11019 fail:
11020  {
11021  Py_CLEAR( tmp2 );
11022  }
11023  {
11024  Py_CLEAR( tmp4 );
11025  }
11026  {
11027  Py_CLEAR( tmp5 );
11028  }
11029  {
11030  Py_CLEAR( tmp6 );
11031  }
11032  {
11033  Py_CLEAR( tmp7 );
11034  }
11035  return NULL;
11036 }
11037 
11038 
11039 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11040  PyObject *resultobj = 0;
11041  PLBOOL arg1 ;
11042  PLINT arg2 ;
11043  PLFLT *arg3 = (PLFLT *) 0 ;
11044  PLFLT *arg4 = (PLFLT *) 0 ;
11045  PLFLT *arg5 = (PLFLT *) 0 ;
11046  PLFLT *arg6 = (PLFLT *) 0 ;
11047  PLFLT *arg7 = (PLFLT *) 0 ;
11048  PLBOOL *arg8 = (PLBOOL *) 0 ;
11049  int val1 ;
11050  int ecode1 = 0 ;
11051  PyArrayObject *tmp2 = NULL ;
11052  PyArrayObject *tmp4 = NULL ;
11053  PyArrayObject *tmp5 = NULL ;
11054  PyArrayObject *tmp6 = NULL ;
11055  PyArrayObject *tmp7 = NULL ;
11056  PyArrayObject *tmp8 = NULL ;
11057  PyObject * obj0 = 0 ;
11058  PyObject * obj1 = 0 ;
11059  PyObject * obj2 = 0 ;
11060  PyObject * obj3 = 0 ;
11061  PyObject * obj4 = 0 ;
11062  PyObject * obj5 = 0 ;
11063  PyObject * obj6 = 0 ;
11064 
11065  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11066  ecode1 = SWIG_AsVal_int(obj0, &val1);
11067  if (!SWIG_IsOK(ecode1)) {
11068  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11069  }
11070  arg1 = (PLBOOL)(val1);
11071  {
11072  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
11073  if ( tmp2 == NULL )
11074  return NULL;
11075  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11076  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11077  }
11078  {
11079  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
11080  if ( tmp4 == NULL )
11081  return NULL;
11082  if ( PyArray_DIMS( tmp4 )[0] != Alen )
11083  {
11084  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11085  return NULL;
11086  }
11087  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11088  }
11089  {
11090  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
11091  if ( tmp5 == NULL )
11092  return NULL;
11093  if ( PyArray_DIMS( tmp5 )[0] != Alen )
11094  {
11095  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11096  return NULL;
11097  }
11098  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11099  }
11100  {
11101  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
11102  if ( tmp6 == NULL )
11103  return NULL;
11104  if ( PyArray_DIMS( tmp6 )[0] != Alen )
11105  {
11106  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11107  return NULL;
11108  }
11109  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11110  }
11111  {
11112  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11113  if ( tmp7 == NULL )
11114  return NULL;
11115  if ( PyArray_DIMS( tmp7 )[0] != Alen )
11116  {
11117  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11118  return NULL;
11119  }
11120  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11121  }
11122  {
11123  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
11124  if ( tmp8 == NULL )
11125  return NULL;
11126  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11127  {
11128  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11129  return NULL;
11130  }
11131  arg8 = (PLINT *) PyArray_DATA( tmp8 );
11132  }
11133  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11134  resultobj = SWIG_Py_Void();
11135  {
11136  Py_CLEAR( tmp2 );
11137  }
11138  {
11139  Py_CLEAR( tmp4 );
11140  }
11141  {
11142  Py_CLEAR( tmp5 );
11143  }
11144  {
11145  Py_CLEAR( tmp6 );
11146  }
11147  {
11148  Py_CLEAR( tmp7 );
11149  }
11150  {
11151  Py_CLEAR( tmp8 );
11152  }
11153  return resultobj;
11154 fail:
11155  {
11156  Py_CLEAR( tmp2 );
11157  }
11158  {
11159  Py_CLEAR( tmp4 );
11160  }
11161  {
11162  Py_CLEAR( tmp5 );
11163  }
11164  {
11165  Py_CLEAR( tmp6 );
11166  }
11167  {
11168  Py_CLEAR( tmp7 );
11169  }
11170  {
11171  Py_CLEAR( tmp8 );
11172  }
11173  return NULL;
11174 }
11175 
11176 
11177 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178  PyObject *resultobj = 0;
11179  PLINT arg1 ;
11180  int val1 ;
11181  int ecode1 = 0 ;
11182  PyObject * obj0 = 0 ;
11183 
11184  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11185  ecode1 = SWIG_AsVal_int(obj0, &val1);
11186  if (!SWIG_IsOK(ecode1)) {
11187  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11188  }
11189  arg1 = (PLINT)(val1);
11190  plscmap1n(arg1);
11191  resultobj = SWIG_Py_Void();
11192  return resultobj;
11193 fail:
11194  return NULL;
11195 }
11196 
11197 
11198 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199  PyObject *resultobj = 0;
11200  PLFLT arg1 ;
11201  PLFLT arg2 ;
11202  double val1 ;
11203  int ecode1 = 0 ;
11204  double val2 ;
11205  int ecode2 = 0 ;
11206  PyObject * obj0 = 0 ;
11207  PyObject * obj1 = 0 ;
11208 
11209  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11210  ecode1 = SWIG_AsVal_double(obj0, &val1);
11211  if (!SWIG_IsOK(ecode1)) {
11212  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11213  }
11214  arg1 = (PLFLT)(val1);
11215  ecode2 = SWIG_AsVal_double(obj1, &val2);
11216  if (!SWIG_IsOK(ecode2)) {
11217  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11218  }
11219  arg2 = (PLFLT)(val2);
11220  plscmap1_range(arg1,arg2);
11221  resultobj = SWIG_Py_Void();
11222  return resultobj;
11223 fail:
11224  return NULL;
11225 }
11226 
11227 
11228 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11229  PyObject *resultobj = 0;
11230  PLFLT *arg1 = (PLFLT *) 0 ;
11231  PLFLT *arg2 = (PLFLT *) 0 ;
11232  PLFLT temp1 ;
11233  int res1 = SWIG_TMPOBJ ;
11234  PLFLT temp2 ;
11235  int res2 = SWIG_TMPOBJ ;
11236 
11237  arg1 = &temp1;
11238  arg2 = &temp2;
11239  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11240  plgcmap1_range(arg1,arg2);
11241  resultobj = SWIG_Py_Void();
11242  if (SWIG_IsTmpObj(res1)) {
11243  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11244  } else {
11245  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11246  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11247  }
11248  if (SWIG_IsTmpObj(res2)) {
11249  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11250  } else {
11251  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11252  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11253  }
11254  return resultobj;
11255 fail:
11256  return NULL;
11257 }
11258 
11259 
11260 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11261  PyObject *resultobj = 0;
11262  PLINT arg1 ;
11263  PLINT arg2 ;
11264  PLINT arg3 ;
11265  PLINT arg4 ;
11266  int val1 ;
11267  int ecode1 = 0 ;
11268  int val2 ;
11269  int ecode2 = 0 ;
11270  int val3 ;
11271  int ecode3 = 0 ;
11272  int val4 ;
11273  int ecode4 = 0 ;
11274  PyObject * obj0 = 0 ;
11275  PyObject * obj1 = 0 ;
11276  PyObject * obj2 = 0 ;
11277  PyObject * obj3 = 0 ;
11278 
11279  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11280  ecode1 = SWIG_AsVal_int(obj0, &val1);
11281  if (!SWIG_IsOK(ecode1)) {
11282  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11283  }
11284  arg1 = (PLINT)(val1);
11285  ecode2 = SWIG_AsVal_int(obj1, &val2);
11286  if (!SWIG_IsOK(ecode2)) {
11287  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11288  }
11289  arg2 = (PLINT)(val2);
11290  ecode3 = SWIG_AsVal_int(obj2, &val3);
11291  if (!SWIG_IsOK(ecode3)) {
11292  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11293  }
11294  arg3 = (PLINT)(val3);
11295  ecode4 = SWIG_AsVal_int(obj3, &val4);
11296  if (!SWIG_IsOK(ecode4)) {
11297  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11298  }
11299  arg4 = (PLINT)(val4);
11300  plscol0(arg1,arg2,arg3,arg4);
11301  resultobj = SWIG_Py_Void();
11302  return resultobj;
11303 fail:
11304  return NULL;
11305 }
11306 
11307 
11308 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11309  PyObject *resultobj = 0;
11310  PLINT arg1 ;
11311  PLINT arg2 ;
11312  PLINT arg3 ;
11313  PLINT arg4 ;
11314  PLFLT arg5 ;
11315  int val1 ;
11316  int ecode1 = 0 ;
11317  int val2 ;
11318  int ecode2 = 0 ;
11319  int val3 ;
11320  int ecode3 = 0 ;
11321  int val4 ;
11322  int ecode4 = 0 ;
11323  double val5 ;
11324  int ecode5 = 0 ;
11325  PyObject * obj0 = 0 ;
11326  PyObject * obj1 = 0 ;
11327  PyObject * obj2 = 0 ;
11328  PyObject * obj3 = 0 ;
11329  PyObject * obj4 = 0 ;
11330 
11331  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11332  ecode1 = SWIG_AsVal_int(obj0, &val1);
11333  if (!SWIG_IsOK(ecode1)) {
11334  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11335  }
11336  arg1 = (PLINT)(val1);
11337  ecode2 = SWIG_AsVal_int(obj1, &val2);
11338  if (!SWIG_IsOK(ecode2)) {
11339  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11340  }
11341  arg2 = (PLINT)(val2);
11342  ecode3 = SWIG_AsVal_int(obj2, &val3);
11343  if (!SWIG_IsOK(ecode3)) {
11344  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11345  }
11346  arg3 = (PLINT)(val3);
11347  ecode4 = SWIG_AsVal_int(obj3, &val4);
11348  if (!SWIG_IsOK(ecode4)) {
11349  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11350  }
11351  arg4 = (PLINT)(val4);
11352  ecode5 = SWIG_AsVal_double(obj4, &val5);
11353  if (!SWIG_IsOK(ecode5)) {
11354  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11355  }
11356  arg5 = (PLFLT)(val5);
11357  plscol0a(arg1,arg2,arg3,arg4,arg5);
11358  resultobj = SWIG_Py_Void();
11359  return resultobj;
11360 fail:
11361  return NULL;
11362 }
11363 
11364 
11365 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366  PyObject *resultobj = 0;
11367  PLINT arg1 ;
11368  PLINT arg2 ;
11369  PLINT arg3 ;
11370  int val1 ;
11371  int ecode1 = 0 ;
11372  int val2 ;
11373  int ecode2 = 0 ;
11374  int val3 ;
11375  int ecode3 = 0 ;
11376  PyObject * obj0 = 0 ;
11377  PyObject * obj1 = 0 ;
11378  PyObject * obj2 = 0 ;
11379 
11380  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11381  ecode1 = SWIG_AsVal_int(obj0, &val1);
11382  if (!SWIG_IsOK(ecode1)) {
11383  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11384  }
11385  arg1 = (PLINT)(val1);
11386  ecode2 = SWIG_AsVal_int(obj1, &val2);
11387  if (!SWIG_IsOK(ecode2)) {
11388  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11389  }
11390  arg2 = (PLINT)(val2);
11391  ecode3 = SWIG_AsVal_int(obj2, &val3);
11392  if (!SWIG_IsOK(ecode3)) {
11393  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11394  }
11395  arg3 = (PLINT)(val3);
11396  plscolbg(arg1,arg2,arg3);
11397  resultobj = SWIG_Py_Void();
11398  return resultobj;
11399 fail:
11400  return NULL;
11401 }
11402 
11403 
11404 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11405  PyObject *resultobj = 0;
11406  PLINT arg1 ;
11407  PLINT arg2 ;
11408  PLINT arg3 ;
11409  PLFLT arg4 ;
11410  int val1 ;
11411  int ecode1 = 0 ;
11412  int val2 ;
11413  int ecode2 = 0 ;
11414  int val3 ;
11415  int ecode3 = 0 ;
11416  double val4 ;
11417  int ecode4 = 0 ;
11418  PyObject * obj0 = 0 ;
11419  PyObject * obj1 = 0 ;
11420  PyObject * obj2 = 0 ;
11421  PyObject * obj3 = 0 ;
11422 
11423  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11424  ecode1 = SWIG_AsVal_int(obj0, &val1);
11425  if (!SWIG_IsOK(ecode1)) {
11426  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11427  }
11428  arg1 = (PLINT)(val1);
11429  ecode2 = SWIG_AsVal_int(obj1, &val2);
11430  if (!SWIG_IsOK(ecode2)) {
11431  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11432  }
11433  arg2 = (PLINT)(val2);
11434  ecode3 = SWIG_AsVal_int(obj2, &val3);
11435  if (!SWIG_IsOK(ecode3)) {
11436  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11437  }
11438  arg3 = (PLINT)(val3);
11439  ecode4 = SWIG_AsVal_double(obj3, &val4);
11440  if (!SWIG_IsOK(ecode4)) {
11441  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11442  }
11443  arg4 = (PLFLT)(val4);
11444  plscolbga(arg1,arg2,arg3,arg4);
11445  resultobj = SWIG_Py_Void();
11446  return resultobj;
11447 fail:
11448  return NULL;
11449 }
11450 
11451 
11452 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11453  PyObject *resultobj = 0;
11454  PLINT arg1 ;
11455  int val1 ;
11456  int ecode1 = 0 ;
11457  PyObject * obj0 = 0 ;
11458 
11459  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11460  ecode1 = SWIG_AsVal_int(obj0, &val1);
11461  if (!SWIG_IsOK(ecode1)) {
11462  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11463  }
11464  arg1 = (PLINT)(val1);
11465  plscolor(arg1);
11466  resultobj = SWIG_Py_Void();
11467  return resultobj;
11468 fail:
11469  return NULL;
11470 }
11471 
11472 
11473 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11474  PyObject *resultobj = 0;
11475  PLINT arg1 ;
11476  int val1 ;
11477  int ecode1 = 0 ;
11478  PyObject * obj0 = 0 ;
11479 
11480  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11481  ecode1 = SWIG_AsVal_int(obj0, &val1);
11482  if (!SWIG_IsOK(ecode1)) {
11483  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11484  }
11485  arg1 = (PLINT)(val1);
11486  plscompression(arg1);
11487  resultobj = SWIG_Py_Void();
11488  return resultobj;
11489 fail:
11490  return NULL;
11491 }
11492 
11493 
11494 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11495  PyObject *resultobj = 0;
11496  char *arg1 = (char *) 0 ;
11497  int res1 ;
11498  char *buf1 = 0 ;
11499  int alloc1 = 0 ;
11500  PyObject * obj0 = 0 ;
11501 
11502  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11503  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11504  if (!SWIG_IsOK(res1)) {
11505  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11506  }
11507  arg1 = (char *)(buf1);
11508  plsdev((char const *)arg1);
11509  resultobj = SWIG_Py_Void();
11510  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11511  return resultobj;
11512 fail:
11513  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11514  return NULL;
11515 }
11516 
11517 
11518 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11519  PyObject *resultobj = 0;
11520  PLFLT arg1 ;
11521  PLFLT arg2 ;
11522  PLFLT arg3 ;
11523  PLFLT arg4 ;
11524  double val1 ;
11525  int ecode1 = 0 ;
11526  double val2 ;
11527  int ecode2 = 0 ;
11528  double val3 ;
11529  int ecode3 = 0 ;
11530  double val4 ;
11531  int ecode4 = 0 ;
11532  PyObject * obj0 = 0 ;
11533  PyObject * obj1 = 0 ;
11534  PyObject * obj2 = 0 ;
11535  PyObject * obj3 = 0 ;
11536 
11537  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11538  ecode1 = SWIG_AsVal_double(obj0, &val1);
11539  if (!SWIG_IsOK(ecode1)) {
11540  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11541  }
11542  arg1 = (PLFLT)(val1);
11543  ecode2 = SWIG_AsVal_double(obj1, &val2);
11544  if (!SWIG_IsOK(ecode2)) {
11545  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11546  }
11547  arg2 = (PLFLT)(val2);
11548  ecode3 = SWIG_AsVal_double(obj2, &val3);
11549  if (!SWIG_IsOK(ecode3)) {
11550  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11551  }
11552  arg3 = (PLFLT)(val3);
11553  ecode4 = SWIG_AsVal_double(obj3, &val4);
11554  if (!SWIG_IsOK(ecode4)) {
11555  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11556  }
11557  arg4 = (PLFLT)(val4);
11558  plsdidev(arg1,arg2,arg3,arg4);
11559  resultobj = SWIG_Py_Void();
11560  return resultobj;
11561 fail:
11562  return NULL;
11563 }
11564 
11565 
11566 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11567  PyObject *resultobj = 0;
11568  PLINT arg1 ;
11569  PLINT arg2 ;
11570  PLINT arg3 ;
11571  PLINT arg4 ;
11572  PLFLT arg5 ;
11573  PLFLT arg6 ;
11574  int val1 ;
11575  int ecode1 = 0 ;
11576  int val2 ;
11577  int ecode2 = 0 ;
11578  int val3 ;
11579  int ecode3 = 0 ;
11580  int val4 ;
11581  int ecode4 = 0 ;
11582  double val5 ;
11583  int ecode5 = 0 ;
11584  double val6 ;
11585  int ecode6 = 0 ;
11586  PyObject * obj0 = 0 ;
11587  PyObject * obj1 = 0 ;
11588  PyObject * obj2 = 0 ;
11589  PyObject * obj3 = 0 ;
11590  PyObject * obj4 = 0 ;
11591  PyObject * obj5 = 0 ;
11592 
11593  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11594  ecode1 = SWIG_AsVal_int(obj0, &val1);
11595  if (!SWIG_IsOK(ecode1)) {
11596  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11597  }
11598  arg1 = (PLINT)(val1);
11599  ecode2 = SWIG_AsVal_int(obj1, &val2);
11600  if (!SWIG_IsOK(ecode2)) {
11601  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11602  }
11603  arg2 = (PLINT)(val2);
11604  ecode3 = SWIG_AsVal_int(obj2, &val3);
11605  if (!SWIG_IsOK(ecode3)) {
11606  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11607  }
11608  arg3 = (PLINT)(val3);
11609  ecode4 = SWIG_AsVal_int(obj3, &val4);
11610  if (!SWIG_IsOK(ecode4)) {
11611  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11612  }
11613  arg4 = (PLINT)(val4);
11614  ecode5 = SWIG_AsVal_double(obj4, &val5);
11615  if (!SWIG_IsOK(ecode5)) {
11616  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11617  }
11618  arg5 = (PLFLT)(val5);
11619  ecode6 = SWIG_AsVal_double(obj5, &val6);
11620  if (!SWIG_IsOK(ecode6)) {
11621  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11622  }
11623  arg6 = (PLFLT)(val6);
11624  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11625  resultobj = SWIG_Py_Void();
11626  return resultobj;
11627 fail:
11628  return NULL;
11629 }
11630 
11631 
11632 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11633  PyObject *resultobj = 0;
11634  PLFLT arg1 ;
11635  double val1 ;
11636  int ecode1 = 0 ;
11637  PyObject * obj0 = 0 ;
11638 
11639  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11640  ecode1 = SWIG_AsVal_double(obj0, &val1);
11641  if (!SWIG_IsOK(ecode1)) {
11642  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11643  }
11644  arg1 = (PLFLT)(val1);
11645  plsdiori(arg1);
11646  resultobj = SWIG_Py_Void();
11647  return resultobj;
11648 fail:
11649  return NULL;
11650 }
11651 
11652 
11653 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654  PyObject *resultobj = 0;
11655  PLFLT arg1 ;
11656  PLFLT arg2 ;
11657  PLFLT arg3 ;
11658  PLFLT arg4 ;
11659  double val1 ;
11660  int ecode1 = 0 ;
11661  double val2 ;
11662  int ecode2 = 0 ;
11663  double val3 ;
11664  int ecode3 = 0 ;
11665  double val4 ;
11666  int ecode4 = 0 ;
11667  PyObject * obj0 = 0 ;
11668  PyObject * obj1 = 0 ;
11669  PyObject * obj2 = 0 ;
11670  PyObject * obj3 = 0 ;
11671 
11672  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11673  ecode1 = SWIG_AsVal_double(obj0, &val1);
11674  if (!SWIG_IsOK(ecode1)) {
11675  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11676  }
11677  arg1 = (PLFLT)(val1);
11678  ecode2 = SWIG_AsVal_double(obj1, &val2);
11679  if (!SWIG_IsOK(ecode2)) {
11680  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11681  }
11682  arg2 = (PLFLT)(val2);
11683  ecode3 = SWIG_AsVal_double(obj2, &val3);
11684  if (!SWIG_IsOK(ecode3)) {
11685  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11686  }
11687  arg3 = (PLFLT)(val3);
11688  ecode4 = SWIG_AsVal_double(obj3, &val4);
11689  if (!SWIG_IsOK(ecode4)) {
11690  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11691  }
11692  arg4 = (PLFLT)(val4);
11693  plsdiplt(arg1,arg2,arg3,arg4);
11694  resultobj = SWIG_Py_Void();
11695  return resultobj;
11696 fail:
11697  return NULL;
11698 }
11699 
11700 
11701 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11702  PyObject *resultobj = 0;
11703  PLFLT arg1 ;
11704  PLFLT arg2 ;
11705  PLFLT arg3 ;
11706  PLFLT arg4 ;
11707  double val1 ;
11708  int ecode1 = 0 ;
11709  double val2 ;
11710  int ecode2 = 0 ;
11711  double val3 ;
11712  int ecode3 = 0 ;
11713  double val4 ;
11714  int ecode4 = 0 ;
11715  PyObject * obj0 = 0 ;
11716  PyObject * obj1 = 0 ;
11717  PyObject * obj2 = 0 ;
11718  PyObject * obj3 = 0 ;
11719 
11720  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11721  ecode1 = SWIG_AsVal_double(obj0, &val1);
11722  if (!SWIG_IsOK(ecode1)) {
11723  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11724  }
11725  arg1 = (PLFLT)(val1);
11726  ecode2 = SWIG_AsVal_double(obj1, &val2);
11727  if (!SWIG_IsOK(ecode2)) {
11728  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11729  }
11730  arg2 = (PLFLT)(val2);
11731  ecode3 = SWIG_AsVal_double(obj2, &val3);
11732  if (!SWIG_IsOK(ecode3)) {
11733  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11734  }
11735  arg3 = (PLFLT)(val3);
11736  ecode4 = SWIG_AsVal_double(obj3, &val4);
11737  if (!SWIG_IsOK(ecode4)) {
11738  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11739  }
11740  arg4 = (PLFLT)(val4);
11741  plsdiplz(arg1,arg2,arg3,arg4);
11742  resultobj = SWIG_Py_Void();
11743  return resultobj;
11744 fail:
11745  return NULL;
11746 }
11747 
11748 
11749 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11750  PyObject *resultobj = 0;
11751  unsigned int arg1 ;
11752  unsigned int val1 ;
11753  int ecode1 = 0 ;
11754  PyObject * obj0 = 0 ;
11755 
11756  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11757  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11758  if (!SWIG_IsOK(ecode1)) {
11759  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11760  }
11761  arg1 = (unsigned int)(val1);
11762  plseed(arg1);
11763  resultobj = SWIG_Py_Void();
11764  return resultobj;
11765 fail:
11766  return NULL;
11767 }
11768 
11769 
11770 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771  PyObject *resultobj = 0;
11772  char arg1 ;
11773  char val1 ;
11774  int ecode1 = 0 ;
11775  PyObject * obj0 = 0 ;
11776 
11777  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11778  ecode1 = SWIG_AsVal_char(obj0, &val1);
11779  if (!SWIG_IsOK(ecode1)) {
11780  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11781  }
11782  arg1 = (char)(val1);
11783  plsesc(arg1);
11784  resultobj = SWIG_Py_Void();
11785  return resultobj;
11786 fail:
11787  return NULL;
11788 }
11789 
11790 
11791 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792  PyObject *resultobj = 0;
11793  char *arg1 = (char *) 0 ;
11794  char *arg2 = (char *) 0 ;
11795  int res1 ;
11796  char *buf1 = 0 ;
11797  int alloc1 = 0 ;
11798  int res2 ;
11799  char *buf2 = 0 ;
11800  int alloc2 = 0 ;
11801  PyObject * obj0 = 0 ;
11802  PyObject * obj1 = 0 ;
11803  PLINT result;
11804 
11805  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11806  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11807  if (!SWIG_IsOK(res1)) {
11808  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11809  }
11810  arg1 = (char *)(buf1);
11811  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11812  if (!SWIG_IsOK(res2)) {
11813  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11814  }
11815  arg2 = (char *)(buf2);
11816  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11817  resultobj = SWIG_From_int((int)(result));
11818  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11819  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11820  return resultobj;
11821 fail:
11822  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11823  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11824  return NULL;
11825 }
11826 
11827 
11828 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11829  PyObject *resultobj = 0;
11830  PLINT arg1 ;
11831  PLINT arg2 ;
11832  PLINT arg3 ;
11833  int val1 ;
11834  int ecode1 = 0 ;
11835  int val2 ;
11836  int ecode2 = 0 ;
11837  int val3 ;
11838  int ecode3 = 0 ;
11839  PyObject * obj0 = 0 ;
11840  PyObject * obj1 = 0 ;
11841  PyObject * obj2 = 0 ;
11842 
11843  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11844  ecode1 = SWIG_AsVal_int(obj0, &val1);
11845  if (!SWIG_IsOK(ecode1)) {
11846  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11847  }
11848  arg1 = (PLINT)(val1);
11849  ecode2 = SWIG_AsVal_int(obj1, &val2);
11850  if (!SWIG_IsOK(ecode2)) {
11851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11852  }
11853  arg2 = (PLINT)(val2);
11854  ecode3 = SWIG_AsVal_int(obj2, &val3);
11855  if (!SWIG_IsOK(ecode3)) {
11856  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11857  }
11858  arg3 = (PLINT)(val3);
11859  plsfam(arg1,arg2,arg3);
11860  resultobj = SWIG_Py_Void();
11861  return resultobj;
11862 fail:
11863  return NULL;
11864 }
11865 
11866 
11867 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11868  PyObject *resultobj = 0;
11869  PLUNICODE arg1 ;
11870  unsigned int val1 ;
11871  int ecode1 = 0 ;
11872  PyObject * obj0 = 0 ;
11873 
11874  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11875  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11876  if (!SWIG_IsOK(ecode1)) {
11877  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11878  }
11879  arg1 = (PLUNICODE)(val1);
11880  plsfci(arg1);
11881  resultobj = SWIG_Py_Void();
11882  return resultobj;
11883 fail:
11884  return NULL;
11885 }
11886 
11887 
11888 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11889  PyObject *resultobj = 0;
11890  char *arg1 = (char *) 0 ;
11891  int res1 ;
11892  char *buf1 = 0 ;
11893  int alloc1 = 0 ;
11894  PyObject * obj0 = 0 ;
11895 
11896  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11897  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11898  if (!SWIG_IsOK(res1)) {
11899  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11900  }
11901  arg1 = (char *)(buf1);
11902  plsfnam((char const *)arg1);
11903  resultobj = SWIG_Py_Void();
11904  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11905  return resultobj;
11906 fail:
11907  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11908  return NULL;
11909 }
11910 
11911 
11912 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11913  PyObject *resultobj = 0;
11914  PLINT arg1 ;
11915  PLINT arg2 ;
11916  PLINT arg3 ;
11917  int val1 ;
11918  int ecode1 = 0 ;
11919  int val2 ;
11920  int ecode2 = 0 ;
11921  int val3 ;
11922  int ecode3 = 0 ;
11923  PyObject * obj0 = 0 ;
11924  PyObject * obj1 = 0 ;
11925  PyObject * obj2 = 0 ;
11926 
11927  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11928  ecode1 = SWIG_AsVal_int(obj0, &val1);
11929  if (!SWIG_IsOK(ecode1)) {
11930  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11931  }
11932  arg1 = (PLINT)(val1);
11933  ecode2 = SWIG_AsVal_int(obj1, &val2);
11934  if (!SWIG_IsOK(ecode2)) {
11935  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11936  }
11937  arg2 = (PLINT)(val2);
11938  ecode3 = SWIG_AsVal_int(obj2, &val3);
11939  if (!SWIG_IsOK(ecode3)) {
11940  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11941  }
11942  arg3 = (PLINT)(val3);
11943  plsfont(arg1,arg2,arg3);
11944  resultobj = SWIG_Py_Void();
11945  return resultobj;
11946 fail:
11947  return NULL;
11948 }
11949 
11950 
11951 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952  PyObject *resultobj = 0;
11953  PLFLT **arg1 = (PLFLT **) 0 ;
11954  PLINT arg2 ;
11955  PLINT arg3 ;
11956  defined_func arg4 = (defined_func) 0 ;
11957  PLFLT arg5 ;
11958  PLFLT arg6 ;
11959  PLFLT arg7 ;
11960  PLFLT arg8 ;
11961  PLFLT *arg9 = (PLFLT *) 0 ;
11962  PLINT arg10 ;
11963  PLFLT arg11 ;
11964  PLINT arg12 ;
11965  PLFLT arg13 ;
11966  fill_func arg14 = (fill_func) 0 ;
11967  PLBOOL arg15 ;
11968  pltr_func arg16 = (pltr_func) 0 ;
11969  PLPointer arg17 = (PLPointer) 0 ;
11970  PyArrayObject *tmp1 = NULL ;
11971  double val5 ;
11972  int ecode5 = 0 ;
11973  double val6 ;
11974  int ecode6 = 0 ;
11975  double val7 ;
11976  int ecode7 = 0 ;
11977  double val8 ;
11978  int ecode8 = 0 ;
11979  PyArrayObject *tmp9 = NULL ;
11980  double val11 ;
11981  int ecode11 = 0 ;
11982  int val12 ;
11983  int ecode12 = 0 ;
11984  double val13 ;
11985  int ecode13 = 0 ;
11986  int val15 ;
11987  int ecode15 = 0 ;
11988  PyObject * obj0 = 0 ;
11989  PyObject * obj1 = 0 ;
11990  PyObject * obj2 = 0 ;
11991  PyObject * obj3 = 0 ;
11992  PyObject * obj4 = 0 ;
11993  PyObject * obj5 = 0 ;
11994  PyObject * obj6 = 0 ;
11995  PyObject * obj7 = 0 ;
11996  PyObject * obj8 = 0 ;
11997  PyObject * obj9 = 0 ;
11998  PyObject * obj10 = 0 ;
11999  PyObject * obj11 = 0 ;
12000 
12001  {
12002  python_pltr = 0;
12003  arg16 = NULL;
12004  }
12005  {
12006  arg17 = NULL;
12007  }
12008  {
12009  arg4 = NULL;
12010  }
12011  {
12012  arg14 = plfill;
12013  }
12014  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
12015  {
12016  int i, size;
12017  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12018  if ( tmp1 == NULL )
12019  return NULL;
12020  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12021  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12022  size = arg3;
12023  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12024  for ( i = 0; i < arg2; i++ )
12025  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12026  }
12027  ecode5 = SWIG_AsVal_double(obj1, &val5);
12028  if (!SWIG_IsOK(ecode5)) {
12029  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12030  }
12031  arg5 = (PLFLT)(val5);
12032  ecode6 = SWIG_AsVal_double(obj2, &val6);
12033  if (!SWIG_IsOK(ecode6)) {
12034  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12035  }
12036  arg6 = (PLFLT)(val6);
12037  ecode7 = SWIG_AsVal_double(obj3, &val7);
12038  if (!SWIG_IsOK(ecode7)) {
12039  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12040  }
12041  arg7 = (PLFLT)(val7);
12042  ecode8 = SWIG_AsVal_double(obj4, &val8);
12043  if (!SWIG_IsOK(ecode8)) {
12044  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12045  }
12046  arg8 = (PLFLT)(val8);
12047  {
12048  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
12049  if ( tmp9 == NULL )
12050  return NULL;
12051  arg10 = PyArray_DIMS( tmp9 )[0];
12052  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12053  }
12054  ecode11 = SWIG_AsVal_double(obj6, &val11);
12055  if (!SWIG_IsOK(ecode11)) {
12056  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12057  }
12058  arg11 = (PLFLT)(val11);
12059  ecode12 = SWIG_AsVal_int(obj7, &val12);
12060  if (!SWIG_IsOK(ecode12)) {
12061  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12062  }
12063  arg12 = (PLINT)(val12);
12064  ecode13 = SWIG_AsVal_double(obj8, &val13);
12065  if (!SWIG_IsOK(ecode13)) {
12066  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12067  }
12068  arg13 = (PLFLT)(val13);
12069  ecode15 = SWIG_AsVal_int(obj9, &val15);
12070  if (!SWIG_IsOK(ecode15)) {
12071  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12072  }
12073  arg15 = (PLBOOL)(val15);
12074  if (obj10) {
12075  {
12076  // it must be a callable or None
12077  if ( obj10 == Py_None )
12078  {
12079  arg16 = NULL;
12080  }
12081  else
12082  {
12083  if ( !PyCallable_Check( (PyObject *) obj10 ) )
12084  {
12085  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12086  return NULL;
12087  }
12088  arg16 = marshal_pltr( obj10 );
12089  }
12090  }
12091  }
12092  if (obj11) {
12093  {
12094  if ( obj11 == Py_None )
12095  arg17 = NULL;
12096  else
12097  {
12098  arg17 = marshal_PLPointer( obj11, 0 );
12099  }
12100  }
12101  }
12102  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12103  resultobj = SWIG_Py_Void();
12104  {
12105  Py_CLEAR( tmp1 );
12106  free( arg1 );
12107  }
12108  {
12109  Py_CLEAR( tmp9 );
12110  }
12111  {
12112  cleanup_pltr();
12113  }
12114  {
12116  }
12117  return resultobj;
12118 fail:
12119  {
12120  Py_CLEAR( tmp1 );
12121  free( arg1 );
12122  }
12123  {
12124  Py_CLEAR( tmp9 );
12125  }
12126  {
12127  cleanup_pltr();
12128  }
12129  {
12131  }
12132  return NULL;
12133 }
12134 
12135 
12136 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12137  PyObject *resultobj = 0;
12138  PLFLT **arg1 = (PLFLT **) 0 ;
12139  PLINT arg2 ;
12140  PLINT arg3 ;
12141  defined_func arg4 = (defined_func) 0 ;
12142  PLFLT arg5 ;
12143  PLFLT arg6 ;
12144  PLFLT arg7 ;
12145  PLFLT arg8 ;
12146  PLFLT arg9 ;
12147  PLFLT arg10 ;
12148  PLINT arg11 ;
12149  PLFLT arg12 ;
12150  PLFLT arg13 ;
12151  PLINT arg14 ;
12152  PLFLT arg15 ;
12153  PLINT arg16 ;
12154  PLFLT arg17 ;
12155  fill_func arg18 = (fill_func) 0 ;
12156  PLBOOL arg19 ;
12157  pltr_func arg20 = (pltr_func) 0 ;
12158  PLPointer arg21 = (PLPointer) 0 ;
12159  PyArrayObject *tmp1 = NULL ;
12160  double val5 ;
12161  int ecode5 = 0 ;
12162  double val6 ;
12163  int ecode6 = 0 ;
12164  double val7 ;
12165  int ecode7 = 0 ;
12166  double val8 ;
12167  int ecode8 = 0 ;
12168  double val9 ;
12169  int ecode9 = 0 ;
12170  double val10 ;
12171  int ecode10 = 0 ;
12172  int val11 ;
12173  int ecode11 = 0 ;
12174  double val12 ;
12175  int ecode12 = 0 ;
12176  double val13 ;
12177  int ecode13 = 0 ;
12178  int val14 ;
12179  int ecode14 = 0 ;
12180  double val15 ;
12181  int ecode15 = 0 ;
12182  int val16 ;
12183  int ecode16 = 0 ;
12184  double val17 ;
12185  int ecode17 = 0 ;
12186  int val19 ;
12187  int ecode19 = 0 ;
12188  PyObject * obj0 = 0 ;
12189  PyObject * obj1 = 0 ;
12190  PyObject * obj2 = 0 ;
12191  PyObject * obj3 = 0 ;
12192  PyObject * obj4 = 0 ;
12193  PyObject * obj5 = 0 ;
12194  PyObject * obj6 = 0 ;
12195  PyObject * obj7 = 0 ;
12196  PyObject * obj8 = 0 ;
12197  PyObject * obj9 = 0 ;
12198  PyObject * obj10 = 0 ;
12199  PyObject * obj11 = 0 ;
12200  PyObject * obj12 = 0 ;
12201  PyObject * obj13 = 0 ;
12202  PyObject * obj14 = 0 ;
12203  PyObject * obj15 = 0 ;
12204  PyObject * obj16 = 0 ;
12205 
12206  {
12207  python_pltr = 0;
12208  arg20 = NULL;
12209  }
12210  {
12211  arg21 = NULL;
12212  }
12213  {
12214  arg4 = NULL;
12215  }
12216  {
12217  arg18 = plfill;
12218  }
12219  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;
12220  {
12221  int i, size;
12222  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12223  if ( tmp1 == NULL )
12224  return NULL;
12225  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12226  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12227  size = arg3;
12228  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12229  for ( i = 0; i < arg2; i++ )
12230  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12231  }
12232  ecode5 = SWIG_AsVal_double(obj1, &val5);
12233  if (!SWIG_IsOK(ecode5)) {
12234  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12235  }
12236  arg5 = (PLFLT)(val5);
12237  ecode6 = SWIG_AsVal_double(obj2, &val6);
12238  if (!SWIG_IsOK(ecode6)) {
12239  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12240  }
12241  arg6 = (PLFLT)(val6);
12242  ecode7 = SWIG_AsVal_double(obj3, &val7);
12243  if (!SWIG_IsOK(ecode7)) {
12244  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12245  }
12246  arg7 = (PLFLT)(val7);
12247  ecode8 = SWIG_AsVal_double(obj4, &val8);
12248  if (!SWIG_IsOK(ecode8)) {
12249  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12250  }
12251  arg8 = (PLFLT)(val8);
12252  ecode9 = SWIG_AsVal_double(obj5, &val9);
12253  if (!SWIG_IsOK(ecode9)) {
12254  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12255  }
12256  arg9 = (PLFLT)(val9);
12257  ecode10 = SWIG_AsVal_double(obj6, &val10);
12258  if (!SWIG_IsOK(ecode10)) {
12259  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12260  }
12261  arg10 = (PLFLT)(val10);
12262  ecode11 = SWIG_AsVal_int(obj7, &val11);
12263  if (!SWIG_IsOK(ecode11)) {
12264  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12265  }
12266  arg11 = (PLINT)(val11);
12267  ecode12 = SWIG_AsVal_double(obj8, &val12);
12268  if (!SWIG_IsOK(ecode12)) {
12269  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12270  }
12271  arg12 = (PLFLT)(val12);
12272  ecode13 = SWIG_AsVal_double(obj9, &val13);
12273  if (!SWIG_IsOK(ecode13)) {
12274  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12275  }
12276  arg13 = (PLFLT)(val13);
12277  ecode14 = SWIG_AsVal_int(obj10, &val14);
12278  if (!SWIG_IsOK(ecode14)) {
12279  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12280  }
12281  arg14 = (PLINT)(val14);
12282  ecode15 = SWIG_AsVal_double(obj11, &val15);
12283  if (!SWIG_IsOK(ecode15)) {
12284  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12285  }
12286  arg15 = (PLFLT)(val15);
12287  ecode16 = SWIG_AsVal_int(obj12, &val16);
12288  if (!SWIG_IsOK(ecode16)) {
12289  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12290  }
12291  arg16 = (PLINT)(val16);
12292  ecode17 = SWIG_AsVal_double(obj13, &val17);
12293  if (!SWIG_IsOK(ecode17)) {
12294  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12295  }
12296  arg17 = (PLFLT)(val17);
12297  ecode19 = SWIG_AsVal_int(obj14, &val19);
12298  if (!SWIG_IsOK(ecode19)) {
12299  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12300  }
12301  arg19 = (PLBOOL)(val19);
12302  if (obj15) {
12303  {
12304  // it must be a callable or None
12305  if ( obj15 == Py_None )
12306  {
12307  arg20 = NULL;
12308  }
12309  else
12310  {
12311  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12312  {
12313  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12314  return NULL;
12315  }
12316  arg20 = marshal_pltr( obj15 );
12317  }
12318  }
12319  }
12320  if (obj16) {
12321  {
12322  if ( obj16 == Py_None )
12323  arg21 = NULL;
12324  else
12325  {
12326  arg21 = marshal_PLPointer( obj16, 0 );
12327  }
12328  }
12329  }
12330  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12331  resultobj = SWIG_Py_Void();
12332  {
12333  Py_CLEAR( tmp1 );
12334  free( arg1 );
12335  }
12336  {
12337  cleanup_pltr();
12338  }
12339  {
12341  }
12342  return resultobj;
12343 fail:
12344  {
12345  Py_CLEAR( tmp1 );
12346  free( arg1 );
12347  }
12348  {
12349  cleanup_pltr();
12350  }
12351  {
12353  }
12354  return NULL;
12355 }
12356 
12357 
12358 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12359  PyObject *resultobj = 0;
12360  label_func arg1 = (label_func) 0 ;
12361  PLPointer arg2 = (PLPointer) 0 ;
12362  int res2 ;
12363  PyObject * obj0 = 0 ;
12364  PyObject * obj1 = 0 ;
12365 
12366  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12367  {
12368  // Release reference to previous function if applicable
12369  if ( python_label )
12370  {
12371  Py_CLEAR( python_label );
12372  python_label = 0;
12373  }
12374  // it must be a callable or None
12375  if ( obj0 == Py_None )
12376  {
12377  arg1 = NULL;
12378  }
12379  else
12380  {
12381  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12382  {
12383  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12384  return NULL;
12385  }
12386  // hold a reference to it
12387  Py_XINCREF( (PyObject *) obj0 );
12388  python_label = (PyObject *) obj0;
12389  // this function handles calling the python function
12390  arg1 = do_label_callback;
12391  }
12392  }
12393  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12394  if (!SWIG_IsOK(res2)) {
12395  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12396  }
12397  plslabelfunc(arg1,arg2);
12398  resultobj = SWIG_Py_Void();
12399  return resultobj;
12400 fail:
12401  return NULL;
12402 }
12403 
12404 
12405 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406  PyObject *resultobj = 0;
12407  PLFLT arg1 ;
12408  PLFLT arg2 ;
12409  double val1 ;
12410  int ecode1 = 0 ;
12411  double val2 ;
12412  int ecode2 = 0 ;
12413  PyObject * obj0 = 0 ;
12414  PyObject * obj1 = 0 ;
12415 
12416  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12417  ecode1 = SWIG_AsVal_double(obj0, &val1);
12418  if (!SWIG_IsOK(ecode1)) {
12419  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12420  }
12421  arg1 = (PLFLT)(val1);
12422  ecode2 = SWIG_AsVal_double(obj1, &val2);
12423  if (!SWIG_IsOK(ecode2)) {
12424  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12425  }
12426  arg2 = (PLFLT)(val2);
12427  plsmaj(arg1,arg2);
12428  resultobj = SWIG_Py_Void();
12429  return resultobj;
12430 fail:
12431  return NULL;
12432 }
12433 
12434 
12435 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12436  PyObject *resultobj = 0;
12437  PLINT arg1 ;
12438  PLINT arg2 ;
12439  void *arg3 = (void *) 0 ;
12440  int val1 ;
12441  int ecode1 = 0 ;
12442  int val2 ;
12443  int ecode2 = 0 ;
12444  int res3 ;
12445  Py_ssize_t size3 = 0 ;
12446  void *buf3 = 0 ;
12447  PyObject * obj0 = 0 ;
12448  PyObject * obj1 = 0 ;
12449  PyObject * obj2 = 0 ;
12450 
12451  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12452  ecode1 = SWIG_AsVal_int(obj0, &val1);
12453  if (!SWIG_IsOK(ecode1)) {
12454  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12455  }
12456  arg1 = (PLINT)(val1);
12457  ecode2 = SWIG_AsVal_int(obj1, &val2);
12458  if (!SWIG_IsOK(ecode2)) {
12459  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12460  }
12461  arg2 = (PLINT)(val2);
12462  {
12463  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12464  if (res3<0) {
12465  PyErr_Clear();
12466  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12467  }
12468  arg3 = (void *) buf3;
12469  }
12470  plsmem(arg1,arg2,arg3);
12471  resultobj = SWIG_Py_Void();
12472  return resultobj;
12473 fail:
12474  return NULL;
12475 }
12476 
12477 
12478 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12479  PyObject *resultobj = 0;
12480  PLINT arg1 ;
12481  PLINT arg2 ;
12482  void *arg3 = (void *) 0 ;
12483  int val1 ;
12484  int ecode1 = 0 ;
12485  int val2 ;
12486  int ecode2 = 0 ;
12487  int res3 ;
12488  Py_ssize_t size3 = 0 ;
12489  void *buf3 = 0 ;
12490  PyObject * obj0 = 0 ;
12491  PyObject * obj1 = 0 ;
12492  PyObject * obj2 = 0 ;
12493 
12494  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12495  ecode1 = SWIG_AsVal_int(obj0, &val1);
12496  if (!SWIG_IsOK(ecode1)) {
12497  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12498  }
12499  arg1 = (PLINT)(val1);
12500  ecode2 = SWIG_AsVal_int(obj1, &val2);
12501  if (!SWIG_IsOK(ecode2)) {
12502  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12503  }
12504  arg2 = (PLINT)(val2);
12505  {
12506  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12507  if (res3<0) {
12508  PyErr_Clear();
12509  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12510  }
12511  arg3 = (void *) buf3;
12512  }
12513  plsmema(arg1,arg2,arg3);
12514  resultobj = SWIG_Py_Void();
12515  return resultobj;
12516 fail:
12517  return NULL;
12518 }
12519 
12520 
12521 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12522  PyObject *resultobj = 0;
12523  PLFLT arg1 ;
12524  PLFLT arg2 ;
12525  double val1 ;
12526  int ecode1 = 0 ;
12527  double val2 ;
12528  int ecode2 = 0 ;
12529  PyObject * obj0 = 0 ;
12530  PyObject * obj1 = 0 ;
12531 
12532  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12533  ecode1 = SWIG_AsVal_double(obj0, &val1);
12534  if (!SWIG_IsOK(ecode1)) {
12535  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12536  }
12537  arg1 = (PLFLT)(val1);
12538  ecode2 = SWIG_AsVal_double(obj1, &val2);
12539  if (!SWIG_IsOK(ecode2)) {
12540  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12541  }
12542  arg2 = (PLFLT)(val2);
12543  plsmin(arg1,arg2);
12544  resultobj = SWIG_Py_Void();
12545  return resultobj;
12546 fail:
12547  return NULL;
12548 }
12549 
12550 
12551 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552  PyObject *resultobj = 0;
12553  PLINT arg1 ;
12554  int val1 ;
12555  int ecode1 = 0 ;
12556  PyObject * obj0 = 0 ;
12557 
12558  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12559  ecode1 = SWIG_AsVal_int(obj0, &val1);
12560  if (!SWIG_IsOK(ecode1)) {
12561  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12562  }
12563  arg1 = (PLINT)(val1);
12564  plsori(arg1);
12565  resultobj = SWIG_Py_Void();
12566  return resultobj;
12567 fail:
12568  return NULL;
12569 }
12570 
12571 
12572 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573  PyObject *resultobj = 0;
12574  PLFLT arg1 ;
12575  PLFLT arg2 ;
12576  PLINT arg3 ;
12577  PLINT arg4 ;
12578  PLINT arg5 ;
12579  PLINT arg6 ;
12580  double val1 ;
12581  int ecode1 = 0 ;
12582  double val2 ;
12583  int ecode2 = 0 ;
12584  int val3 ;
12585  int ecode3 = 0 ;
12586  int val4 ;
12587  int ecode4 = 0 ;
12588  int val5 ;
12589  int ecode5 = 0 ;
12590  int val6 ;
12591  int ecode6 = 0 ;
12592  PyObject * obj0 = 0 ;
12593  PyObject * obj1 = 0 ;
12594  PyObject * obj2 = 0 ;
12595  PyObject * obj3 = 0 ;
12596  PyObject * obj4 = 0 ;
12597  PyObject * obj5 = 0 ;
12598 
12599  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12600  ecode1 = SWIG_AsVal_double(obj0, &val1);
12601  if (!SWIG_IsOK(ecode1)) {
12602  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12603  }
12604  arg1 = (PLFLT)(val1);
12605  ecode2 = SWIG_AsVal_double(obj1, &val2);
12606  if (!SWIG_IsOK(ecode2)) {
12607  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12608  }
12609  arg2 = (PLFLT)(val2);
12610  ecode3 = SWIG_AsVal_int(obj2, &val3);
12611  if (!SWIG_IsOK(ecode3)) {
12612  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12613  }
12614  arg3 = (PLINT)(val3);
12615  ecode4 = SWIG_AsVal_int(obj3, &val4);
12616  if (!SWIG_IsOK(ecode4)) {
12617  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12618  }
12619  arg4 = (PLINT)(val4);
12620  ecode5 = SWIG_AsVal_int(obj4, &val5);
12621  if (!SWIG_IsOK(ecode5)) {
12622  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12623  }
12624  arg5 = (PLINT)(val5);
12625  ecode6 = SWIG_AsVal_int(obj5, &val6);
12626  if (!SWIG_IsOK(ecode6)) {
12627  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12628  }
12629  arg6 = (PLINT)(val6);
12630  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12631  resultobj = SWIG_Py_Void();
12632  return resultobj;
12633 fail:
12634  return NULL;
12635 }
12636 
12637 
12638 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12639  PyObject *resultobj = 0;
12640  char *arg1 = (char *) 0 ;
12641  int res1 ;
12642  char *buf1 = 0 ;
12643  int alloc1 = 0 ;
12644  PyObject * obj0 = 0 ;
12645 
12646  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12647  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12648  if (!SWIG_IsOK(res1)) {
12649  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12650  }
12651  arg1 = (char *)(buf1);
12652  plspal0((char const *)arg1);
12653  resultobj = SWIG_Py_Void();
12654  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12655  return resultobj;
12656 fail:
12657  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12658  return NULL;
12659 }
12660 
12661 
12662 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12663  PyObject *resultobj = 0;
12664  char *arg1 = (char *) 0 ;
12665  PLBOOL arg2 ;
12666  int res1 ;
12667  char *buf1 = 0 ;
12668  int alloc1 = 0 ;
12669  int val2 ;
12670  int ecode2 = 0 ;
12671  PyObject * obj0 = 0 ;
12672  PyObject * obj1 = 0 ;
12673 
12674  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12675  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12676  if (!SWIG_IsOK(res1)) {
12677  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12678  }
12679  arg1 = (char *)(buf1);
12680  ecode2 = SWIG_AsVal_int(obj1, &val2);
12681  if (!SWIG_IsOK(ecode2)) {
12682  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12683  }
12684  arg2 = (PLBOOL)(val2);
12685  plspal1((char const *)arg1,arg2);
12686  resultobj = SWIG_Py_Void();
12687  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12688  return resultobj;
12689 fail:
12690  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12691  return NULL;
12692 }
12693 
12694 
12695 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12696  PyObject *resultobj = 0;
12697  PLBOOL arg1 ;
12698  int val1 ;
12699  int ecode1 = 0 ;
12700  PyObject * obj0 = 0 ;
12701 
12702  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12703  ecode1 = SWIG_AsVal_int(obj0, &val1);
12704  if (!SWIG_IsOK(ecode1)) {
12705  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12706  }
12707  arg1 = (PLBOOL)(val1);
12708  plspause(arg1);
12709  resultobj = SWIG_Py_Void();
12710  return resultobj;
12711 fail:
12712  return NULL;
12713 }
12714 
12715 
12716 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717  PyObject *resultobj = 0;
12718  PLINT arg1 ;
12719  int val1 ;
12720  int ecode1 = 0 ;
12721  PyObject * obj0 = 0 ;
12722 
12723  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12724  ecode1 = SWIG_AsVal_int(obj0, &val1);
12725  if (!SWIG_IsOK(ecode1)) {
12726  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12727  }
12728  arg1 = (PLINT)(val1);
12729  plsstrm(arg1);
12730  resultobj = SWIG_Py_Void();
12731  return resultobj;
12732 fail:
12733  return NULL;
12734 }
12735 
12736 
12737 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738  PyObject *resultobj = 0;
12739  PLINT arg1 ;
12740  PLINT arg2 ;
12741  int val1 ;
12742  int ecode1 = 0 ;
12743  int val2 ;
12744  int ecode2 = 0 ;
12745  PyObject * obj0 = 0 ;
12746  PyObject * obj1 = 0 ;
12747 
12748  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12749  ecode1 = SWIG_AsVal_int(obj0, &val1);
12750  if (!SWIG_IsOK(ecode1)) {
12751  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12752  }
12753  arg1 = (PLINT)(val1);
12754  ecode2 = SWIG_AsVal_int(obj1, &val2);
12755  if (!SWIG_IsOK(ecode2)) {
12756  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12757  }
12758  arg2 = (PLINT)(val2);
12759  plssub(arg1,arg2);
12760  resultobj = SWIG_Py_Void();
12761  return resultobj;
12762 fail:
12763  return NULL;
12764 }
12765 
12766 
12767 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768  PyObject *resultobj = 0;
12769  PLFLT arg1 ;
12770  PLFLT arg2 ;
12771  double val1 ;
12772  int ecode1 = 0 ;
12773  double val2 ;
12774  int ecode2 = 0 ;
12775  PyObject * obj0 = 0 ;
12776  PyObject * obj1 = 0 ;
12777 
12778  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12779  ecode1 = SWIG_AsVal_double(obj0, &val1);
12780  if (!SWIG_IsOK(ecode1)) {
12781  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12782  }
12783  arg1 = (PLFLT)(val1);
12784  ecode2 = SWIG_AsVal_double(obj1, &val2);
12785  if (!SWIG_IsOK(ecode2)) {
12786  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12787  }
12788  arg2 = (PLFLT)(val2);
12789  plssym(arg1,arg2);
12790  resultobj = SWIG_Py_Void();
12791  return resultobj;
12792 fail:
12793  return NULL;
12794 }
12795 
12796 
12797 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798  PyObject *resultobj = 0;
12799  PLINT arg1 ;
12800  PLINT arg2 ;
12801  int val1 ;
12802  int ecode1 = 0 ;
12803  int val2 ;
12804  int ecode2 = 0 ;
12805  PyObject * obj0 = 0 ;
12806  PyObject * obj1 = 0 ;
12807 
12808  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12809  ecode1 = SWIG_AsVal_int(obj0, &val1);
12810  if (!SWIG_IsOK(ecode1)) {
12811  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12812  }
12813  arg1 = (PLINT)(val1);
12814  ecode2 = SWIG_AsVal_int(obj1, &val2);
12815  if (!SWIG_IsOK(ecode2)) {
12816  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12817  }
12818  arg2 = (PLINT)(val2);
12819  plstar(arg1,arg2);
12820  resultobj = SWIG_Py_Void();
12821  return resultobj;
12822 fail:
12823  return NULL;
12824 }
12825 
12826 
12827 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828  PyObject *resultobj = 0;
12829  char *arg1 = (char *) 0 ;
12830  PLINT arg2 ;
12831  PLINT arg3 ;
12832  int res1 ;
12833  char *buf1 = 0 ;
12834  int alloc1 = 0 ;
12835  int val2 ;
12836  int ecode2 = 0 ;
12837  int val3 ;
12838  int ecode3 = 0 ;
12839  PyObject * obj0 = 0 ;
12840  PyObject * obj1 = 0 ;
12841  PyObject * obj2 = 0 ;
12842 
12843  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12844  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12845  if (!SWIG_IsOK(res1)) {
12846  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12847  }
12848  arg1 = (char *)(buf1);
12849  ecode2 = SWIG_AsVal_int(obj1, &val2);
12850  if (!SWIG_IsOK(ecode2)) {
12851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12852  }
12853  arg2 = (PLINT)(val2);
12854  ecode3 = SWIG_AsVal_int(obj2, &val3);
12855  if (!SWIG_IsOK(ecode3)) {
12856  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12857  }
12858  arg3 = (PLINT)(val3);
12859  plstart((char const *)arg1,arg2,arg3);
12860  resultobj = SWIG_Py_Void();
12861  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12862  return resultobj;
12863 fail:
12864  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12865  return NULL;
12866 }
12867 
12868 
12869 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870  PyObject *resultobj = 0;
12871  ct_func arg1 = (ct_func) 0 ;
12872  PLPointer arg2 = (PLPointer) 0 ;
12873  int res2 ;
12874  PyObject * obj0 = 0 ;
12875  PyObject * obj1 = 0 ;
12876 
12877  {
12878  python_ct = 0;
12879  arg1 = NULL;
12880  }
12881  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12882  if (obj0) {
12883  {
12884  if ( python_ct )
12885  cleanup_ct();
12886  // it must be a callable or none
12887  if ( obj0 == Py_None )
12888  {
12889  arg1 = NULL;
12890  }
12891  else
12892  {
12893  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12894  {
12895  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12896  return NULL;
12897  }
12898  arg1 = marshal_ct( obj0 );
12899  }
12900  }
12901  }
12902  if (obj1) {
12903  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12904  if (!SWIG_IsOK(res2)) {
12905  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12906  }
12907  }
12908  plstransform(arg1,arg2);
12909  resultobj = SWIG_Py_Void();
12910  return resultobj;
12911 fail:
12912  return NULL;
12913 }
12914 
12915 
12916 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917  PyObject *resultobj = 0;
12918  PLINT arg1 ;
12919  PLFLT *arg2 = (PLFLT *) 0 ;
12920  PLFLT *arg3 = (PLFLT *) 0 ;
12921  char *arg4 = (char *) 0 ;
12922  PyArrayObject *tmp1 = NULL ;
12923  PyArrayObject *tmp3 = NULL ;
12924  int res4 ;
12925  char *buf4 = 0 ;
12926  int alloc4 = 0 ;
12927  PyObject * obj0 = 0 ;
12928  PyObject * obj1 = 0 ;
12929  PyObject * obj2 = 0 ;
12930 
12931  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12932  {
12933  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12934  if ( tmp1 == NULL )
12935  return NULL;
12936  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12937  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12938  }
12939  {
12940  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12941  if ( tmp3 == NULL )
12942  return NULL;
12943  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12944  {
12945  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12946  return NULL;
12947  }
12948  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12949  }
12950  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12951  if (!SWIG_IsOK(res4)) {
12952  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12953  }
12954  arg4 = (char *)(buf4);
12955  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12956  resultobj = SWIG_Py_Void();
12957  {
12958  Py_CLEAR( tmp1 );
12959  }
12960  {
12961  Py_CLEAR( tmp3 );
12962  }
12963  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12964  return resultobj;
12965 fail:
12966  {
12967  Py_CLEAR( tmp1 );
12968  }
12969  {
12970  Py_CLEAR( tmp3 );
12971  }
12972  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12973  return NULL;
12974 }
12975 
12976 
12977 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978  PyObject *resultobj = 0;
12979  PLINT arg1 ;
12980  PLFLT *arg2 = (PLFLT *) 0 ;
12981  PLFLT *arg3 = (PLFLT *) 0 ;
12982  PLFLT *arg4 = (PLFLT *) 0 ;
12983  char *arg5 = (char *) 0 ;
12984  PyArrayObject *tmp1 = NULL ;
12985  PyArrayObject *tmp3 = NULL ;
12986  PyArrayObject *tmp4 = NULL ;
12987  int res5 ;
12988  char *buf5 = 0 ;
12989  int alloc5 = 0 ;
12990  PyObject * obj0 = 0 ;
12991  PyObject * obj1 = 0 ;
12992  PyObject * obj2 = 0 ;
12993  PyObject * obj3 = 0 ;
12994 
12995  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12996  {
12997  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12998  if ( tmp1 == NULL )
12999  return NULL;
13000  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13001  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13002  }
13003  {
13004  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13005  if ( tmp3 == NULL )
13006  return NULL;
13007  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13008  {
13009  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13010  return NULL;
13011  }
13012  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13013  }
13014  {
13015  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
13016  if ( tmp4 == NULL )
13017  return NULL;
13018  if ( PyArray_DIMS( tmp4 )[0] != Alen )
13019  {
13020  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13021  return NULL;
13022  }
13023  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13024  }
13025  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
13026  if (!SWIG_IsOK(res5)) {
13027  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13028  }
13029  arg5 = (char *)(buf5);
13030  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13031  resultobj = SWIG_Py_Void();
13032  {
13033  Py_CLEAR( tmp1 );
13034  }
13035  {
13036  Py_CLEAR( tmp3 );
13037  }
13038  {
13039  Py_CLEAR( tmp4 );
13040  }
13041  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13042  return resultobj;
13043 fail:
13044  {
13045  Py_CLEAR( tmp1 );
13046  }
13047  {
13048  Py_CLEAR( tmp3 );
13049  }
13050  {
13051  Py_CLEAR( tmp4 );
13052  }
13053  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13054  return NULL;
13055 }
13056 
13057 
13058 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13059  PyObject *resultobj = 0;
13060  PLINT arg1 ;
13061  PLINT arg2 ;
13062  PLFLT arg3 ;
13063  PLFLT arg4 ;
13064  int val1 ;
13065  int ecode1 = 0 ;
13066  int val2 ;
13067  int ecode2 = 0 ;
13068  double val3 ;
13069  int ecode3 = 0 ;
13070  double val4 ;
13071  int ecode4 = 0 ;
13072  PyObject * obj0 = 0 ;
13073  PyObject * obj1 = 0 ;
13074  PyObject * obj2 = 0 ;
13075  PyObject * obj3 = 0 ;
13076 
13077  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13078  ecode1 = SWIG_AsVal_int(obj0, &val1);
13079  if (!SWIG_IsOK(ecode1)) {
13080  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13081  }
13082  arg1 = (PLINT)(val1);
13083  ecode2 = SWIG_AsVal_int(obj1, &val2);
13084  if (!SWIG_IsOK(ecode2)) {
13085  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13086  }
13087  arg2 = (PLINT)(val2);
13088  ecode3 = SWIG_AsVal_double(obj2, &val3);
13089  if (!SWIG_IsOK(ecode3)) {
13090  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13091  }
13092  arg3 = (PLFLT)(val3);
13093  ecode4 = SWIG_AsVal_double(obj3, &val4);
13094  if (!SWIG_IsOK(ecode4)) {
13095  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13096  }
13097  arg4 = (PLFLT)(val4);
13098  plstripa(arg1,arg2,arg3,arg4);
13099  resultobj = SWIG_Py_Void();
13100  return resultobj;
13101 fail:
13102  return NULL;
13103 }
13104 
13105 
13106 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107  PyObject *resultobj = 0;
13108  PLINT *arg1 = (PLINT *) 0 ;
13109  char *arg2 = (char *) 0 ;
13110  char *arg3 = (char *) 0 ;
13111  PLFLT arg4 ;
13112  PLFLT arg5 ;
13113  PLFLT arg6 ;
13114  PLFLT arg7 ;
13115  PLFLT arg8 ;
13116  PLFLT arg9 ;
13117  PLFLT arg10 ;
13118  PLBOOL arg11 ;
13119  PLBOOL arg12 ;
13120  PLINT arg13 ;
13121  PLINT arg14 ;
13122  PLINT *arg15 = (PLINT *) 0 ;
13123  PLINT *arg16 = (PLINT *) 0 ;
13124  char **arg17 ;
13125  char *arg18 = (char *) 0 ;
13126  char *arg19 = (char *) 0 ;
13127  char *arg20 = (char *) 0 ;
13128  PLINT temp1 ;
13129  int res1 = SWIG_TMPOBJ ;
13130  int res2 ;
13131  char *buf2 = 0 ;
13132  int alloc2 = 0 ;
13133  int res3 ;
13134  char *buf3 = 0 ;
13135  int alloc3 = 0 ;
13136  double val4 ;
13137  int ecode4 = 0 ;
13138  double val5 ;
13139  int ecode5 = 0 ;
13140  double val6 ;
13141  int ecode6 = 0 ;
13142  double val7 ;
13143  int ecode7 = 0 ;
13144  double val8 ;
13145  int ecode8 = 0 ;
13146  double val9 ;
13147  int ecode9 = 0 ;
13148  double val10 ;
13149  int ecode10 = 0 ;
13150  int val11 ;
13151  int ecode11 = 0 ;
13152  int val12 ;
13153  int ecode12 = 0 ;
13154  int val13 ;
13155  int ecode13 = 0 ;
13156  int val14 ;
13157  int ecode14 = 0 ;
13158  PyArrayObject *tmp15 = NULL ;
13159  PyArrayObject *tmp16 = NULL ;
13160  char **tmp17 = NULL ;
13161  int res18 ;
13162  char *buf18 = 0 ;
13163  int alloc18 = 0 ;
13164  int res19 ;
13165  char *buf19 = 0 ;
13166  int alloc19 = 0 ;
13167  int res20 ;
13168  char *buf20 = 0 ;
13169  int alloc20 = 0 ;
13170  PyObject * obj0 = 0 ;
13171  PyObject * obj1 = 0 ;
13172  PyObject * obj2 = 0 ;
13173  PyObject * obj3 = 0 ;
13174  PyObject * obj4 = 0 ;
13175  PyObject * obj5 = 0 ;
13176  PyObject * obj6 = 0 ;
13177  PyObject * obj7 = 0 ;
13178  PyObject * obj8 = 0 ;
13179  PyObject * obj9 = 0 ;
13180  PyObject * obj10 = 0 ;
13181  PyObject * obj11 = 0 ;
13182  PyObject * obj12 = 0 ;
13183  PyObject * obj13 = 0 ;
13184  PyObject * obj14 = 0 ;
13185  PyObject * obj15 = 0 ;
13186  PyObject * obj16 = 0 ;
13187  PyObject * obj17 = 0 ;
13188  PyObject * obj18 = 0 ;
13189 
13190  arg1 = &temp1;
13191  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;
13192  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13193  if (!SWIG_IsOK(res2)) {
13194  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13195  }
13196  arg2 = (char *)(buf2);
13197  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13198  if (!SWIG_IsOK(res3)) {
13199  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13200  }
13201  arg3 = (char *)(buf3);
13202  ecode4 = SWIG_AsVal_double(obj2, &val4);
13203  if (!SWIG_IsOK(ecode4)) {
13204  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13205  }
13206  arg4 = (PLFLT)(val4);
13207  ecode5 = SWIG_AsVal_double(obj3, &val5);
13208  if (!SWIG_IsOK(ecode5)) {
13209  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13210  }
13211  arg5 = (PLFLT)(val5);
13212  ecode6 = SWIG_AsVal_double(obj4, &val6);
13213  if (!SWIG_IsOK(ecode6)) {
13214  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13215  }
13216  arg6 = (PLFLT)(val6);
13217  ecode7 = SWIG_AsVal_double(obj5, &val7);
13218  if (!SWIG_IsOK(ecode7)) {
13219  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13220  }
13221  arg7 = (PLFLT)(val7);
13222  ecode8 = SWIG_AsVal_double(obj6, &val8);
13223  if (!SWIG_IsOK(ecode8)) {
13224  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13225  }
13226  arg8 = (PLFLT)(val8);
13227  ecode9 = SWIG_AsVal_double(obj7, &val9);
13228  if (!SWIG_IsOK(ecode9)) {
13229  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13230  }
13231  arg9 = (PLFLT)(val9);
13232  ecode10 = SWIG_AsVal_double(obj8, &val10);
13233  if (!SWIG_IsOK(ecode10)) {
13234  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13235  }
13236  arg10 = (PLFLT)(val10);
13237  ecode11 = SWIG_AsVal_int(obj9, &val11);
13238  if (!SWIG_IsOK(ecode11)) {
13239  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13240  }
13241  arg11 = (PLBOOL)(val11);
13242  ecode12 = SWIG_AsVal_int(obj10, &val12);
13243  if (!SWIG_IsOK(ecode12)) {
13244  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13245  }
13246  arg12 = (PLBOOL)(val12);
13247  ecode13 = SWIG_AsVal_int(obj11, &val13);
13248  if (!SWIG_IsOK(ecode13)) {
13249  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13250  }
13251  arg13 = (PLINT)(val13);
13252  ecode14 = SWIG_AsVal_int(obj12, &val14);
13253  if (!SWIG_IsOK(ecode14)) {
13254  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13255  }
13256  arg14 = (PLINT)(val14);
13257  {
13258  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13259  if ( tmp15 == NULL )
13260  return NULL;
13261  Alen = PyArray_DIMS( tmp15 )[0];
13262  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13263  }
13264  {
13265  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13266  if ( tmp16 == NULL )
13267  return NULL;
13268  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13269  {
13270  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13271  return NULL;
13272  }
13273  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13274  }
13275  {
13276  int i;
13277  PyObject *elt, *unicode_string;
13278 
13279  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13280  {
13281  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13282  return NULL;
13283  }
13284  if ( Alen != 4 )
13285  {
13286  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13287  return NULL;
13288  }
13289  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13290  if ( tmp17 == NULL )
13291  return NULL;
13292  arg17 = tmp17;
13293  for ( i = 0; i < 4; i++ )
13294  {
13295  arg17[i] = NULL;
13296  elt = PySequence_Fast_GET_ITEM( obj15, i );
13297  if ( PyString_Check( elt ) )
13298  {
13299  arg17[i] = PyString_AsString( elt );
13300  }
13301  else if ( PyUnicode_Check( elt ) )
13302  {
13303  unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13304  arg17[i] = PyBytes_AS_STRING( unicode_string );
13305  }
13306  if ( arg17[i] == NULL )
13307  {
13308  free( tmp17 );
13309  return NULL;
13310  }
13311  }
13312  }
13313  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13314  if (!SWIG_IsOK(res18)) {
13315  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13316  }
13317  arg18 = (char *)(buf18);
13318  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13319  if (!SWIG_IsOK(res19)) {
13320  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13321  }
13322  arg19 = (char *)(buf19);
13323  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13324  if (!SWIG_IsOK(res20)) {
13325  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13326  }
13327  arg20 = (char *)(buf20);
13328  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);
13329  resultobj = SWIG_Py_Void();
13330  if (SWIG_IsTmpObj(res1)) {
13331  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13332  } else {
13333  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13334  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13335  }
13336  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13337  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13338  {
13339  Py_CLEAR( tmp15 );
13340  }
13341  {
13342  Py_CLEAR( tmp16 );
13343  }
13344  {
13345  free( tmp17 );
13346  }
13347  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13348  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13349  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13350  return resultobj;
13351 fail:
13352  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13353  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13354  {
13355  Py_CLEAR( tmp15 );
13356  }
13357  {
13358  Py_CLEAR( tmp16 );
13359  }
13360  {
13361  free( tmp17 );
13362  }
13363  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13364  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13365  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13366  return NULL;
13367 }
13368 
13369 
13370 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13371  PyObject *resultobj = 0;
13372  PLINT arg1 ;
13373  int val1 ;
13374  int ecode1 = 0 ;
13375  PyObject * obj0 = 0 ;
13376 
13377  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13378  ecode1 = SWIG_AsVal_int(obj0, &val1);
13379  if (!SWIG_IsOK(ecode1)) {
13380  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13381  }
13382  arg1 = (PLINT)(val1);
13383  plstripd(arg1);
13384  resultobj = SWIG_Py_Void();
13385  return resultobj;
13386 fail:
13387  return NULL;
13388 }
13389 
13390 
13391 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392  PyObject *resultobj = 0;
13393  PLINT arg1 ;
13394  PLINT *arg2 = (PLINT *) 0 ;
13395  PLINT *arg3 = (PLINT *) 0 ;
13396  PyArrayObject *tmp1 = NULL ;
13397  PyArrayObject *tmp3 = NULL ;
13398  PyObject * obj0 = 0 ;
13399  PyObject * obj1 = 0 ;
13400 
13401  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13402  {
13403  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13404  if ( tmp1 == NULL )
13405  return NULL;
13406  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13407  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13408  }
13409  {
13410  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13411  if ( tmp3 == NULL )
13412  return NULL;
13413  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13414  {
13415  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13416  return NULL;
13417  }
13418  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13419  }
13420  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13421  resultobj = SWIG_Py_Void();
13422  {
13423  Py_CLEAR( tmp1 );
13424  }
13425  {
13426  Py_CLEAR( tmp3 );
13427  }
13428  return resultobj;
13429 fail:
13430  {
13431  Py_CLEAR( tmp1 );
13432  }
13433  {
13434  Py_CLEAR( tmp3 );
13435  }
13436  return NULL;
13437 }
13438 
13439 
13440 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13441  PyObject *resultobj = 0;
13442  PLFLT *arg1 = (PLFLT *) 0 ;
13443  PLFLT *arg2 = (PLFLT *) 0 ;
13444  PLINT arg3 ;
13445  PLBOOL arg4 ;
13446  PyArrayObject *tmp1 = NULL ;
13447  PyArrayObject *tmp2 = NULL ;
13448  int val4 ;
13449  int ecode4 = 0 ;
13450  PyObject * obj0 = 0 ;
13451  PyObject * obj1 = 0 ;
13452  PyObject * obj2 = 0 ;
13453 
13454  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13455  {
13456  if ( obj0 != Py_None )
13457  {
13458  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13459  if ( tmp1 == NULL )
13460  return NULL;
13461  Alen = PyArray_DIMS( tmp1 )[0];
13462  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13463  }
13464  else
13465  {
13466  arg1 = NULL;
13467  Alen = 0;
13468  }
13469  }
13470  {
13471  if ( obj1 != Py_None )
13472  {
13473  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13474  if ( tmp2 == NULL )
13475  return NULL;
13476  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13477  {
13478  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13479  return NULL;
13480  }
13481  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13482  arg3 = PyArray_DIMS( tmp2 )[0];
13483  }
13484  else
13485  {
13486  arg2 = NULL;
13487  arg3 = 0;
13488  }
13489  }
13490  ecode4 = SWIG_AsVal_int(obj2, &val4);
13491  if (!SWIG_IsOK(ecode4)) {
13492  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13493  }
13494  arg4 = (PLBOOL)(val4);
13495  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13496  resultobj = SWIG_Py_Void();
13497  {
13498  Py_CLEAR( tmp1 );
13499  }
13500  {
13501  Py_CLEAR( tmp2 );
13502  }
13503  return resultobj;
13504 fail:
13505  {
13506  Py_CLEAR( tmp1 );
13507  }
13508  {
13509  Py_CLEAR( tmp2 );
13510  }
13511  return NULL;
13512 }
13513 
13514 
13515 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13516  PyObject *resultobj = 0;
13517  PLFLT arg1 ;
13518  PLFLT arg2 ;
13519  PLFLT arg3 ;
13520  PLFLT arg4 ;
13521  double val1 ;
13522  int ecode1 = 0 ;
13523  double val2 ;
13524  int ecode2 = 0 ;
13525  double val3 ;
13526  int ecode3 = 0 ;
13527  double val4 ;
13528  int ecode4 = 0 ;
13529  PyObject * obj0 = 0 ;
13530  PyObject * obj1 = 0 ;
13531  PyObject * obj2 = 0 ;
13532  PyObject * obj3 = 0 ;
13533 
13534  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13535  ecode1 = SWIG_AsVal_double(obj0, &val1);
13536  if (!SWIG_IsOK(ecode1)) {
13537  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13538  }
13539  arg1 = (PLFLT)(val1);
13540  ecode2 = SWIG_AsVal_double(obj1, &val2);
13541  if (!SWIG_IsOK(ecode2)) {
13542  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13543  }
13544  arg2 = (PLFLT)(val2);
13545  ecode3 = SWIG_AsVal_double(obj2, &val3);
13546  if (!SWIG_IsOK(ecode3)) {
13547  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13548  }
13549  arg3 = (PLFLT)(val3);
13550  ecode4 = SWIG_AsVal_double(obj3, &val4);
13551  if (!SWIG_IsOK(ecode4)) {
13552  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13553  }
13554  arg4 = (PLFLT)(val4);
13555  plsvpa(arg1,arg2,arg3,arg4);
13556  resultobj = SWIG_Py_Void();
13557  return resultobj;
13558 fail:
13559  return NULL;
13560 }
13561 
13562 
13563 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13564  PyObject *resultobj = 0;
13565  PLINT arg1 ;
13566  PLINT arg2 ;
13567  int val1 ;
13568  int ecode1 = 0 ;
13569  int val2 ;
13570  int ecode2 = 0 ;
13571  PyObject * obj0 = 0 ;
13572  PyObject * obj1 = 0 ;
13573 
13574  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13575  ecode1 = SWIG_AsVal_int(obj0, &val1);
13576  if (!SWIG_IsOK(ecode1)) {
13577  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13578  }
13579  arg1 = (PLINT)(val1);
13580  ecode2 = SWIG_AsVal_int(obj1, &val2);
13581  if (!SWIG_IsOK(ecode2)) {
13582  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13583  }
13584  arg2 = (PLINT)(val2);
13585  plsxax(arg1,arg2);
13586  resultobj = SWIG_Py_Void();
13587  return resultobj;
13588 fail:
13589  return NULL;
13590 }
13591 
13592 
13593 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594  PyObject *resultobj = 0;
13595  PLINT arg1 ;
13596  PLINT arg2 ;
13597  int val1 ;
13598  int ecode1 = 0 ;
13599  int val2 ;
13600  int ecode2 = 0 ;
13601  PyObject * obj0 = 0 ;
13602  PyObject * obj1 = 0 ;
13603 
13604  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13605  ecode1 = SWIG_AsVal_int(obj0, &val1);
13606  if (!SWIG_IsOK(ecode1)) {
13607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13608  }
13609  arg1 = (PLINT)(val1);
13610  ecode2 = SWIG_AsVal_int(obj1, &val2);
13611  if (!SWIG_IsOK(ecode2)) {
13612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13613  }
13614  arg2 = (PLINT)(val2);
13615  plsyax(arg1,arg2);
13616  resultobj = SWIG_Py_Void();
13617  return resultobj;
13618 fail:
13619  return NULL;
13620 }
13621 
13622 
13623 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13624  PyObject *resultobj = 0;
13625  PLINT arg1 ;
13626  PLFLT *arg2 = (PLFLT *) 0 ;
13627  PLFLT *arg3 = (PLFLT *) 0 ;
13628  PLINT arg4 ;
13629  PyArrayObject *tmp1 = NULL ;
13630  PyArrayObject *tmp3 = NULL ;
13631  int val4 ;
13632  int ecode4 = 0 ;
13633  PyObject * obj0 = 0 ;
13634  PyObject * obj1 = 0 ;
13635  PyObject * obj2 = 0 ;
13636 
13637  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13638  {
13639  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13640  if ( tmp1 == NULL )
13641  return NULL;
13642  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13643  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13644  }
13645  {
13646  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13647  if ( tmp3 == NULL )
13648  return NULL;
13649  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13650  {
13651  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13652  return NULL;
13653  }
13654  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13655  }
13656  ecode4 = SWIG_AsVal_int(obj2, &val4);
13657  if (!SWIG_IsOK(ecode4)) {
13658  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13659  }
13660  arg4 = (PLINT)(val4);
13661  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13662  resultobj = SWIG_Py_Void();
13663  {
13664  Py_CLEAR( tmp1 );
13665  }
13666  {
13667  Py_CLEAR( tmp3 );
13668  }
13669  return resultobj;
13670 fail:
13671  {
13672  Py_CLEAR( tmp1 );
13673  }
13674  {
13675  Py_CLEAR( tmp3 );
13676  }
13677  return NULL;
13678 }
13679 
13680 
13681 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13682  PyObject *resultobj = 0;
13683  PLINT arg1 ;
13684  PLINT arg2 ;
13685  int val1 ;
13686  int ecode1 = 0 ;
13687  int val2 ;
13688  int ecode2 = 0 ;
13689  PyObject * obj0 = 0 ;
13690  PyObject * obj1 = 0 ;
13691 
13692  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13693  ecode1 = SWIG_AsVal_int(obj0, &val1);
13694  if (!SWIG_IsOK(ecode1)) {
13695  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13696  }
13697  arg1 = (PLINT)(val1);
13698  ecode2 = SWIG_AsVal_int(obj1, &val2);
13699  if (!SWIG_IsOK(ecode2)) {
13700  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13701  }
13702  arg2 = (PLINT)(val2);
13703  plszax(arg1,arg2);
13704  resultobj = SWIG_Py_Void();
13705  return resultobj;
13706 fail:
13707  return NULL;
13708 }
13709 
13710 
13711 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13712  PyObject *resultobj = 0;
13713 
13714  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13715  pltext();
13716  resultobj = SWIG_Py_Void();
13717  return resultobj;
13718 fail:
13719  return NULL;
13720 }
13721 
13722 
13723 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13724  PyObject *resultobj = 0;
13725  char *arg1 = (char *) 0 ;
13726  int res1 ;
13727  char *buf1 = 0 ;
13728  int alloc1 = 0 ;
13729  PyObject * obj0 = 0 ;
13730 
13731  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13732  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13733  if (!SWIG_IsOK(res1)) {
13734  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13735  }
13736  arg1 = (char *)(buf1);
13737  pltimefmt((char const *)arg1);
13738  resultobj = SWIG_Py_Void();
13739  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13740  return resultobj;
13741 fail:
13742  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13743  return NULL;
13744 }
13745 
13746 
13747 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13748  PyObject *resultobj = 0;
13749  PLFLT arg1 ;
13750  double val1 ;
13751  int ecode1 = 0 ;
13752  PyObject * obj0 = 0 ;
13753 
13754  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13755  ecode1 = SWIG_AsVal_double(obj0, &val1);
13756  if (!SWIG_IsOK(ecode1)) {
13757  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13758  }
13759  arg1 = (PLFLT)(val1);
13760  plvasp(arg1);
13761  resultobj = SWIG_Py_Void();
13762  return resultobj;
13763 fail:
13764  return NULL;
13765 }
13766 
13767 
13768 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13769  PyObject *resultobj = 0;
13770  PLFLT **arg1 = (PLFLT **) 0 ;
13771  PLFLT **arg2 = (PLFLT **) 0 ;
13772  PLINT arg3 ;
13773  PLINT arg4 ;
13774  PLFLT arg5 ;
13775  pltr_func arg6 = (pltr_func) 0 ;
13776  PLPointer arg7 = (PLPointer) 0 ;
13777  PyArrayObject *tmp1 = NULL ;
13778  PyArrayObject *tmp2 = NULL ;
13779  double val5 ;
13780  int ecode5 = 0 ;
13781  PyObject * obj0 = 0 ;
13782  PyObject * obj1 = 0 ;
13783  PyObject * obj2 = 0 ;
13784  PyObject * obj3 = 0 ;
13785  PyObject * obj4 = 0 ;
13786 
13787  {
13788  python_pltr = 0;
13789  arg6 = NULL;
13790  }
13791  {
13792  arg7 = NULL;
13793  }
13794  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13795  {
13796  int i, size;
13797  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13798  if ( tmp1 == NULL )
13799  return NULL;
13800  Xlen = PyArray_DIMS( tmp1 )[0];
13801  Ylen = PyArray_DIMS( tmp1 )[1];
13802  size = Ylen;
13803  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13804  for ( i = 0; i < Xlen; i++ )
13805  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13806  }
13807  {
13808  int i, size;
13809  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13810  if ( tmp2 == NULL )
13811  return NULL;
13812  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13813  {
13814  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13815  return NULL;
13816  }
13817  arg3 = PyArray_DIMS( tmp2 )[0];
13818  arg4 = PyArray_DIMS( tmp2 )[1];
13819  size = arg4;
13820  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13821  for ( i = 0; i < arg3; i++ )
13822  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13823  }
13824  ecode5 = SWIG_AsVal_double(obj2, &val5);
13825  if (!SWIG_IsOK(ecode5)) {
13826  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13827  }
13828  arg5 = (PLFLT)(val5);
13829  if (obj3) {
13830  {
13831  // it must be a callable or None
13832  if ( obj3 == Py_None )
13833  {
13834  arg6 = NULL;
13835  }
13836  else
13837  {
13838  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13839  {
13840  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13841  return NULL;
13842  }
13843  arg6 = marshal_pltr( obj3 );
13844  }
13845  }
13846  }
13847  if (obj4) {
13848  {
13849  if ( obj4 == Py_None )
13850  arg7 = NULL;
13851  else
13852  {
13853  arg7 = marshal_PLPointer( obj4, 0 );
13854  }
13855  }
13856  }
13857  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13858  resultobj = SWIG_Py_Void();
13859  {
13860  Py_CLEAR( tmp1 );
13861  free( arg1 );
13862  }
13863  {
13864  Py_CLEAR( tmp2 );
13865  free( arg2 );
13866  }
13867  {
13868  cleanup_pltr();
13869  }
13870  {
13872  }
13873  return resultobj;
13874 fail:
13875  {
13876  Py_CLEAR( tmp1 );
13877  free( arg1 );
13878  }
13879  {
13880  Py_CLEAR( tmp2 );
13881  free( arg2 );
13882  }
13883  {
13884  cleanup_pltr();
13885  }
13886  {
13888  }
13889  return NULL;
13890 }
13891 
13892 
13893 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13894  PyObject *resultobj = 0;
13895  PLFLT arg1 ;
13896  PLFLT arg2 ;
13897  PLFLT arg3 ;
13898  PLFLT arg4 ;
13899  PLFLT arg5 ;
13900  double val1 ;
13901  int ecode1 = 0 ;
13902  double val2 ;
13903  int ecode2 = 0 ;
13904  double val3 ;
13905  int ecode3 = 0 ;
13906  double val4 ;
13907  int ecode4 = 0 ;
13908  double val5 ;
13909  int ecode5 = 0 ;
13910  PyObject * obj0 = 0 ;
13911  PyObject * obj1 = 0 ;
13912  PyObject * obj2 = 0 ;
13913  PyObject * obj3 = 0 ;
13914  PyObject * obj4 = 0 ;
13915 
13916  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13917  ecode1 = SWIG_AsVal_double(obj0, &val1);
13918  if (!SWIG_IsOK(ecode1)) {
13919  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13920  }
13921  arg1 = (PLFLT)(val1);
13922  ecode2 = SWIG_AsVal_double(obj1, &val2);
13923  if (!SWIG_IsOK(ecode2)) {
13924  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13925  }
13926  arg2 = (PLFLT)(val2);
13927  ecode3 = SWIG_AsVal_double(obj2, &val3);
13928  if (!SWIG_IsOK(ecode3)) {
13929  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13930  }
13931  arg3 = (PLFLT)(val3);
13932  ecode4 = SWIG_AsVal_double(obj3, &val4);
13933  if (!SWIG_IsOK(ecode4)) {
13934  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13935  }
13936  arg4 = (PLFLT)(val4);
13937  ecode5 = SWIG_AsVal_double(obj4, &val5);
13938  if (!SWIG_IsOK(ecode5)) {
13939  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13940  }
13941  arg5 = (PLFLT)(val5);
13942  plvpas(arg1,arg2,arg3,arg4,arg5);
13943  resultobj = SWIG_Py_Void();
13944  return resultobj;
13945 fail:
13946  return NULL;
13947 }
13948 
13949 
13950 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13951  PyObject *resultobj = 0;
13952  PLFLT arg1 ;
13953  PLFLT arg2 ;
13954  PLFLT arg3 ;
13955  PLFLT arg4 ;
13956  double val1 ;
13957  int ecode1 = 0 ;
13958  double val2 ;
13959  int ecode2 = 0 ;
13960  double val3 ;
13961  int ecode3 = 0 ;
13962  double val4 ;
13963  int ecode4 = 0 ;
13964  PyObject * obj0 = 0 ;
13965  PyObject * obj1 = 0 ;
13966  PyObject * obj2 = 0 ;
13967  PyObject * obj3 = 0 ;
13968 
13969  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13970  ecode1 = SWIG_AsVal_double(obj0, &val1);
13971  if (!SWIG_IsOK(ecode1)) {
13972  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13973  }
13974  arg1 = (PLFLT)(val1);
13975  ecode2 = SWIG_AsVal_double(obj1, &val2);
13976  if (!SWIG_IsOK(ecode2)) {
13977  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13978  }
13979  arg2 = (PLFLT)(val2);
13980  ecode3 = SWIG_AsVal_double(obj2, &val3);
13981  if (!SWIG_IsOK(ecode3)) {
13982  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13983  }
13984  arg3 = (PLFLT)(val3);
13985  ecode4 = SWIG_AsVal_double(obj3, &val4);
13986  if (!SWIG_IsOK(ecode4)) {
13987  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13988  }
13989  arg4 = (PLFLT)(val4);
13990  plvpor(arg1,arg2,arg3,arg4);
13991  resultobj = SWIG_Py_Void();
13992  return resultobj;
13993 fail:
13994  return NULL;
13995 }
13996 
13997 
13998 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13999  PyObject *resultobj = 0;
14000 
14001  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
14002  plvsta();
14003  resultobj = SWIG_Py_Void();
14004  return resultobj;
14005 fail:
14006  return NULL;
14007 }
14008 
14009 
14010 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14011  PyObject *resultobj = 0;
14012  PLFLT arg1 ;
14013  PLFLT arg2 ;
14014  PLFLT arg3 ;
14015  PLFLT arg4 ;
14016  PLFLT arg5 ;
14017  PLFLT arg6 ;
14018  PLFLT arg7 ;
14019  PLFLT arg8 ;
14020  PLFLT arg9 ;
14021  PLFLT arg10 ;
14022  PLFLT arg11 ;
14023  double val1 ;
14024  int ecode1 = 0 ;
14025  double val2 ;
14026  int ecode2 = 0 ;
14027  double val3 ;
14028  int ecode3 = 0 ;
14029  double val4 ;
14030  int ecode4 = 0 ;
14031  double val5 ;
14032  int ecode5 = 0 ;
14033  double val6 ;
14034  int ecode6 = 0 ;
14035  double val7 ;
14036  int ecode7 = 0 ;
14037  double val8 ;
14038  int ecode8 = 0 ;
14039  double val9 ;
14040  int ecode9 = 0 ;
14041  double val10 ;
14042  int ecode10 = 0 ;
14043  double val11 ;
14044  int ecode11 = 0 ;
14045  PyObject * obj0 = 0 ;
14046  PyObject * obj1 = 0 ;
14047  PyObject * obj2 = 0 ;
14048  PyObject * obj3 = 0 ;
14049  PyObject * obj4 = 0 ;
14050  PyObject * obj5 = 0 ;
14051  PyObject * obj6 = 0 ;
14052  PyObject * obj7 = 0 ;
14053  PyObject * obj8 = 0 ;
14054  PyObject * obj9 = 0 ;
14055  PyObject * obj10 = 0 ;
14056 
14057  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14058  ecode1 = SWIG_AsVal_double(obj0, &val1);
14059  if (!SWIG_IsOK(ecode1)) {
14060  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14061  }
14062  arg1 = (PLFLT)(val1);
14063  ecode2 = SWIG_AsVal_double(obj1, &val2);
14064  if (!SWIG_IsOK(ecode2)) {
14065  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14066  }
14067  arg2 = (PLFLT)(val2);
14068  ecode3 = SWIG_AsVal_double(obj2, &val3);
14069  if (!SWIG_IsOK(ecode3)) {
14070  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14071  }
14072  arg3 = (PLFLT)(val3);
14073  ecode4 = SWIG_AsVal_double(obj3, &val4);
14074  if (!SWIG_IsOK(ecode4)) {
14075  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14076  }
14077  arg4 = (PLFLT)(val4);
14078  ecode5 = SWIG_AsVal_double(obj4, &val5);
14079  if (!SWIG_IsOK(ecode5)) {
14080  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14081  }
14082  arg5 = (PLFLT)(val5);
14083  ecode6 = SWIG_AsVal_double(obj5, &val6);
14084  if (!SWIG_IsOK(ecode6)) {
14085  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14086  }
14087  arg6 = (PLFLT)(val6);
14088  ecode7 = SWIG_AsVal_double(obj6, &val7);
14089  if (!SWIG_IsOK(ecode7)) {
14090  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14091  }
14092  arg7 = (PLFLT)(val7);
14093  ecode8 = SWIG_AsVal_double(obj7, &val8);
14094  if (!SWIG_IsOK(ecode8)) {
14095  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14096  }
14097  arg8 = (PLFLT)(val8);
14098  ecode9 = SWIG_AsVal_double(obj8, &val9);
14099  if (!SWIG_IsOK(ecode9)) {
14100  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14101  }
14102  arg9 = (PLFLT)(val9);
14103  ecode10 = SWIG_AsVal_double(obj9, &val10);
14104  if (!SWIG_IsOK(ecode10)) {
14105  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14106  }
14107  arg10 = (PLFLT)(val10);
14108  ecode11 = SWIG_AsVal_double(obj10, &val11);
14109  if (!SWIG_IsOK(ecode11)) {
14110  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14111  }
14112  arg11 = (PLFLT)(val11);
14113  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14114  resultobj = SWIG_Py_Void();
14115  return resultobj;
14116 fail:
14117  return NULL;
14118 }
14119 
14120 
14121 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14122  PyObject *resultobj = 0;
14123  PLFLT arg1 ;
14124  double val1 ;
14125  int ecode1 = 0 ;
14126  PyObject * obj0 = 0 ;
14127 
14128  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
14129  ecode1 = SWIG_AsVal_double(obj0, &val1);
14130  if (!SWIG_IsOK(ecode1)) {
14131  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14132  }
14133  arg1 = (PLFLT)(val1);
14134  plwidth(arg1);
14135  resultobj = SWIG_Py_Void();
14136  return resultobj;
14137 fail:
14138  return NULL;
14139 }
14140 
14141 
14142 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143  PyObject *resultobj = 0;
14144  PLFLT arg1 ;
14145  PLFLT arg2 ;
14146  PLFLT arg3 ;
14147  PLFLT arg4 ;
14148  double val1 ;
14149  int ecode1 = 0 ;
14150  double val2 ;
14151  int ecode2 = 0 ;
14152  double val3 ;
14153  int ecode3 = 0 ;
14154  double val4 ;
14155  int ecode4 = 0 ;
14156  PyObject * obj0 = 0 ;
14157  PyObject * obj1 = 0 ;
14158  PyObject * obj2 = 0 ;
14159  PyObject * obj3 = 0 ;
14160 
14161  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14162  ecode1 = SWIG_AsVal_double(obj0, &val1);
14163  if (!SWIG_IsOK(ecode1)) {
14164  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14165  }
14166  arg1 = (PLFLT)(val1);
14167  ecode2 = SWIG_AsVal_double(obj1, &val2);
14168  if (!SWIG_IsOK(ecode2)) {
14169  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14170  }
14171  arg2 = (PLFLT)(val2);
14172  ecode3 = SWIG_AsVal_double(obj2, &val3);
14173  if (!SWIG_IsOK(ecode3)) {
14174  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14175  }
14176  arg3 = (PLFLT)(val3);
14177  ecode4 = SWIG_AsVal_double(obj3, &val4);
14178  if (!SWIG_IsOK(ecode4)) {
14179  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14180  }
14181  arg4 = (PLFLT)(val4);
14182  plwind(arg1,arg2,arg3,arg4);
14183  resultobj = SWIG_Py_Void();
14184  return resultobj;
14185 fail:
14186  return NULL;
14187 }
14188 
14189 
14190 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191  PyObject *resultobj = 0;
14192  PLBOOL arg1 ;
14193  PLBOOL *arg2 = (PLBOOL *) 0 ;
14194  int val1 ;
14195  int ecode1 = 0 ;
14196  PLBOOL temp2 ;
14197  int res2 = SWIG_TMPOBJ ;
14198  PyObject * obj0 = 0 ;
14199 
14200  arg2 = &temp2;
14201  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14202  ecode1 = SWIG_AsVal_int(obj0, &val1);
14203  if (!SWIG_IsOK(ecode1)) {
14204  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14205  }
14206  arg1 = (PLBOOL)(val1);
14207  plxormod(arg1,arg2);
14208  resultobj = SWIG_Py_Void();
14209  if (SWIG_IsTmpObj(res2)) {
14210  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14211  } else {
14212  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14213  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14214  }
14215  return resultobj;
14216 fail:
14217  return NULL;
14218 }
14219 
14220 
14221 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14222  PyObject *resultobj = 0;
14223  mapform_func arg1 = (mapform_func) 0 ;
14224  char *arg2 = (char *) 0 ;
14225  PLFLT arg3 ;
14226  PLFLT arg4 ;
14227  PLFLT arg5 ;
14228  PLFLT arg6 ;
14229  int res2 ;
14230  char *buf2 = 0 ;
14231  int alloc2 = 0 ;
14232  double val3 ;
14233  int ecode3 = 0 ;
14234  double val4 ;
14235  int ecode4 = 0 ;
14236  double val5 ;
14237  int ecode5 = 0 ;
14238  double val6 ;
14239  int ecode6 = 0 ;
14240  PyObject * obj0 = 0 ;
14241  PyObject * obj1 = 0 ;
14242  PyObject * obj2 = 0 ;
14243  PyObject * obj3 = 0 ;
14244  PyObject * obj4 = 0 ;
14245  PyObject * obj5 = 0 ;
14246 
14247  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14248  {
14249  // it must be a callable or none
14250  if ( obj0 == Py_None )
14251  {
14252  arg1 = NULL;
14253  }
14254  else
14255  {
14256  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14257  {
14258  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14259  return NULL;
14260  }
14261  arg1 = marshal_mapform( obj0 );
14262  }
14263  }
14264  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14265  if (!SWIG_IsOK(res2)) {
14266  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14267  }
14268  arg2 = (char *)(buf2);
14269  ecode3 = SWIG_AsVal_double(obj2, &val3);
14270  if (!SWIG_IsOK(ecode3)) {
14271  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14272  }
14273  arg3 = (PLFLT)(val3);
14274  ecode4 = SWIG_AsVal_double(obj3, &val4);
14275  if (!SWIG_IsOK(ecode4)) {
14276  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14277  }
14278  arg4 = (PLFLT)(val4);
14279  ecode5 = SWIG_AsVal_double(obj4, &val5);
14280  if (!SWIG_IsOK(ecode5)) {
14281  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14282  }
14283  arg5 = (PLFLT)(val5);
14284  ecode6 = SWIG_AsVal_double(obj5, &val6);
14285  if (!SWIG_IsOK(ecode6)) {
14286  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14287  }
14288  arg6 = (PLFLT)(val6);
14289  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14290  resultobj = SWIG_Py_Void();
14291  {
14292  cleanup_mapform();
14293  }
14294  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14295  return resultobj;
14296 fail:
14297  {
14298  cleanup_mapform();
14299  }
14300  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14301  return NULL;
14302 }
14303 
14304 
14305 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14306  PyObject *resultobj = 0;
14307  mapform_func arg1 = (mapform_func) 0 ;
14308  char *arg2 = (char *) 0 ;
14309  PLFLT arg3 ;
14310  PLFLT arg4 ;
14311  PLFLT arg5 ;
14312  PLFLT arg6 ;
14313  PLINT *arg7 = (PLINT *) 0 ;
14314  PLINT arg8 ;
14315  int res2 ;
14316  char *buf2 = 0 ;
14317  int alloc2 = 0 ;
14318  double val3 ;
14319  int ecode3 = 0 ;
14320  double val4 ;
14321  int ecode4 = 0 ;
14322  double val5 ;
14323  int ecode5 = 0 ;
14324  double val6 ;
14325  int ecode6 = 0 ;
14326  PyArrayObject *tmp7 = NULL ;
14327  PyObject * obj0 = 0 ;
14328  PyObject * obj1 = 0 ;
14329  PyObject * obj2 = 0 ;
14330  PyObject * obj3 = 0 ;
14331  PyObject * obj4 = 0 ;
14332  PyObject * obj5 = 0 ;
14333  PyObject * obj6 = 0 ;
14334 
14335  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14336  {
14337  // it must be a callable or none
14338  if ( obj0 == Py_None )
14339  {
14340  arg1 = NULL;
14341  }
14342  else
14343  {
14344  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14345  {
14346  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14347  return NULL;
14348  }
14349  arg1 = marshal_mapform( obj0 );
14350  }
14351  }
14352  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14353  if (!SWIG_IsOK(res2)) {
14354  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14355  }
14356  arg2 = (char *)(buf2);
14357  ecode3 = SWIG_AsVal_double(obj2, &val3);
14358  if (!SWIG_IsOK(ecode3)) {
14359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14360  }
14361  arg3 = (PLFLT)(val3);
14362  ecode4 = SWIG_AsVal_double(obj3, &val4);
14363  if (!SWIG_IsOK(ecode4)) {
14364  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14365  }
14366  arg4 = (PLFLT)(val4);
14367  ecode5 = SWIG_AsVal_double(obj4, &val5);
14368  if (!SWIG_IsOK(ecode5)) {
14369  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14370  }
14371  arg5 = (PLFLT)(val5);
14372  ecode6 = SWIG_AsVal_double(obj5, &val6);
14373  if (!SWIG_IsOK(ecode6)) {
14374  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14375  }
14376  arg6 = (PLFLT)(val6);
14377  {
14378  if ( obj6 != Py_None )
14379  {
14380  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14381  if ( tmp7 == NULL )
14382  return NULL;
14383  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14384  arg8 = PyArray_DIMS( tmp7 )[0];
14385  }
14386  else
14387  {
14388  arg7 = NULL;
14389  arg8 = 0;
14390  }
14391  }
14392  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14393  resultobj = SWIG_Py_Void();
14394  {
14395  cleanup_mapform();
14396  }
14397  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14398  {
14399  Py_CLEAR( tmp7 );
14400  }
14401  return resultobj;
14402 fail:
14403  {
14404  cleanup_mapform();
14405  }
14406  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14407  {
14408  Py_CLEAR( tmp7 );
14409  }
14410  return NULL;
14411 }
14412 
14413 
14414 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14415  PyObject *resultobj = 0;
14416  mapform_func arg1 = (mapform_func) 0 ;
14417  char *arg2 = (char *) 0 ;
14418  char *arg3 = (char *) 0 ;
14419  PLFLT arg4 ;
14420  PLFLT arg5 ;
14421  PLFLT arg6 ;
14422  PLFLT arg7 ;
14423  PLINT *arg8 = (PLINT *) 0 ;
14424  PLINT arg9 ;
14425  int res2 ;
14426  char *buf2 = 0 ;
14427  int alloc2 = 0 ;
14428  int res3 ;
14429  char *buf3 = 0 ;
14430  int alloc3 = 0 ;
14431  double val4 ;
14432  int ecode4 = 0 ;
14433  double val5 ;
14434  int ecode5 = 0 ;
14435  double val6 ;
14436  int ecode6 = 0 ;
14437  double val7 ;
14438  int ecode7 = 0 ;
14439  PyArrayObject *tmp8 = NULL ;
14440  PyObject * obj0 = 0 ;
14441  PyObject * obj1 = 0 ;
14442  PyObject * obj2 = 0 ;
14443  PyObject * obj3 = 0 ;
14444  PyObject * obj4 = 0 ;
14445  PyObject * obj5 = 0 ;
14446  PyObject * obj6 = 0 ;
14447  PyObject * obj7 = 0 ;
14448 
14449  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
14450  {
14451  // it must be a callable or none
14452  if ( obj0 == Py_None )
14453  {
14454  arg1 = NULL;
14455  }
14456  else
14457  {
14458  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14459  {
14460  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14461  return NULL;
14462  }
14463  arg1 = marshal_mapform( obj0 );
14464  }
14465  }
14466  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14467  if (!SWIG_IsOK(res2)) {
14468  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14469  }
14470  arg2 = (char *)(buf2);
14471  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
14472  if (!SWIG_IsOK(res3)) {
14473  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14474  }
14475  arg3 = (char *)(buf3);
14476  ecode4 = SWIG_AsVal_double(obj3, &val4);
14477  if (!SWIG_IsOK(ecode4)) {
14478  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14479  }
14480  arg4 = (PLFLT)(val4);
14481  ecode5 = SWIG_AsVal_double(obj4, &val5);
14482  if (!SWIG_IsOK(ecode5)) {
14483  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14484  }
14485  arg5 = (PLFLT)(val5);
14486  ecode6 = SWIG_AsVal_double(obj5, &val6);
14487  if (!SWIG_IsOK(ecode6)) {
14488  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14489  }
14490  arg6 = (PLFLT)(val6);
14491  ecode7 = SWIG_AsVal_double(obj6, &val7);
14492  if (!SWIG_IsOK(ecode7)) {
14493  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14494  }
14495  arg7 = (PLFLT)(val7);
14496  {
14497  if ( obj7 != Py_None )
14498  {
14499  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
14500  if ( tmp8 == NULL )
14501  return NULL;
14502  arg8 = (PLINT *) PyArray_DATA( tmp8 );
14503  arg9 = PyArray_DIMS( tmp8 )[0];
14504  }
14505  else
14506  {
14507  arg8 = NULL;
14508  arg9 = 0;
14509  }
14510  }
14511  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14512  resultobj = SWIG_Py_Void();
14513  {
14514  cleanup_mapform();
14515  }
14516  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14517  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14518  {
14519  Py_CLEAR( tmp8 );
14520  }
14521  return resultobj;
14522 fail:
14523  {
14524  cleanup_mapform();
14525  }
14526  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14527  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14528  {
14529  Py_CLEAR( tmp8 );
14530  }
14531  return NULL;
14532 }
14533 
14534 
14535 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14536  PyObject *resultobj = 0;
14537  mapform_func arg1 = (mapform_func) 0 ;
14538  char *arg2 = (char *) 0 ;
14539  PLFLT arg3 ;
14540  PLFLT arg4 ;
14541  PLFLT arg5 ;
14542  char *arg6 = (char *) 0 ;
14543  PLFLT arg7 ;
14544  PLFLT arg8 ;
14545  PLFLT arg9 ;
14546  PLFLT arg10 ;
14547  PLINT arg11 ;
14548  int res2 ;
14549  char *buf2 = 0 ;
14550  int alloc2 = 0 ;
14551  double val3 ;
14552  int ecode3 = 0 ;
14553  double val4 ;
14554  int ecode4 = 0 ;
14555  double val5 ;
14556  int ecode5 = 0 ;
14557  int res6 ;
14558  char *buf6 = 0 ;
14559  int alloc6 = 0 ;
14560  double val7 ;
14561  int ecode7 = 0 ;
14562  double val8 ;
14563  int ecode8 = 0 ;
14564  double val9 ;
14565  int ecode9 = 0 ;
14566  double val10 ;
14567  int ecode10 = 0 ;
14568  int val11 ;
14569  int ecode11 = 0 ;
14570  PyObject * obj0 = 0 ;
14571  PyObject * obj1 = 0 ;
14572  PyObject * obj2 = 0 ;
14573  PyObject * obj3 = 0 ;
14574  PyObject * obj4 = 0 ;
14575  PyObject * obj5 = 0 ;
14576  PyObject * obj6 = 0 ;
14577  PyObject * obj7 = 0 ;
14578  PyObject * obj8 = 0 ;
14579  PyObject * obj9 = 0 ;
14580  PyObject * obj10 = 0 ;
14581 
14582  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14583  {
14584  // it must be a callable or none
14585  if ( obj0 == Py_None )
14586  {
14587  arg1 = NULL;
14588  }
14589  else
14590  {
14591  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14592  {
14593  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14594  return NULL;
14595  }
14596  arg1 = marshal_mapform( obj0 );
14597  }
14598  }
14599  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14600  if (!SWIG_IsOK(res2)) {
14601  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14602  }
14603  arg2 = (char *)(buf2);
14604  ecode3 = SWIG_AsVal_double(obj2, &val3);
14605  if (!SWIG_IsOK(ecode3)) {
14606  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14607  }
14608  arg3 = (PLFLT)(val3);
14609  ecode4 = SWIG_AsVal_double(obj3, &val4);
14610  if (!SWIG_IsOK(ecode4)) {
14611  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14612  }
14613  arg4 = (PLFLT)(val4);
14614  ecode5 = SWIG_AsVal_double(obj4, &val5);
14615  if (!SWIG_IsOK(ecode5)) {
14616  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14617  }
14618  arg5 = (PLFLT)(val5);
14619  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
14620  if (!SWIG_IsOK(res6)) {
14621  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14622  }
14623  arg6 = (char *)(buf6);
14624  ecode7 = SWIG_AsVal_double(obj6, &val7);
14625  if (!SWIG_IsOK(ecode7)) {
14626  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14627  }
14628  arg7 = (PLFLT)(val7);
14629  ecode8 = SWIG_AsVal_double(obj7, &val8);
14630  if (!SWIG_IsOK(ecode8)) {
14631  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14632  }
14633  arg8 = (PLFLT)(val8);
14634  ecode9 = SWIG_AsVal_double(obj8, &val9);
14635  if (!SWIG_IsOK(ecode9)) {
14636  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14637  }
14638  arg9 = (PLFLT)(val9);
14639  ecode10 = SWIG_AsVal_double(obj9, &val10);
14640  if (!SWIG_IsOK(ecode10)) {
14641  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14642  }
14643  arg10 = (PLFLT)(val10);
14644  ecode11 = SWIG_AsVal_int(obj10, &val11);
14645  if (!SWIG_IsOK(ecode11)) {
14646  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14647  }
14648  arg11 = (PLINT)(val11);
14649  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14650  resultobj = SWIG_Py_Void();
14651  {
14652  cleanup_mapform();
14653  }
14654  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14655  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14656  return resultobj;
14657 fail:
14658  {
14659  cleanup_mapform();
14660  }
14661  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14662  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14663  return NULL;
14664 }
14665 
14666 
14667 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668  PyObject *resultobj = 0;
14669  mapform_func arg1 = (mapform_func) 0 ;
14670  char *arg2 = (char *) 0 ;
14671  PLFLT arg3 ;
14672  PLFLT arg4 ;
14673  PLFLT arg5 ;
14674  PLFLT arg6 ;
14675  PLINT *arg7 = (PLINT *) 0 ;
14676  PLINT arg8 ;
14677  int res2 ;
14678  char *buf2 = 0 ;
14679  int alloc2 = 0 ;
14680  double val3 ;
14681  int ecode3 = 0 ;
14682  double val4 ;
14683  int ecode4 = 0 ;
14684  double val5 ;
14685  int ecode5 = 0 ;
14686  double val6 ;
14687  int ecode6 = 0 ;
14688  PyArrayObject *tmp7 = NULL ;
14689  PyObject * obj0 = 0 ;
14690  PyObject * obj1 = 0 ;
14691  PyObject * obj2 = 0 ;
14692  PyObject * obj3 = 0 ;
14693  PyObject * obj4 = 0 ;
14694  PyObject * obj5 = 0 ;
14695  PyObject * obj6 = 0 ;
14696 
14697  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14698  {
14699  // it must be a callable or none
14700  if ( obj0 == Py_None )
14701  {
14702  arg1 = NULL;
14703  }
14704  else
14705  {
14706  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14707  {
14708  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14709  return NULL;
14710  }
14711  arg1 = marshal_mapform( obj0 );
14712  }
14713  }
14714  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14715  if (!SWIG_IsOK(res2)) {
14716  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14717  }
14718  arg2 = (char *)(buf2);
14719  ecode3 = SWIG_AsVal_double(obj2, &val3);
14720  if (!SWIG_IsOK(ecode3)) {
14721  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14722  }
14723  arg3 = (PLFLT)(val3);
14724  ecode4 = SWIG_AsVal_double(obj3, &val4);
14725  if (!SWIG_IsOK(ecode4)) {
14726  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14727  }
14728  arg4 = (PLFLT)(val4);
14729  ecode5 = SWIG_AsVal_double(obj4, &val5);
14730  if (!SWIG_IsOK(ecode5)) {
14731  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14732  }
14733  arg5 = (PLFLT)(val5);
14734  ecode6 = SWIG_AsVal_double(obj5, &val6);
14735  if (!SWIG_IsOK(ecode6)) {
14736  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14737  }
14738  arg6 = (PLFLT)(val6);
14739  {
14740  if ( obj6 != Py_None )
14741  {
14742  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14743  if ( tmp7 == NULL )
14744  return NULL;
14745  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14746  arg8 = PyArray_DIMS( tmp7 )[0];
14747  }
14748  else
14749  {
14750  arg7 = NULL;
14751  arg8 = 0;
14752  }
14753  }
14754  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14755  resultobj = SWIG_Py_Void();
14756  {
14757  cleanup_mapform();
14758  }
14759  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14760  {
14761  Py_CLEAR( tmp7 );
14762  }
14763  return resultobj;
14764 fail:
14765  {
14766  cleanup_mapform();
14767  }
14768  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14769  {
14770  Py_CLEAR( tmp7 );
14771  }
14772  return NULL;
14773 }
14774 
14775 
14776 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14777  PyObject *resultobj = 0;
14778  mapform_func arg1 = (mapform_func) 0 ;
14779  PLFLT arg2 ;
14780  PLFLT arg3 ;
14781  PLFLT arg4 ;
14782  PLFLT arg5 ;
14783  PLFLT arg6 ;
14784  PLFLT arg7 ;
14785  double val2 ;
14786  int ecode2 = 0 ;
14787  double val3 ;
14788  int ecode3 = 0 ;
14789  double val4 ;
14790  int ecode4 = 0 ;
14791  double val5 ;
14792  int ecode5 = 0 ;
14793  double val6 ;
14794  int ecode6 = 0 ;
14795  double val7 ;
14796  int ecode7 = 0 ;
14797  PyObject * obj0 = 0 ;
14798  PyObject * obj1 = 0 ;
14799  PyObject * obj2 = 0 ;
14800  PyObject * obj3 = 0 ;
14801  PyObject * obj4 = 0 ;
14802  PyObject * obj5 = 0 ;
14803  PyObject * obj6 = 0 ;
14804 
14805  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14806  {
14807  // it must be a callable or none
14808  if ( obj0 == Py_None )
14809  {
14810  arg1 = NULL;
14811  }
14812  else
14813  {
14814  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14815  {
14816  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14817  return NULL;
14818  }
14819  arg1 = marshal_mapform( obj0 );
14820  }
14821  }
14822  ecode2 = SWIG_AsVal_double(obj1, &val2);
14823  if (!SWIG_IsOK(ecode2)) {
14824  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14825  }
14826  arg2 = (PLFLT)(val2);
14827  ecode3 = SWIG_AsVal_double(obj2, &val3);
14828  if (!SWIG_IsOK(ecode3)) {
14829  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14830  }
14831  arg3 = (PLFLT)(val3);
14832  ecode4 = SWIG_AsVal_double(obj3, &val4);
14833  if (!SWIG_IsOK(ecode4)) {
14834  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14835  }
14836  arg4 = (PLFLT)(val4);
14837  ecode5 = SWIG_AsVal_double(obj4, &val5);
14838  if (!SWIG_IsOK(ecode5)) {
14839  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14840  }
14841  arg5 = (PLFLT)(val5);
14842  ecode6 = SWIG_AsVal_double(obj5, &val6);
14843  if (!SWIG_IsOK(ecode6)) {
14844  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14845  }
14846  arg6 = (PLFLT)(val6);
14847  ecode7 = SWIG_AsVal_double(obj6, &val7);
14848  if (!SWIG_IsOK(ecode7)) {
14849  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14850  }
14851  arg7 = (PLFLT)(val7);
14852  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14853  resultobj = SWIG_Py_Void();
14854  {
14855  cleanup_mapform();
14856  }
14857  return resultobj;
14858 fail:
14859  {
14860  cleanup_mapform();
14861  }
14862  return NULL;
14863 }
14864 
14865 
14866 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867  PyObject *resultobj = 0;
14868  PLFLT **arg1 = (PLFLT **) 0 ;
14869  PLINT arg2 ;
14870  PLINT arg3 ;
14871  PLFLT arg4 ;
14872  PLFLT arg5 ;
14873  PLFLT arg6 ;
14874  PLFLT arg7 ;
14875  PLFLT arg8 ;
14876  PLFLT arg9 ;
14877  PLFLT arg10 ;
14878  PLFLT arg11 ;
14879  PLFLT arg12 ;
14880  PLFLT arg13 ;
14881  PyArrayObject *tmp1 = NULL ;
14882  double val4 ;
14883  int ecode4 = 0 ;
14884  double val5 ;
14885  int ecode5 = 0 ;
14886  double val6 ;
14887  int ecode6 = 0 ;
14888  double val7 ;
14889  int ecode7 = 0 ;
14890  double val8 ;
14891  int ecode8 = 0 ;
14892  double val9 ;
14893  int ecode9 = 0 ;
14894  double val10 ;
14895  int ecode10 = 0 ;
14896  double val11 ;
14897  int ecode11 = 0 ;
14898  double val12 ;
14899  int ecode12 = 0 ;
14900  double val13 ;
14901  int ecode13 = 0 ;
14902  PyObject * obj0 = 0 ;
14903  PyObject * obj1 = 0 ;
14904  PyObject * obj2 = 0 ;
14905  PyObject * obj3 = 0 ;
14906  PyObject * obj4 = 0 ;
14907  PyObject * obj5 = 0 ;
14908  PyObject * obj6 = 0 ;
14909  PyObject * obj7 = 0 ;
14910  PyObject * obj8 = 0 ;
14911  PyObject * obj9 = 0 ;
14912  PyObject * obj10 = 0 ;
14913 
14914  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14915  {
14916  int i, size;
14917  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14918  if ( tmp1 == NULL )
14919  return NULL;
14920  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14921  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14922  size = arg3;
14923  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14924  for ( i = 0; i < arg2; i++ )
14925  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14926  }
14927  ecode4 = SWIG_AsVal_double(obj1, &val4);
14928  if (!SWIG_IsOK(ecode4)) {
14929  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14930  }
14931  arg4 = (PLFLT)(val4);
14932  ecode5 = SWIG_AsVal_double(obj2, &val5);
14933  if (!SWIG_IsOK(ecode5)) {
14934  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14935  }
14936  arg5 = (PLFLT)(val5);
14937  ecode6 = SWIG_AsVal_double(obj3, &val6);
14938  if (!SWIG_IsOK(ecode6)) {
14939  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14940  }
14941  arg6 = (PLFLT)(val6);
14942  ecode7 = SWIG_AsVal_double(obj4, &val7);
14943  if (!SWIG_IsOK(ecode7)) {
14944  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14945  }
14946  arg7 = (PLFLT)(val7);
14947  ecode8 = SWIG_AsVal_double(obj5, &val8);
14948  if (!SWIG_IsOK(ecode8)) {
14949  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14950  }
14951  arg8 = (PLFLT)(val8);
14952  ecode9 = SWIG_AsVal_double(obj6, &val9);
14953  if (!SWIG_IsOK(ecode9)) {
14954  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14955  }
14956  arg9 = (PLFLT)(val9);
14957  ecode10 = SWIG_AsVal_double(obj7, &val10);
14958  if (!SWIG_IsOK(ecode10)) {
14959  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14960  }
14961  arg10 = (PLFLT)(val10);
14962  ecode11 = SWIG_AsVal_double(obj8, &val11);
14963  if (!SWIG_IsOK(ecode11)) {
14964  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14965  }
14966  arg11 = (PLFLT)(val11);
14967  ecode12 = SWIG_AsVal_double(obj9, &val12);
14968  if (!SWIG_IsOK(ecode12)) {
14969  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14970  }
14971  arg12 = (PLFLT)(val12);
14972  ecode13 = SWIG_AsVal_double(obj10, &val13);
14973  if (!SWIG_IsOK(ecode13)) {
14974  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14975  }
14976  arg13 = (PLFLT)(val13);
14977  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14978  resultobj = SWIG_Py_Void();
14979  {
14980  Py_CLEAR( tmp1 );
14981  free( arg1 );
14982  }
14983  return resultobj;
14984 fail:
14985  {
14986  Py_CLEAR( tmp1 );
14987  free( arg1 );
14988  }
14989  return NULL;
14990 }
14991 
14992 
14993 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994  PyObject *resultobj = 0;
14995  PLFLT **arg1 = (PLFLT **) 0 ;
14996  PLINT arg2 ;
14997  PLINT arg3 ;
14998  PLFLT arg4 ;
14999  PLFLT arg5 ;
15000  PLFLT arg6 ;
15001  PLFLT arg7 ;
15002  PLFLT arg8 ;
15003  PLFLT arg9 ;
15004  PLFLT arg10 ;
15005  PLFLT arg11 ;
15006  pltr_func arg12 = (pltr_func) 0 ;
15007  PLPointer arg13 = (PLPointer) 0 ;
15008  PyArrayObject *tmp1 = NULL ;
15009  double val4 ;
15010  int ecode4 = 0 ;
15011  double val5 ;
15012  int ecode5 = 0 ;
15013  double val6 ;
15014  int ecode6 = 0 ;
15015  double val7 ;
15016  int ecode7 = 0 ;
15017  double val8 ;
15018  int ecode8 = 0 ;
15019  double val9 ;
15020  int ecode9 = 0 ;
15021  double val10 ;
15022  int ecode10 = 0 ;
15023  double val11 ;
15024  int ecode11 = 0 ;
15025  PyObject * obj0 = 0 ;
15026  PyObject * obj1 = 0 ;
15027  PyObject * obj2 = 0 ;
15028  PyObject * obj3 = 0 ;
15029  PyObject * obj4 = 0 ;
15030  PyObject * obj5 = 0 ;
15031  PyObject * obj6 = 0 ;
15032  PyObject * obj7 = 0 ;
15033  PyObject * obj8 = 0 ;
15034  PyObject * obj9 = 0 ;
15035  PyObject * obj10 = 0 ;
15036 
15037  {
15038  python_pltr = 0;
15039  arg12 = NULL;
15040  }
15041  {
15042  arg13 = NULL;
15043  }
15044  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
15045  {
15046  int i, size;
15047  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15048  if ( tmp1 == NULL )
15049  return NULL;
15050  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15051  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15052  size = arg3;
15053  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15054  for ( i = 0; i < arg2; i++ )
15055  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15056  }
15057  ecode4 = SWIG_AsVal_double(obj1, &val4);
15058  if (!SWIG_IsOK(ecode4)) {
15059  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15060  }
15061  arg4 = (PLFLT)(val4);
15062  ecode5 = SWIG_AsVal_double(obj2, &val5);
15063  if (!SWIG_IsOK(ecode5)) {
15064  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15065  }
15066  arg5 = (PLFLT)(val5);
15067  ecode6 = SWIG_AsVal_double(obj3, &val6);
15068  if (!SWIG_IsOK(ecode6)) {
15069  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15070  }
15071  arg6 = (PLFLT)(val6);
15072  ecode7 = SWIG_AsVal_double(obj4, &val7);
15073  if (!SWIG_IsOK(ecode7)) {
15074  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15075  }
15076  arg7 = (PLFLT)(val7);
15077  ecode8 = SWIG_AsVal_double(obj5, &val8);
15078  if (!SWIG_IsOK(ecode8)) {
15079  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15080  }
15081  arg8 = (PLFLT)(val8);
15082  ecode9 = SWIG_AsVal_double(obj6, &val9);
15083  if (!SWIG_IsOK(ecode9)) {
15084  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15085  }
15086  arg9 = (PLFLT)(val9);
15087  ecode10 = SWIG_AsVal_double(obj7, &val10);
15088  if (!SWIG_IsOK(ecode10)) {
15089  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15090  }
15091  arg10 = (PLFLT)(val10);
15092  ecode11 = SWIG_AsVal_double(obj8, &val11);
15093  if (!SWIG_IsOK(ecode11)) {
15094  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15095  }
15096  arg11 = (PLFLT)(val11);
15097  if (obj9) {
15098  {
15099  // it must be a callable or None
15100  if ( obj9 == Py_None )
15101  {
15102  arg12 = NULL;
15103  }
15104  else
15105  {
15106  if ( !PyCallable_Check( (PyObject *) obj9 ) )
15107  {
15108  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15109  return NULL;
15110  }
15111  arg12 = marshal_pltr( obj9 );
15112  }
15113  }
15114  }
15115  if (obj10) {
15116  {
15117  if ( obj10 == Py_None )
15118  arg13 = NULL;
15119  else
15120  {
15121  arg13 = marshal_PLPointer( obj10, 1 );
15122  }
15123  }
15124  }
15125  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15126  resultobj = SWIG_Py_Void();
15127  {
15128  Py_CLEAR( tmp1 );
15129  free( arg1 );
15130  }
15131  {
15132  cleanup_pltr();
15133  }
15134  {
15136  }
15137  return resultobj;
15138 fail:
15139  {
15140  Py_CLEAR( tmp1 );
15141  free( arg1 );
15142  }
15143  {
15144  cleanup_pltr();
15145  }
15146  {
15148  }
15149  return NULL;
15150 }
15151 
15152 
15153 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15154  PyObject *resultobj = 0;
15155 
15156  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
15157  plClearOpts();
15158  resultobj = SWIG_Py_Void();
15159  return resultobj;
15160 fail:
15161  return NULL;
15162 }
15163 
15164 
15165 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166  PyObject *resultobj = 0;
15167 
15168  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
15169  plResetOpts();
15170  resultobj = SWIG_Py_Void();
15171  return resultobj;
15172 fail:
15173  return NULL;
15174 }
15175 
15176 
15177 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15178  PyObject *resultobj = 0;
15179  char *arg1 = (char *) 0 ;
15180  char *arg2 = (char *) 0 ;
15181  int res1 ;
15182  char *buf1 = 0 ;
15183  int alloc1 = 0 ;
15184  int res2 ;
15185  char *buf2 = 0 ;
15186  int alloc2 = 0 ;
15187  PyObject * obj0 = 0 ;
15188  PyObject * obj1 = 0 ;
15189 
15190  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
15191  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
15192  if (!SWIG_IsOK(res1)) {
15193  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15194  }
15195  arg1 = (char *)(buf1);
15196  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15197  if (!SWIG_IsOK(res2)) {
15198  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15199  }
15200  arg2 = (char *)(buf2);
15201  plSetUsage((char const *)arg1,(char const *)arg2);
15202  resultobj = SWIG_Py_Void();
15203  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15204  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15205  return resultobj;
15206 fail:
15207  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15208  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15209  return NULL;
15210 }
15211 
15212 
15213 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15214  PyObject *resultobj = 0;
15215 
15216  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
15217  plOptUsage();
15218  resultobj = SWIG_Py_Void();
15219  return resultobj;
15220 fail:
15221  return NULL;
15222 }
15223 
15224 
15225 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226  PyObject *resultobj = 0;
15227  PLFLT **arg1 = (PLFLT **) 0 ;
15228  PLINT arg2 ;
15229  PLINT arg3 ;
15230  PLFLT *arg4 = (PLFLT *) 0 ;
15231  PLFLT *arg5 = (PLFLT *) 0 ;
15232  PyArrayObject *tmp1 = NULL ;
15233  PLFLT temp4 ;
15234  int res4 = SWIG_TMPOBJ ;
15235  PLFLT temp5 ;
15236  int res5 = SWIG_TMPOBJ ;
15237  PyObject * obj0 = 0 ;
15238 
15239  arg4 = &temp4;
15240  arg5 = &temp5;
15241  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
15242  {
15243  int i, size;
15244  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15245  if ( tmp1 == NULL )
15246  return NULL;
15247  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15248  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15249  size = arg3;
15250  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15251  for ( i = 0; i < arg2; i++ )
15252  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15253  }
15254  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15255  resultobj = SWIG_Py_Void();
15256  if (SWIG_IsTmpObj(res4)) {
15257  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15258  } else {
15259  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15260  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15261  }
15262  if (SWIG_IsTmpObj(res5)) {
15263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15264  } else {
15265  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15267  }
15268  {
15269  Py_CLEAR( tmp1 );
15270  free( arg1 );
15271  }
15272  return resultobj;
15273 fail:
15274  {
15275  Py_CLEAR( tmp1 );
15276  free( arg1 );
15277  }
15278  return NULL;
15279 }
15280 
15281 
15282 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15283  PyObject *resultobj = 0;
15284  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15285  void *argp1 = 0 ;
15286  int res1 = 0 ;
15287  PyObject * obj0 = 0 ;
15288  PLINT result;
15289 
15290  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
15291  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15292  if (!SWIG_IsOK(res1)) {
15293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15294  }
15295  arg1 = (PLGraphicsIn *)(argp1);
15296  result = (PLINT)plGetCursor(arg1);
15297  resultobj = SWIG_From_int((int)(result));
15298  return resultobj;
15299 fail:
15300  return NULL;
15301 }
15302 
15303 
15304 static PyMethodDef SwigMethods[] = {
15305  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
15306  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15307  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15308  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15309  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15310  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
15311  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15312  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
15313  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15314  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
15315  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15316  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
15317  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15318  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
15319  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15320  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
15321  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15322  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
15323  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15324  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
15325  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15326  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
15327  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15328  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
15329  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15330  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
15331  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15332  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
15333  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
15334  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
15335  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
15336  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
15337  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
15338  "Set format of numerical label for contours\n"
15339  "\n"
15340  "DESCRIPTION:\n"
15341  "\n"
15342  " Set format of numerical label for contours.\n"
15343  "\n"
15344  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15345  "\n"
15346  " This function is used example 9.\n"
15347  "\n"
15348  "\n"
15349  "\n"
15350  "SYNOPSIS:\n"
15351  "\n"
15352  "pl_setcontlabelformat(lexp, sigdig)\n"
15353  "\n"
15354  "ARGUMENTS:\n"
15355  "\n"
15356  " lexp (PLINT, input) : If the contour numerical label is greater\n"
15357  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15358  " format is used. Default value of lexp is 4.\n"
15359  "\n"
15360  " sigdig (PLINT, input) : Number of significant digits. Default\n"
15361  " value is 2.\n"
15362  "\n"
15363  ""},
15364  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
15365  "Set parameters of contour labelling other than format of numerical label\n"
15366  "\n"
15367  "DESCRIPTION:\n"
15368  "\n"
15369  " Set parameters of contour labelling other than those handled by\n"
15370  " pl_setcontlabelformat.\n"
15371  "\n"
15372  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15373  "\n"
15374  " This function is used in example 9.\n"
15375  "\n"
15376  "\n"
15377  "\n"
15378  "SYNOPSIS:\n"
15379  "\n"
15380  "pl_setcontlabelparam(offset, size, spacing, active)\n"
15381  "\n"
15382  "ARGUMENTS:\n"
15383  "\n"
15384  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15385  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15386  "\n"
15387  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15388  " Default value is 0.3.\n"
15389  "\n"
15390  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15391  " Default value is 0.1.\n"
15392  "\n"
15393  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15394  " contour labels on. Default is off (0).\n"
15395  "\n"
15396  ""},
15397  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
15398  "Advance the (sub-)page\n"
15399  "\n"
15400  "DESCRIPTION:\n"
15401  "\n"
15402  " Advances to the next subpage if sub=0, performing a page advance if\n"
15403  " there are no remaining subpages on the current page. If subpages\n"
15404  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15405  " PLplot switches to the specified subpage. Note that this allows you\n"
15406  " to overwrite a plot on the specified subpage; if this is not what you\n"
15407  " intended, use pleop followed by plbop to first advance the page. This\n"
15408  " routine is called automatically (with page=0) by plenv, but if plenv\n"
15409  " is not used, pladv must be called after initializing PLplot but before\n"
15410  " defining the viewport.\n"
15411  "\n"
15412  " Redacted form: pladv(page)\n"
15413  "\n"
15414  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15415  " 29, and 31.\n"
15416  "\n"
15417  "\n"
15418  "\n"
15419  "SYNOPSIS:\n"
15420  "\n"
15421  "pladv(page)\n"
15422  "\n"
15423  "ARGUMENTS:\n"
15424  "\n"
15425  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15426  " in the top left corner and increasing along the rows) to which to\n"
15427  " advance. Set to zero to advance to the next subpage (or to the\n"
15428  " next page if subpages are not being used).\n"
15429  "\n"
15430  ""},
15431  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
15432  "Draw a circular or elliptical arc\n"
15433  "\n"
15434  "DESCRIPTION:\n"
15435  "\n"
15436  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15437  " semiminor axis b, starting at angle1 and ending at angle2.\n"
15438  "\n"
15439  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15440  " fill)\n"
15441  "\n"
15442  "\n"
15443  " This function is used in examples 3 and 27.\n"
15444  "\n"
15445  "\n"
15446  "\n"
15447  "SYNOPSIS:\n"
15448  "\n"
15449  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15450  "\n"
15451  "ARGUMENTS:\n"
15452  "\n"
15453  " x (PLFLT, input) : X coordinate of arc center.\n"
15454  "\n"
15455  " y (PLFLT, input) : Y coordinate of arc center.\n"
15456  "\n"
15457  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15458  "\n"
15459  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15460  "\n"
15461  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15462  " semimajor axis.\n"
15463  "\n"
15464  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15465  " semimajor axis.\n"
15466  "\n"
15467  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15468  " X-axis.\n"
15469  "\n"
15470  " fill (PLBOOL, input) : Draw a filled arc.\n"
15471  "\n"
15472  ""},
15473  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
15474  "Draw a box with axes, etc. with arbitrary origin\n"
15475  "\n"
15476  "DESCRIPTION:\n"
15477  "\n"
15478  " Draws a box around the currently defined viewport with arbitrary\n"
15479  " world-coordinate origin specified by x0 and y0 and labels it with\n"
15480  " world coordinate values appropriate to the window. Thus plaxes should\n"
15481  " only be called after defining both viewport and window. The ascii\n"
15482  " character strings xopt and yopt specify how the box should be drawn as\n"
15483  " described below. If ticks and/or subticks are to be drawn for a\n"
15484  " particular axis, the tick intervals and number of subintervals may be\n"
15485  " specified explicitly, or they may be defaulted by setting the\n"
15486  " appropriate arguments to zero.\n"
15487  "\n"
15488  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15489  " ytick, nysub)\n"
15490  "\n"
15491  "\n"
15492  " This function is not used in any examples.\n"
15493  "\n"
15494  "\n"
15495  "\n"
15496  "SYNOPSIS:\n"
15497  "\n"
15498  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15499  "\n"
15500  "ARGUMENTS:\n"
15501  "\n"
15502  " x0 (PLFLT, input) : World X coordinate of origin.\n"
15503  "\n"
15504  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15505  "\n"
15506  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15507  " options for the x axis. The string can include any combination of\n"
15508  " the following letters (upper or lower case) in any order: a: Draws\n"
15509  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15510  " (x=0).\n"
15511  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15512  " c: Draws top (X) or right (Y) edge of frame.\n"
15513  " d: Plot labels as date / time. Values are assumed to be\n"
15514  " seconds since the epoch (as used by gmtime).\n"
15515  " f: Always use fixed point numeric labels.\n"
15516  " g: Draws a grid at the major tick interval.\n"
15517  " h: Draws a grid at the minor tick interval.\n"
15518  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15519  " inwards.\n"
15520  " l: Labels axis logarithmically. This only affects the labels,\n"
15521  " not the data, and so it is necessary to compute the logarithms\n"
15522  " of data points before passing them to any of the drawing\n"
15523  " routines.\n"
15524  " m: Writes numeric labels at major tick intervals in the\n"
15525  " unconventional location (above box for X, right of box for Y).\n"
15526  " n: Writes numeric labels at major tick intervals in the\n"
15527  " conventional location (below box for X, left of box for Y).\n"
15528  " o: Use custom labelling function to generate axis label text.\n"
15529  " The custom labelling function can be defined with the\n"
15530  " plslabelfunc command.\n"
15531  " s: Enables subticks between major ticks, only valid if t is\n"
15532  " also specified.\n"
15533  " t: Draws major ticks.\n"
15534  " u: Exactly like \"b\" except don't draw edge line.\n"
15535  " w: Exactly like \"c\" except don't draw edge line.\n"
15536  " x: Exactly like \"t\" (including the side effect of the\n"
15537  " numerical labels for the major ticks) except exclude drawing\n"
15538  " the major and minor tick marks.\n"
15539  "\n"
15540  "\n"
15541  " xtick (PLFLT, input) : World coordinate interval between major\n"
15542  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15543  " generates a suitable tick interval.\n"
15544  "\n"
15545  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15546  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15547  " generates a suitable minor tick interval.\n"
15548  "\n"
15549  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15550  " options for the y axis. The string can include any combination of\n"
15551  " the letters defined above for xopt, and in addition may contain:\n"
15552  " v: Write numeric labels for the y axis parallel to the base of the\n"
15553  " graph, rather than parallel to the axis.\n"
15554  "\n"
15555  "\n"
15556  " ytick (PLFLT, input) : World coordinate interval between major\n"
15557  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15558  " generates a suitable tick interval.\n"
15559  "\n"
15560  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15561  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15562  " generates a suitable minor tick interval.\n"
15563  "\n"
15564  ""},
15565  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
15566  "Plot a histogram from binned data\n"
15567  "\n"
15568  "DESCRIPTION:\n"
15569  "\n"
15570  " Plots a histogram consisting of nbin bins. The value associated with\n"
15571  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15572  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15573  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15574  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15575  " placed midway between the values in the x vector. Also see plhist for\n"
15576  " drawing histograms from unbinned data.\n"
15577  "\n"
15578  " Redacted form: General: plbin(x, y, opt)\n"
15579  " Python: plbin(nbin, x, y, opt)\n"
15580  "\n"
15581  "\n"
15582  " This function is not used in any examples.\n"
15583  "\n"
15584  "\n"
15585  "\n"
15586  "SYNOPSIS:\n"
15587  "\n"
15588  "plbin(nbin, x, y, opt)\n"
15589  "\n"
15590  "ARGUMENTS:\n"
15591  "\n"
15592  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15593  " and y vectors.)\n"
15594  "\n"
15595  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15596  " with bins. These must form a strictly increasing sequence.\n"
15597  "\n"
15598  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15599  " proportional to the number of points in each bin. This is a PLFLT\n"
15600  " (instead of PLINT) vector so as to allow histograms of\n"
15601  " probabilities, etc.\n"
15602  "\n"
15603  " opt (PLINT, input) : Is a combination of several flags:\n"
15604  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15605  " outer bins are expanded to fill up the entire x-axis and bins of\n"
15606  " zero height are simply drawn.\n"
15607  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15608  " between the x values. If the values in x are equally spaced,\n"
15609  " the values are the center values of the bins.\n"
15610  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15611  " size as the ones inside.\n"
15612  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15613  " (there is a gap for such bins).\n"
15614  "\n"
15615  ""},
15616  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15617  "Calculate broken-down time from continuous time for the current stream\n"
15618  "\n"
15619  "DESCRIPTION:\n"
15620  "\n"
15621  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15622  " continuous time, ctime for the current stream. This function is the\n"
15623  " inverse of plctime.\n"
15624  "\n"
15625  " The PLplot definition of broken-down time is a calendar time that\n"
15626  " completely ignores all time zone offsets, i.e., it is the user's\n"
15627  " responsibility to apply those offsets (if so desired) before using the\n"
15628  " PLplot time API. By default broken-down time is defined using the\n"
15629  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15630  " continuous time is defined as the number of seconds since the Unix\n"
15631  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15632  " broken-down and continuous time are possible, see plconfigtime.\n"
15633  "\n"
15634  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15635  " ctime)\n"
15636  "\n"
15637  "\n"
15638  " This function is used in example 29.\n"
15639  "\n"
15640  "\n"
15641  "\n"
15642  "SYNOPSIS:\n"
15643  "\n"
15644  "plbtime(year, month, day, hour, min, sec, ctime)\n"
15645  "\n"
15646  "ARGUMENTS:\n"
15647  "\n"
15648  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15649  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15650  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15651  " BCE, etc.)\n"
15652  "\n"
15653  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15654  " the year in the range from 0 (January) to 11 (December).\n"
15655  "\n"
15656  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15657  " month in the range from 1 to 31.\n"
15658  "\n"
15659  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15660  " day in the range from 0 to 23.\n"
15661  "\n"
15662  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15663  " hour in the range from 0 to 59\n"
15664  "\n"
15665  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15666  " minute in range from 0. to 60.\n"
15667  "\n"
15668  " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15669  " time is calculated.\n"
15670  "\n"
15671  ""},
15672  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15673  "Begin a new page\n"
15674  "\n"
15675  "DESCRIPTION:\n"
15676  "\n"
15677  " Begins a new page. For a file driver, the output file is opened if\n"
15678  " necessary. Advancing the page via pleop and plbop is useful when a\n"
15679  " page break is desired at a particular point when plotting to subpages.\n"
15680  " Another use for pleop and plbop is when plotting pages to different\n"
15681  " files, since you can manually set the file name by calling plsfnam\n"
15682  " after the call to pleop. (In fact some drivers may only support a\n"
15683  " single page per file, making this a necessity.) One way to handle\n"
15684  " this case automatically is to page advance via pladv, but enable\n"
15685  " familying (see plsfam) with a small limit on the file size so that a\n"
15686  " new family member file will be created on each page break.\n"
15687  "\n"
15688  " Redacted form: plbop()\n"
15689  "\n"
15690  " This function is used in examples 2 and 20.\n"
15691  "\n"
15692  "\n"
15693  "\n"
15694  "SYNOPSIS:\n"
15695  "\n"
15696  "plbop()\n"
15697  "\n"
15698  ""},
15699  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15700  "Draw a box with axes, etc\n"
15701  "\n"
15702  "DESCRIPTION:\n"
15703  "\n"
15704  " Draws a box around the currently defined viewport, and labels it with\n"
15705  " world coordinate values appropriate to the window. Thus plbox should\n"
15706  " only be called after defining both viewport and window. The ascii\n"
15707  " character strings xopt and yopt specify how the box should be drawn as\n"
15708  " described below. If ticks and/or subticks are to be drawn for a\n"
15709  " particular axis, the tick intervals and number of subintervals may be\n"
15710  " specified explicitly, or they may be defaulted by setting the\n"
15711  " appropriate arguments to zero.\n"
15712  "\n"
15713  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15714  "\n"
15715  "\n"
15716  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15717  " and 29.\n"
15718  "\n"
15719  "\n"
15720  "\n"
15721  "SYNOPSIS:\n"
15722  "\n"
15723  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15724  "\n"
15725  "ARGUMENTS:\n"
15726  "\n"
15727  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15728  " options for the x axis. The string can include any combination of\n"
15729  " the following letters (upper or lower case) in any order: a: Draws\n"
15730  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15731  " (x=0).\n"
15732  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15733  " c: Draws top (X) or right (Y) edge of frame.\n"
15734  " d: Plot labels as date / time. Values are assumed to be\n"
15735  " seconds since the epoch (as used by gmtime).\n"
15736  " f: Always use fixed point numeric labels.\n"
15737  " g: Draws a grid at the major tick interval.\n"
15738  " h: Draws a grid at the minor tick interval.\n"
15739  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15740  " inwards.\n"
15741  " l: Labels axis logarithmically. This only affects the labels,\n"
15742  " not the data, and so it is necessary to compute the logarithms\n"
15743  " of data points before passing them to any of the drawing\n"
15744  " routines.\n"
15745  " m: Writes numeric labels at major tick intervals in the\n"
15746  " unconventional location (above box for X, right of box for Y).\n"
15747  " n: Writes numeric labels at major tick intervals in the\n"
15748  " conventional location (below box for X, left of box for Y).\n"
15749  " o: Use custom labelling function to generate axis label text.\n"
15750  " The custom labelling function can be defined with the\n"
15751  " plslabelfunc command.\n"
15752  " s: Enables subticks between major ticks, only valid if t is\n"
15753  " also specified.\n"
15754  " t: Draws major ticks.\n"
15755  " u: Exactly like \"b\" except don't draw edge line.\n"
15756  " w: Exactly like \"c\" except don't draw edge line.\n"
15757  " x: Exactly like \"t\" (including the side effect of the\n"
15758  " numerical labels for the major ticks) except exclude drawing\n"
15759  " the major and minor tick marks.\n"
15760  "\n"
15761  "\n"
15762  " xtick (PLFLT, input) : World coordinate interval between major\n"
15763  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15764  " generates a suitable tick interval.\n"
15765  "\n"
15766  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15767  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15768  " generates a suitable minor tick interval.\n"
15769  "\n"
15770  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15771  " options for the y axis. The string can include any combination of\n"
15772  " the letters defined above for xopt, and in addition may contain:\n"
15773  " v: Write numeric labels for the y axis parallel to the base of the\n"
15774  " graph, rather than parallel to the axis.\n"
15775  "\n"
15776  "\n"
15777  " ytick (PLFLT, input) : World coordinate interval between major\n"
15778  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15779  " generates a suitable tick interval.\n"
15780  "\n"
15781  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15782  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15783  " generates a suitable minor tick interval.\n"
15784  "\n"
15785  ""},
15786  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15787  "Draw a box with axes, etc, in 3-d\n"
15788  "\n"
15789  "DESCRIPTION:\n"
15790  "\n"
15791  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15792  " plot. For a more complete description of three-dimensional plotting\n"
15793  " see the PLplot documentation.\n"
15794  "\n"
15795  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15796  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15797  "\n"
15798  "\n"
15799  " This function is used in examples 8, 11, 18, and 21.\n"
15800  "\n"
15801  "\n"
15802  "\n"
15803  "SYNOPSIS:\n"
15804  "\n"
15805  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15806  "\n"
15807  "ARGUMENTS:\n"
15808  "\n"
15809  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15810  " options for the x axis. The string can include any combination of\n"
15811  " the following letters (upper or lower case) in any order: b: Draws\n"
15812  " axis at base, at height z=\n"
15813  " zmin where zmin is defined by call to plw3d. This character must be\n"
15814  " specified in order to use any of the other options.\n"
15815  " d: Plot labels as date / time. Values are assumed to be\n"
15816  " seconds since the epoch (as used by gmtime).\n"
15817  " f: Always use fixed point numeric labels.\n"
15818  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15819  " than upwards.\n"
15820  " l: Labels axis logarithmically. This only affects the labels,\n"
15821  " not the data, and so it is necessary to compute the logarithms\n"
15822  " of data points before passing them to any of the drawing\n"
15823  " routines.\n"
15824  " n: Writes numeric labels at major tick intervals.\n"
15825  " o: Use custom labelling function to generate axis label text.\n"
15826  " The custom labelling function can be defined with the\n"
15827  " plslabelfunc command.\n"
15828  " s: Enables subticks between major ticks, only valid if t is\n"
15829  " also specified.\n"
15830  " t: Draws major ticks.\n"
15831  " u: If this is specified, the text label for the axis is\n"
15832  " written under the axis.\n"
15833  "\n"
15834  "\n"
15835  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15836  " the text label for the x axis. It is only drawn if u is in the\n"
15837  " xopt string.\n"
15838  "\n"
15839  " xtick (PLFLT, input) : World coordinate interval between major\n"
15840  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15841  " generates a suitable tick interval.\n"
15842  "\n"
15843  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15844  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15845  " generates a suitable minor tick interval.\n"
15846  "\n"
15847  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15848  " options for the y axis. The string is interpreted in the same way\n"
15849  " as xopt.\n"
15850  "\n"
15851  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15852  " the text label for the y axis. It is only drawn if u is in the\n"
15853  " yopt string.\n"
15854  "\n"
15855  " ytick (PLFLT, input) : World coordinate interval between major\n"
15856  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15857  " generates a suitable tick interval.\n"
15858  "\n"
15859  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15860  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15861  " generates a suitable minor tick interval.\n"
15862  "\n"
15863  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15864  " options for the z axis. The string can include any combination of\n"
15865  " the following letters (upper or lower case) in any order: b: Draws\n"
15866  " z axis to the left of the surface plot.\n"
15867  " c: Draws z axis to the right of the surface plot.\n"
15868  " d: Draws grid lines parallel to the x-y plane behind the\n"
15869  " figure. These lines are not drawn until after plot3d or\n"
15870  " plmesh are called because of the need for hidden line removal.\n"
15871  " e: Plot labels as date / time. Values are assumed to be\n"
15872  " seconds since the epoch (as used by gmtime). Note this\n"
15873  " suboption is interpreted the same as the d suboption for xopt\n"
15874  " and yopt, but it has to be identified as e for zopt since d\n"
15875  " has already been used for the different purpose above.\n"
15876  " f: Always use fixed point numeric labels.\n"
15877  " i: Inverts tick marks, so they are drawn away from the center.\n"
15878  " l: Labels axis logarithmically. This only affects the labels,\n"
15879  " not the data, and so it is necessary to compute the logarithms\n"
15880  " of data points before passing them to any of the drawing\n"
15881  " routines.\n"
15882  " m: Writes numeric labels at major tick intervals on the\n"
15883  " right-hand z axis.\n"
15884  " n: Writes numeric labels at major tick intervals on the\n"
15885  " left-hand z axis.\n"
15886  " o: Use custom labelling function to generate axis label text.\n"
15887  " The custom labelling function can be defined with the\n"
15888  " plslabelfunc command.\n"
15889  " s: Enables subticks between major ticks, only valid if t is\n"
15890  " also specified.\n"
15891  " t: Draws major ticks.\n"
15892  " u: If this is specified, the text label is written beside the\n"
15893  " left-hand axis.\n"
15894  " v: If this is specified, the text label is written beside the\n"
15895  " right-hand axis.\n"
15896  "\n"
15897  "\n"
15898  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15899  " the text label for the z axis. It is only drawn if u or v are in\n"
15900  " the zopt string.\n"
15901  "\n"
15902  " ztick (PLFLT, input) : World coordinate interval between major\n"
15903  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15904  " generates a suitable tick interval.\n"
15905  "\n"
15906  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15907  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15908  " generates a suitable minor tick interval.\n"
15909  "\n"
15910  ""},
15911  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15912  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15913  "\n"
15914  "DESCRIPTION:\n"
15915  "\n"
15916  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15917  " from relative device coordinates, rx and ry.\n"
15918  "\n"
15919  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15920  "\n"
15921  "\n"
15922  " This function is used in example 31.\n"
15923  "\n"
15924  "\n"
15925  "\n"
15926  "SYNOPSIS:\n"
15927  "\n"
15928  "plcalc_world(rx, ry, wx, wy, window)\n"
15929  "\n"
15930  "ARGUMENTS:\n"
15931  "\n"
15932  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15933  " the x coordinate.\n"
15934  "\n"
15935  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15936  " the y coordinate.\n"
15937  "\n"
15938  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15939  " coordinate corresponding to the relative device coordinates rx and\n"
15940  " ry.\n"
15941  "\n"
15942  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15943  " coordinate corresponding to the relative device coordinates rx and\n"
15944  " ry.\n"
15945  "\n"
15946  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15947  " defined window index that corresponds to the input relative device\n"
15948  " coordinates (and the returned world coordinates). To give some\n"
15949  " background on the window index, for each page the initial window\n"
15950  " index is set to zero, and each time plwind is called within the\n"
15951  " page, world and device coordinates are stored for the window and\n"
15952  " the window index is incremented. Thus, for a simple page layout\n"
15953  " with non-overlapping viewports and one window per viewport, window\n"
15954  " corresponds to the viewport index (in the order which the\n"
15955  " viewport/windows were created) of the only viewport/window\n"
15956  " corresponding to rx and ry. However, for more complicated layouts\n"
15957  " with potentially overlapping viewports and possibly more than one\n"
15958  " window (set of world coordinates) per viewport, window and the\n"
15959  " corresponding output world coordinates corresponds to the last\n"
15960  " window created that fulfills the criterion that the relative\n"
15961  " device coordinates are inside it. Finally, in all cases where the\n"
15962  " input relative device coordinates are not inside any\n"
15963  " viewport/window, then the returned value of the last defined\n"
15964  " window index is set to -1.\n"
15965  "\n"
15966  ""},
15967  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15968  "Clear current (sub)page\n"
15969  "\n"
15970  "DESCRIPTION:\n"
15971  "\n"
15972  " Clears the current page, effectively erasing everything that have been\n"
15973  " drawn. This command only works with interactive drivers; if the\n"
15974  " driver does not support this, the page is filled with the background\n"
15975  " color in use. If the current page is divided into subpages, only the\n"
15976  " current subpage is erased. The nth subpage can be selected with\n"
15977  " pladv(n).\n"
15978  "\n"
15979  " Redacted form: General: plclear()\n"
15980  "\n"
15981  "\n"
15982  " This function is not used in any examples.\n"
15983  "\n"
15984  "\n"
15985  "\n"
15986  "SYNOPSIS:\n"
15987  "\n"
15988  "plclear()\n"
15989  "\n"
15990  ""},
15991  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15992  "Set color, cmap0\n"
15993  "\n"
15994  "DESCRIPTION:\n"
15995  "\n"
15996  " Sets the color index for cmap0 (see the PLplot documentation).\n"
15997  "\n"
15998  " Redacted form: plcol0(icol0)\n"
15999  "\n"
16000  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16001  "\n"
16002  "\n"
16003  "\n"
16004  "SYNOPSIS:\n"
16005  "\n"
16006  "plcol0(icol0)\n"
16007  "\n"
16008  "ARGUMENTS:\n"
16009  "\n"
16010  " icol0 (PLINT, input) : Integer representing the color. The\n"
16011  " defaults at present are (these may change):\n"
16012  " 0 black (default background)\n"
16013  " 1 red (default foreground)\n"
16014  " 2 yellow\n"
16015  " 3 green\n"
16016  " 4 aquamarine\n"
16017  " 5 pink\n"
16018  " 6 wheat\n"
16019  " 7 grey\n"
16020  " 8 brown\n"
16021  " 9 blue\n"
16022  " 10 BlueViolet\n"
16023  " 11 cyan\n"
16024  " 12 turquoise\n"
16025  " 13 magenta\n"
16026  " 14 salmon\n"
16027  " 15 white\n"
16028  "\n"
16029  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16030  " change an individual color in the cmap0 color palette.\n"
16031  "\n"
16032  ""},
16033  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
16034  "Set color, cmap1\n"
16035  "\n"
16036  "DESCRIPTION:\n"
16037  "\n"
16038  " Sets the color for cmap1 (see the PLplot documentation).\n"
16039  "\n"
16040  " Redacted form: plcol1(col1)\n"
16041  "\n"
16042  " This function is used in examples 12 and 21.\n"
16043  "\n"
16044  "\n"
16045  "\n"
16046  "SYNOPSIS:\n"
16047  "\n"
16048  "plcol1(col1)\n"
16049  "\n"
16050  "ARGUMENTS:\n"
16051  "\n"
16052  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16053  " is mapped to color using the continuous cmap1 palette which by\n"
16054  " default ranges from blue to the background color to red. The\n"
16055  " cmap1 palette can also be straightforwardly changed by the user\n"
16056  " with plscmap1 or plscmap1l.\n"
16057  "\n"
16058  ""},
16059  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
16060  "Configure the transformation between continuous and broken-down time for the current stream\n"
16061  "\n"
16062  "DESCRIPTION:\n"
16063  "\n"
16064  " Configure the transformation between continuous and broken-down time\n"
16065  " for the current stream. This transformation is used by both plbtime\n"
16066  " and plctime.\n"
16067  "\n"
16068  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16069  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16070  "\n"
16071  "\n"
16072  " This function is used in example 29.\n"
16073  "\n"
16074  "\n"
16075  "\n"
16076  "SYNOPSIS:\n"
16077  "\n"
16078  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16079  "\n"
16080  "ARGUMENTS:\n"
16081  "\n"
16082  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16083  " As a special case, if\n"
16084  " scale is 0., then all other arguments are ignored, and the result (the\n"
16085  " default used by PLplot) is the equivalent of a call to\n"
16086  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16087  " That is, for this special case broken-down time is calculated with\n"
16088  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16089  " and the continuous time is defined as the number of seconds since\n"
16090  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16091  "\n"
16092  " offset1 (PLFLT, input) : If\n"
16093  " ifbtime_offset is true, the parameters\n"
16094  " offset1 and\n"
16095  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16096  " (with units in days) specify the epoch of the continuous time\n"
16097  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16098  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16099  " are used to specify the origin to allow users (by specifying\n"
16100  " offset1 as an integer that can be exactly represented by a\n"
16101  " floating-point variable and specifying\n"
16102  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16103  " the numerical errors of the continuous time representation.\n"
16104  "\n"
16105  " offset2 (PLFLT, input) : See documentation of\n"
16106  " offset1.\n"
16107  "\n"
16108  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16109  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16110  " calendar is used for broken-down time rather than the proleptic\n"
16111  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16112  " have been historically used to define UTC are inserted into the\n"
16113  " broken-down time. Other possibilities for additional control bits\n"
16114  " for ccontrol exist such as making the historical time corrections\n"
16115  " in the broken-down time corresponding to ET (ephemeris time) or\n"
16116  " making the (slightly non-constant) corrections from international\n"
16117  " atomic time (TAI) to what astronomers define as terrestrial time\n"
16118  " (TT). But those additional possibilities have not been\n"
16119  " implemented yet in the qsastime library (one of the PLplot utility\n"
16120  " libraries).\n"
16121  "\n"
16122  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16123  " epoch of the continuous time scale is specified by the user. If\n"
16124  " ifbtime_offset is false, then\n"
16125  " offset1 and\n"
16126  " offset2 are used to specify the epoch, and the following broken-down\n"
16127  " time parameters are completely ignored. If\n"
16128  " ifbtime_offset is true, then\n"
16129  " offset1 and\n"
16130  " offset2 are completely ignored, and the following broken-down time\n"
16131  " parameters are used to specify the epoch.\n"
16132  "\n"
16133  " year (PLINT, input) : Year of epoch.\n"
16134  "\n"
16135  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16136  " 11 (December).\n"
16137  "\n"
16138  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16139  "\n"
16140  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16141  "\n"
16142  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16143  "\n"
16144  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16145  "\n"
16146  ""},
16147  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
16148  "Contour plot\n"
16149  "\n"
16150  "DESCRIPTION:\n"
16151  "\n"
16152  " Draws a contour plot of the data in f[\n"
16153  " nx][\n"
16154  " ny], using the nlevel contour levels specified by clevel. Only the\n"
16155  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16156  " where all these index ranges are interpreted as one-based for\n"
16157  " historical reasons. A transformation routine pointed to by pltr with\n"
16158  " a generic pointer pltr_data for additional data required by the\n"
16159  " transformation routine is used to map indices within the matrix to the\n"
16160  " world coordinates.\n"
16161  "\n"
16162  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16163  " where (see above discussion) the pltr, pltr_data callback arguments\n"
16164  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16165  " vectors; or xg and yg matrices.\n"
16166  "\n"
16167  " This function is used in examples 9, 14, 16, and 22.\n"
16168  "\n"
16169  "\n"
16170  "\n"
16171  "SYNOPSIS:\n"
16172  "\n"
16173  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16174  "\n"
16175  "ARGUMENTS:\n"
16176  "\n"
16177  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16178  "\n"
16179  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16180  "\n"
16181  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16182  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16183  " zero-based for historical backwards-compatibility reasons.\n"
16184  "\n"
16185  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16186  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16187  " zero-based for historical backwards-compatibility reasons.\n"
16188  "\n"
16189  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16190  " which to draw contours.\n"
16191  "\n"
16192  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16193  "\n"
16194  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16195  " defines the transformation between the zero-based indices of the\n"
16196  " matrix f and the world coordinates.For the C case, transformation\n"
16197  " functions are provided in the PLplot library: pltr0 for the\n"
16198  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16199  " respectively defined by vectors and matrices. In addition, C\n"
16200  " callback routines for the transformation can be supplied by the\n"
16201  " user such as the mypltr function in examples/c/x09c.c which\n"
16202  " provides a general linear transformation between index coordinates\n"
16203  " and world coordinates.For languages other than C you should\n"
16204  " consult the PLplot documentation for the details concerning how\n"
16205  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16206  " general, a particular pattern of callback-associated arguments\n"
16207  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16208  " yg matrices are respectively interfaced to a linear-transformation\n"
16209  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16210  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16211  " the PLplot documentation) support native language callbacks for\n"
16212  " handling index to world-coordinate transformations. Examples of\n"
16213  " these various approaches are given in examples/<language>x09*,\n"
16214  " examples/<language>x16*, examples/<language>x20*,\n"
16215  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16216  " supported languages.\n"
16217  "\n"
16218  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16219  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16220  " that is externally supplied.\n"
16221  "\n"
16222  ""},
16223  { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
16224  "Calculate continuous time from broken-down time for the current stream\n"
16225  "\n"
16226  "DESCRIPTION:\n"
16227  "\n"
16228  " Calculate continuous time, ctime, from broken-down time for the\n"
16229  " current stream. The broken-down\n"
16230  " time is specified by the following parameters: year, month, day, hour,\n"
16231  " min, and sec. This function is the inverse of plbtime.\n"
16232  "\n"
16233  " The PLplot definition of broken-down time is a calendar time that\n"
16234  " completely ignores all time zone offsets, i.e., it is the user's\n"
16235  " responsibility to apply those offsets (if so desired) before using the\n"
16236  " PLplot time API. By default broken-down time is defined using the\n"
16237  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16238  " continuous time is defined as the number of seconds since the Unix\n"
16239  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16240  " broken-down and continuous time are possible, see plconfigtime which\n"
16241  " specifies that transformation for the current stream.\n"
16242  "\n"
16243  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16244  " ctime)\n"
16245  "\n"
16246  "\n"
16247  " This function is used in example 29.\n"
16248  "\n"
16249  "\n"
16250  "\n"
16251  "SYNOPSIS:\n"
16252  "\n"
16253  "plctime(year, month, day, hour, min, sec, ctime)\n"
16254  "\n"
16255  "ARGUMENTS:\n"
16256  "\n"
16257  " year (PLINT, input) : Input year.\n"
16258  "\n"
16259  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16260  " (December).\n"
16261  "\n"
16262  " day (PLINT, input) : Input day in range from 1 to 31.\n"
16263  "\n"
16264  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16265  "\n"
16266  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16267  "\n"
16268  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16269  "\n"
16270  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16271  " time calculated from the broken-down time specified by the\n"
16272  " previous parameters.\n"
16273  "\n"
16274  ""},
16275  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
16276  "Copy state parameters from the reference stream to the current stream\n"
16277  "\n"
16278  "DESCRIPTION:\n"
16279  "\n"
16280  " Copies state parameters from the reference stream to the current\n"
16281  " stream. Tell driver interface to map device coordinates unless flags\n"
16282  " == 1.\n"
16283  "\n"
16284  " This function is used for making save files of selected plots (e.g.\n"
16285  " from the TK driver). After initializing, you can get a copy of the\n"
16286  " current plot to the specified device by switching to this stream and\n"
16287  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16288  " appropriate. The plot buffer must have previously been enabled (done\n"
16289  " automatically by some display drivers, such as X).\n"
16290  "\n"
16291  " Redacted form: plcpstrm(iplsr, flags)\n"
16292  "\n"
16293  " This function is used in example 1,20.\n"
16294  "\n"
16295  "\n"
16296  "\n"
16297  "SYNOPSIS:\n"
16298  "\n"
16299  "plcpstrm(iplsr, flags)\n"
16300  "\n"
16301  "ARGUMENTS:\n"
16302  "\n"
16303  " iplsr (PLINT, input) : Number of reference stream.\n"
16304  "\n"
16305  " flags (PLBOOL, input) : If flags is set to true the device\n"
16306  " coordinates are not copied from the reference to current stream.\n"
16307  "\n"
16308  ""},
16309  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
16310  "End plotting session\n"
16311  "\n"
16312  "DESCRIPTION:\n"
16313  "\n"
16314  " Ends a plotting session, tidies up all the output files, switches\n"
16315  " interactive devices back into text mode and frees up any memory that\n"
16316  " was allocated. Must be called before end of program.\n"
16317  "\n"
16318  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16319  " wait state after a call to plend or other functions which trigger the\n"
16320  " end of a plot page. To avoid this, use the plspause function.\n"
16321  "\n"
16322  " Redacted form: plend()\n"
16323  "\n"
16324  " This function is used in all of the examples.\n"
16325  "\n"
16326  "\n"
16327  "\n"
16328  "SYNOPSIS:\n"
16329  "\n"
16330  "plend()\n"
16331  "\n"
16332  ""},
16333  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
16334  "End plotting session for current stream\n"
16335  "\n"
16336  "DESCRIPTION:\n"
16337  "\n"
16338  " Ends a plotting session for the current output stream only. See\n"
16339  " plsstrm for more info.\n"
16340  "\n"
16341  " Redacted form: plend1()\n"
16342  "\n"
16343  " This function is used in examples 1 and 20.\n"
16344  "\n"
16345  "\n"
16346  "\n"
16347  "SYNOPSIS:\n"
16348  "\n"
16349  "plend1()\n"
16350  "\n"
16351  ""},
16352  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
16353  "Set up standard window and draw box\n"
16354  "\n"
16355  "DESCRIPTION:\n"
16356  "\n"
16357  " Sets up plotter environment for simple graphs by calling pladv and\n"
16358  " setting up viewport and window to sensible default values. plenv\n"
16359  " leaves a standard margin (left-hand margin of eight character heights,\n"
16360  " and a margin around the other three sides of five character heights)\n"
16361  " around most graphs for axis labels and a title. When these defaults\n"
16362  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16363  " plvasp for setting up the viewport, plwind for defining the window,\n"
16364  " and plbox for drawing the box.\n"
16365  "\n"
16366  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16367  "\n"
16368  " This function is used in example 1,3,9,13,14,19-22,29.\n"
16369  "\n"
16370  "\n"
16371  "\n"
16372  "SYNOPSIS:\n"
16373  "\n"
16374  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16375  "\n"
16376  "ARGUMENTS:\n"
16377  "\n"
16378  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16379  " world coordinates).\n"
16380  "\n"
16381  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16382  " world coordinates).\n"
16383  "\n"
16384  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16385  " coordinates).\n"
16386  "\n"
16387  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16388  " coordinates).\n"
16389  "\n"
16390  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16391  " scales will not be set, the user must set up the scale before\n"
16392  " calling plenv using plsvpa, plvasp or other.\n"
16393  " 0: the x and y axes are scaled independently to use as much of\n"
16394  " the screen as possible.\n"
16395  " 1: the scales of the x and y axes are made equal.\n"
16396  " 2: the axis of the x and y axes are made equal, and the plot\n"
16397  " box will be square.\n"
16398  "\n"
16399  "\n"
16400  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16401  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16402  " -1: draw box only.\n"
16403  " 0: draw box, ticks, and numeric tick labels.\n"
16404  " 1: also draw coordinate axes at x=0 and y=0.\n"
16405  " 2: also draw a grid at major tick positions in both\n"
16406  " coordinates.\n"
16407  " 3: also draw a grid at minor tick positions in both\n"
16408  " coordinates.\n"
16409  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16410  " have to be converted to logarithms separately.)\n"
16411  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16412  " have to be converted to logarithms separately.)\n"
16413  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16414  " have to be converted to logarithms separately.)\n"
16415  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16416  " have to be converted to logarithms separately.)\n"
16417  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16418  " have to be converted to logarithms separately.)\n"
16419  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16420  " have to be converted to logarithms separately.)\n"
16421  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16422  " have to be converted to logarithms separately.)\n"
16423  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16424  " have to be converted to logarithms separately.)\n"
16425  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16426  " and y data have to be converted to logarithms separately.)\n"
16427  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16428  " and y data have to be converted to logarithms separately.)\n"
16429  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16430  " and y data have to be converted to logarithms separately.)\n"
16431  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16432  " and y data have to be converted to logarithms separately.)\n"
16433  " 40: same as 0 except date / time x labels.\n"
16434  " 41: same as 1 except date / time x labels.\n"
16435  " 42: same as 2 except date / time x labels.\n"
16436  " 43: same as 3 except date / time x labels.\n"
16437  " 50: same as 0 except date / time y labels.\n"
16438  " 51: same as 1 except date / time y labels.\n"
16439  " 52: same as 2 except date / time y labels.\n"
16440  " 53: same as 3 except date / time y labels.\n"
16441  " 60: same as 0 except date / time x and y labels.\n"
16442  " 61: same as 1 except date / time x and y labels.\n"
16443  " 62: same as 2 except date / time x and y labels.\n"
16444  " 63: same as 3 except date / time x and y labels.\n"
16445  " 70: same as 0 except custom x and y labels.\n"
16446  " 71: same as 1 except custom x and y labels.\n"
16447  " 72: same as 2 except custom x and y labels.\n"
16448  " 73: same as 3 except custom x and y labels.\n"
16449  "\n"
16450  ""},
16451  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
16452  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16453  "\n"
16454  "DESCRIPTION:\n"
16455  "\n"
16456  " Sets up plotter environment for simple graphs by calling pladv and\n"
16457  " setting up viewport and window to sensible default values. plenv0\n"
16458  " leaves a standard margin (left-hand margin of eight character heights,\n"
16459  " and a margin around the other three sides of five character heights)\n"
16460  " around most graphs for axis labels and a title. When these defaults\n"
16461  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16462  " plvasp for setting up the viewport, plwind for defining the window,\n"
16463  " and plbox for drawing the box.\n"
16464  "\n"
16465  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16466  "\n"
16467  " This function is used in example 21.\n"
16468  "\n"
16469  "\n"
16470  "\n"
16471  "SYNOPSIS:\n"
16472  "\n"
16473  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16474  "\n"
16475  "ARGUMENTS:\n"
16476  "\n"
16477  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16478  " world coordinates).\n"
16479  "\n"
16480  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16481  " world coordinates).\n"
16482  "\n"
16483  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16484  " coordinates).\n"
16485  "\n"
16486  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16487  " coordinates).\n"
16488  "\n"
16489  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16490  " scales will not be set, the user must set up the scale before\n"
16491  " calling plenv0 using plsvpa, plvasp or other.\n"
16492  " 0: the x and y axes are scaled independently to use as much of\n"
16493  " the screen as possible.\n"
16494  " 1: the scales of the x and y axes are made equal.\n"
16495  " 2: the axis of the x and y axes are made equal, and the plot\n"
16496  " box will be square.\n"
16497  "\n"
16498  "\n"
16499  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16500  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16501  " -1: draw box only.\n"
16502  " 0: draw box, ticks, and numeric tick labels.\n"
16503  " 1: also draw coordinate axes at x=0 and y=0.\n"
16504  " 2: also draw a grid at major tick positions in both\n"
16505  " coordinates.\n"
16506  " 3: also draw a grid at minor tick positions in both\n"
16507  " coordinates.\n"
16508  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16509  " have to be converted to logarithms separately.)\n"
16510  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16511  " have to be converted to logarithms separately.)\n"
16512  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16513  " have to be converted to logarithms separately.)\n"
16514  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16515  " have to be converted to logarithms separately.)\n"
16516  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16517  " have to be converted to logarithms separately.)\n"
16518  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16519  " have to be converted to logarithms separately.)\n"
16520  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16521  " have to be converted to logarithms separately.)\n"
16522  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16523  " have to be converted to logarithms separately.)\n"
16524  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16525  " and y data have to be converted to logarithms separately.)\n"
16526  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16527  " and y data have to be converted to logarithms separately.)\n"
16528  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16529  " and y data have to be converted to logarithms separately.)\n"
16530  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16531  " and y data have to be converted to logarithms separately.)\n"
16532  " 40: same as 0 except date / time x labels.\n"
16533  " 41: same as 1 except date / time x labels.\n"
16534  " 42: same as 2 except date / time x labels.\n"
16535  " 43: same as 3 except date / time x labels.\n"
16536  " 50: same as 0 except date / time y labels.\n"
16537  " 51: same as 1 except date / time y labels.\n"
16538  " 52: same as 2 except date / time y labels.\n"
16539  " 53: same as 3 except date / time y labels.\n"
16540  " 60: same as 0 except date / time x and y labels.\n"
16541  " 61: same as 1 except date / time x and y labels.\n"
16542  " 62: same as 2 except date / time x and y labels.\n"
16543  " 63: same as 3 except date / time x and y labels.\n"
16544  " 70: same as 0 except custom x and y labels.\n"
16545  " 71: same as 1 except custom x and y labels.\n"
16546  " 72: same as 2 except custom x and y labels.\n"
16547  " 73: same as 3 except custom x and y labels.\n"
16548  "\n"
16549  ""},
16550  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
16551  "Eject current page\n"
16552  "\n"
16553  "DESCRIPTION:\n"
16554  "\n"
16555  " Clears the graphics screen of an interactive device, or ejects a page\n"
16556  " on a plotter. See plbop for more information.\n"
16557  "\n"
16558  " Redacted form: pleop()\n"
16559  "\n"
16560  " This function is used in example 2,14.\n"
16561  "\n"
16562  "\n"
16563  "\n"
16564  "SYNOPSIS:\n"
16565  "\n"
16566  "pleop()\n"
16567  "\n"
16568  ""},
16569  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
16570  "Draw error bars in x direction\n"
16571  "\n"
16572  "DESCRIPTION:\n"
16573  "\n"
16574  " Draws a set of n error bars in x direction, the i'th error bar\n"
16575  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16576  " of the error bars are of length equal to the minor tick length\n"
16577  " (settable using plsmin).\n"
16578  "\n"
16579  " Redacted form: General: plerrx(xmin, ymax, y)\n"
16580  "\n"
16581  "\n"
16582  " This function is used in example 29.\n"
16583  "\n"
16584  "\n"
16585  "\n"
16586  "SYNOPSIS:\n"
16587  "\n"
16588  "plerrx(n, xmin, xmax, y)\n"
16589  "\n"
16590  "ARGUMENTS:\n"
16591  "\n"
16592  " n (PLINT, input) : Number of error bars to draw.\n"
16593  "\n"
16594  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16595  " of the left-hand endpoints of the error bars.\n"
16596  "\n"
16597  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16598  " of the right-hand endpoints of the error bars.\n"
16599  "\n"
16600  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16601  " the error bars.\n"
16602  "\n"
16603  ""},
16604  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
16605  "Draw error bars in the y direction\n"
16606  "\n"
16607  "DESCRIPTION:\n"
16608  "\n"
16609  " Draws a set of n error bars in the y direction, the i'th error bar\n"
16610  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16611  " of the error bars are of length equal to the minor tick length\n"
16612  " (settable using plsmin).\n"
16613  "\n"
16614  " Redacted form: General: plerry(x, ymin, ymax)\n"
16615  "\n"
16616  "\n"
16617  " This function is used in example 29.\n"
16618  "\n"
16619  "\n"
16620  "\n"
16621  "SYNOPSIS:\n"
16622  "\n"
16623  "plerry(n, x, ymin, ymax)\n"
16624  "\n"
16625  "ARGUMENTS:\n"
16626  "\n"
16627  " n (PLINT, input) : Number of error bars to draw.\n"
16628  "\n"
16629  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16630  " the error bars.\n"
16631  "\n"
16632  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16633  " of the lower endpoints of the error bars.\n"
16634  "\n"
16635  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16636  " of the upper endpoints of the error bars.\n"
16637  "\n"
16638  ""},
16639  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16640  "Advance to the next family file on the next new page\n"
16641  "\n"
16642  "DESCRIPTION:\n"
16643  "\n"
16644  " Advance to the next family file on the next new page.\n"
16645  "\n"
16646  " Redacted form: plfamadv()\n"
16647  "\n"
16648  " This function is not used in any examples.\n"
16649  "\n"
16650  "\n"
16651  "\n"
16652  "SYNOPSIS:\n"
16653  "\n"
16654  "plfamadv()\n"
16655  "\n"
16656  ""},
16657  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16658  "Draw filled polygon\n"
16659  "\n"
16660  "DESCRIPTION:\n"
16661  "\n"
16662  " Fills the polygon defined by the n points (\n"
16663  " x[i],\n"
16664  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16665  " style is a solid fill. The routine will automatically close the\n"
16666  " polygon between the last and first vertices. If multiple closed\n"
16667  " polygons are passed in x and y then plfill will fill in between them.\n"
16668  "\n"
16669  " Redacted form: plfill(x,y)\n"
16670  "\n"
16671  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16672  "\n"
16673  "\n"
16674  "\n"
16675  "SYNOPSIS:\n"
16676  "\n"
16677  "plfill(n, x, y)\n"
16678  "\n"
16679  "ARGUMENTS:\n"
16680  "\n"
16681  " n (PLINT, input) : Number of vertices in polygon.\n"
16682  "\n"
16683  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16684  " vertices.\n"
16685  "\n"
16686  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16687  " vertices.\n"
16688  "\n"
16689  ""},
16690  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16691  "Draw filled polygon in 3D\n"
16692  "\n"
16693  "DESCRIPTION:\n"
16694  "\n"
16695  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16696  " vectors using the pattern defined by plpsty or plpat. The routine\n"
16697  " will automatically close the polygon between the last and first\n"
16698  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16699  " plfill3 will fill in between them.\n"
16700  "\n"
16701  " Redacted form: General: plfill3(x, y, z)\n"
16702  "\n"
16703  "\n"
16704  " This function is used in example 15.\n"
16705  "\n"
16706  "\n"
16707  "\n"
16708  "SYNOPSIS:\n"
16709  "\n"
16710  "plfill3(n, x, y, z)\n"
16711  "\n"
16712  "ARGUMENTS:\n"
16713  "\n"
16714  " n (PLINT, input) : Number of vertices in polygon.\n"
16715  "\n"
16716  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16717  " vertices.\n"
16718  "\n"
16719  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16720  " vertices.\n"
16721  "\n"
16722  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16723  " vertices.\n"
16724  "\n"
16725  ""},
16726  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16727  "Draw linear gradient inside polygon\n"
16728  "\n"
16729  "DESCRIPTION:\n"
16730  "\n"
16731  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16732  " points (\n"
16733  " x[i],\n"
16734  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16735  " polygon coordinates and the gradient angle are all expressed in world\n"
16736  " coordinates. The angle from the x axis for both the rotated\n"
16737  " coordinate system and the gradient vector is specified by angle. The\n"
16738  " magnitude of the gradient vector is the difference between the maximum\n"
16739  " and minimum values of x for the vertices in the rotated coordinate\n"
16740  " system. The origin of the gradient vector can be interpreted as being\n"
16741  " anywhere on the line corresponding to the minimum x value for the\n"
16742  " vertices in the rotated coordinate system. The distance along the\n"
16743  " gradient vector is linearly transformed to the independent variable of\n"
16744  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16745  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16746  " color corresponding to the independent variable of cmap1. For more\n"
16747  " information about cmap1 (see the PLplot documentation).\n"
16748  "\n"
16749  " Redacted form: plgradient(x,y,angle)\n"
16750  "\n"
16751  " This function is used in examples 25 and 30.\n"
16752  "\n"
16753  "\n"
16754  "\n"
16755  "SYNOPSIS:\n"
16756  "\n"
16757  "plgradient(n, x, y, angle)\n"
16758  "\n"
16759  "ARGUMENTS:\n"
16760  "\n"
16761  " n (PLINT, input) : Number of vertices in polygon.\n"
16762  "\n"
16763  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16764  " vertices.\n"
16765  "\n"
16766  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16767  " vertices.\n"
16768  "\n"
16769  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16770  " axis.\n"
16771  "\n"
16772  ""},
16773  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16774  "Flushes the output stream\n"
16775  "\n"
16776  "DESCRIPTION:\n"
16777  "\n"
16778  " Flushes the output stream. Use sparingly, if at all.\n"
16779  "\n"
16780  " Redacted form: plflush()\n"
16781  "\n"
16782  " This function is used in examples 1 and 14.\n"
16783  "\n"
16784  "\n"
16785  "\n"
16786  "SYNOPSIS:\n"
16787  "\n"
16788  "plflush()\n"
16789  "\n"
16790  ""},
16791  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16792  "Set font\n"
16793  "\n"
16794  "DESCRIPTION:\n"
16795  "\n"
16796  " Sets the font used for subsequent text and symbols. For devices that\n"
16797  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16798  " fonts with extended character set are loaded (see plfontld). For\n"
16799  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16800  " this routine calls the plsfci routine with argument set up\n"
16801  " appropriately for the various cases below. However, this method of\n"
16802  " specifying the font for unicode-aware devices is deprecated, and the\n"
16803  " much more flexible method of calling plsfont directly is recommended\n"
16804  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16805  "\n"
16806  " Redacted form: plfont(ifont)\n"
16807  "\n"
16808  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16809  "\n"
16810  "\n"
16811  "\n"
16812  "SYNOPSIS:\n"
16813  "\n"
16814  "plfont(ifont)\n"
16815  "\n"
16816  "ARGUMENTS:\n"
16817  "\n"
16818  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16819  " (simplest and fastest)\n"
16820  " 2: Serif font\n"
16821  " 3: Italic font\n"
16822  " 4: Script font\n"
16823  "\n"
16824  ""},
16825  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16826  "Load Hershey fonts\n"
16827  "\n"
16828  "DESCRIPTION:\n"
16829  "\n"
16830  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16831  " be called before or after initializing PLplot. If not explicitly\n"
16832  " called before PLplot initialization, then by default that\n"
16833  " initialization loads Hershey fonts with the extended character set.\n"
16834  " This routine only has a practical effect for devices that still use\n"
16835  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16836  " system fonts instead of Hershey fonts).\n"
16837  "\n"
16838  " Redacted form: plfontld(fnt)\n"
16839  "\n"
16840  " This function is used in examples 1 and 7.\n"
16841  "\n"
16842  "\n"
16843  "\n"
16844  "SYNOPSIS:\n"
16845  "\n"
16846  "plfontld(fnt)\n"
16847  "\n"
16848  "ARGUMENTS:\n"
16849  "\n"
16850  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16851  " A zero value specifies Hershey fonts with the standard character\n"
16852  " set and a non-zero value (the default assumed if plfontld is never\n"
16853  " called) specifies Hershey fonts with the extended character set.\n"
16854  "\n"
16855  ""},
16856  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16857  "Get character default height and current (scaled) height\n"
16858  "\n"
16859  "DESCRIPTION:\n"
16860  "\n"
16861  " Get character default height and current (scaled) height.\n"
16862  "\n"
16863  " Redacted form: plgchr(p_def, p_ht)\n"
16864  "\n"
16865  " This function is used in example 23.\n"
16866  "\n"
16867  "\n"
16868  "\n"
16869  "SYNOPSIS:\n"
16870  "\n"
16871  "plgchr(p_def, p_ht)\n"
16872  "\n"
16873  "ARGUMENTS:\n"
16874  "\n"
16875  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16876  " character height (mm).\n"
16877  "\n"
16878  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16879  " character height (mm).\n"
16880  "\n"
16881  ""},
16882  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16883  "Returns 8-bit RGB values for given color index from cmap0\n"
16884  "\n"
16885  "DESCRIPTION:\n"
16886  "\n"
16887  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16888  " PLplot documentation). Values are negative if an invalid color id is\n"
16889  " given.\n"
16890  "\n"
16891  " Redacted form: plgcol0(icol0, r, g, b)\n"
16892  "\n"
16893  " This function is used in example 2.\n"
16894  "\n"
16895  "\n"
16896  "\n"
16897  "SYNOPSIS:\n"
16898  "\n"
16899  "plgcol0(icol0, r, g, b)\n"
16900  "\n"
16901  "ARGUMENTS:\n"
16902  "\n"
16903  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16904  "\n"
16905  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16906  " value.\n"
16907  "\n"
16908  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16909  " value.\n"
16910  "\n"
16911  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16912  " value.\n"
16913  "\n"
16914  ""},
16915  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16916  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16917  "\n"
16918  "DESCRIPTION:\n"
16919  "\n"
16920  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16921  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16922  " Values are negative if an invalid color id is given.\n"
16923  "\n"
16924  " Redacted form: plgcola(r, g, b)\n"
16925  "\n"
16926  " This function is used in example 30.\n"
16927  "\n"
16928  "\n"
16929  "\n"
16930  "SYNOPSIS:\n"
16931  "\n"
16932  "plgcol0a(icol0, r, g, b, alpha)\n"
16933  "\n"
16934  "ARGUMENTS:\n"
16935  "\n"
16936  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16937  "\n"
16938  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16939  " in the range from 0 to 255.\n"
16940  "\n"
16941  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16942  " in the range from 0 to 255.\n"
16943  "\n"
16944  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16945  " in the range from 0 to 255.\n"
16946  "\n"
16947  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16948  " transparency in the range from (0.0-1.0).\n"
16949  "\n"
16950  ""},
16951  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16952  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16953  "\n"
16954  "DESCRIPTION:\n"
16955  "\n"
16956  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16957  "\n"
16958  " Redacted form: plgcolbg(r, g, b)\n"
16959  "\n"
16960  " This function is used in example 31.\n"
16961  "\n"
16962  "\n"
16963  "\n"
16964  "SYNOPSIS:\n"
16965  "\n"
16966  "plgcolbg(r, g, b)\n"
16967  "\n"
16968  "ARGUMENTS:\n"
16969  "\n"
16970  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16971  " in the range from 0 to 255.\n"
16972  "\n"
16973  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16974  " in the range from 0 to 255.\n"
16975  "\n"
16976  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16977  " in the range from 0 to 255.\n"
16978  "\n"
16979  ""},
16980  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16981  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16982  "\n"
16983  "DESCRIPTION:\n"
16984  "\n"
16985  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16986  " alpha transparency value.\n"
16987  "\n"
16988  " This function is used in example 31.\n"
16989  "\n"
16990  "\n"
16991  "\n"
16992  "SYNOPSIS:\n"
16993  "\n"
16994  "plgcolbga(r, g, b, alpha)\n"
16995  "\n"
16996  "ARGUMENTS:\n"
16997  "\n"
16998  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16999  " in the range from 0 to 255.\n"
17000  "\n"
17001  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17002  " in the range from 0 to 255.\n"
17003  "\n"
17004  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17005  " in the range from 0 to 255.\n"
17006  "\n"
17007  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17008  " transparency in the range (0.0-1.0).\n"
17009  "\n"
17010  ""},
17011  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
17012  "Get the current device-compression setting\n"
17013  "\n"
17014  "DESCRIPTION:\n"
17015  "\n"
17016  " Get the current device-compression setting. This parameter is only\n"
17017  " used for drivers that provide compression.\n"
17018  "\n"
17019  " Redacted form: plgcompression(compression)\n"
17020  "\n"
17021  " This function is used in example 31.\n"
17022  "\n"
17023  "\n"
17024  "\n"
17025  "SYNOPSIS:\n"
17026  "\n"
17027  "plgcompression(compression)\n"
17028  "\n"
17029  "ARGUMENTS:\n"
17030  "\n"
17031  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17032  " compression setting for the current device.\n"
17033  "\n"
17034  ""},
17035  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
17036  "Get the current device (keyword) name\n"
17037  "\n"
17038  "DESCRIPTION:\n"
17039  "\n"
17040  " Get the current device (keyword) name. Note: you must have allocated\n"
17041  " space for this (80 characters is safe).\n"
17042  "\n"
17043  " Redacted form: plgdev(p_dev)\n"
17044  "\n"
17045  " This function is used in example 14.\n"
17046  "\n"
17047  "\n"
17048  "\n"
17049  "SYNOPSIS:\n"
17050  "\n"
17051  "plgdev(p_dev)\n"
17052  "\n"
17053  "ARGUMENTS:\n"
17054  "\n"
17055  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17056  " (with preallocated length of 80 characters or more) containing the\n"
17057  " device (keyword) name.\n"
17058  "\n"
17059  ""},
17060  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
17061  "Get parameters that define current device-space window\n"
17062  "\n"
17063  "DESCRIPTION:\n"
17064  "\n"
17065  " Get relative margin width, aspect ratio, and relative justification\n"
17066  " that define current device-space window. If plsdidev has not been\n"
17067  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17068  " p_jy will all be 0.\n"
17069  "\n"
17070  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17071  "\n"
17072  " This function is used in example 31.\n"
17073  "\n"
17074  "\n"
17075  "\n"
17076  "SYNOPSIS:\n"
17077  "\n"
17078  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17079  "\n"
17080  "ARGUMENTS:\n"
17081  "\n"
17082  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17083  " margin width.\n"
17084  "\n"
17085  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17086  " ratio.\n"
17087  "\n"
17088  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17089  " justification in x.\n"
17090  "\n"
17091  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17092  " justification in y.\n"
17093  "\n"
17094  ""},
17095  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
17096  "Get plot orientation\n"
17097  "\n"
17098  "DESCRIPTION:\n"
17099  "\n"
17100  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17101  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17102  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17103  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17104  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17105  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17106  " not been called the default value pointed to by p_rot will be 0.\n"
17107  "\n"
17108  " Redacted form: plgdiori(p_rot)\n"
17109  "\n"
17110  " This function is not used in any examples.\n"
17111  "\n"
17112  "\n"
17113  "\n"
17114  "SYNOPSIS:\n"
17115  "\n"
17116  "plgdiori(p_rot)\n"
17117  "\n"
17118  "ARGUMENTS:\n"
17119  "\n"
17120  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17121  " parameter.\n"
17122  "\n"
17123  ""},
17124  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
17125  "Get parameters that define current plot-space window\n"
17126  "\n"
17127  "DESCRIPTION:\n"
17128  "\n"
17129  " Get relative minima and maxima that define current plot-space window.\n"
17130  " If plsdiplt has not been called the default values pointed to by\n"
17131  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17132  "\n"
17133  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17134  "\n"
17135  " This function is used in example 31.\n"
17136  "\n"
17137  "\n"
17138  "\n"
17139  "SYNOPSIS:\n"
17140  "\n"
17141  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17142  "\n"
17143  "ARGUMENTS:\n"
17144  "\n"
17145  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17146  " minimum in x.\n"
17147  "\n"
17148  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17149  " minimum in y.\n"
17150  "\n"
17151  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17152  " maximum in x.\n"
17153  "\n"
17154  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17155  " maximum in y.\n"
17156  "\n"
17157  ""},
17158  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
17159  "Get family file parameters\n"
17160  "\n"
17161  "DESCRIPTION:\n"
17162  "\n"
17163  " Gets information about current family file, if familying is enabled.\n"
17164  " See the PLplot documentation for more information.\n"
17165  "\n"
17166  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17167  "\n"
17168  " This function is used in examples 14 and 31.\n"
17169  "\n"
17170  "\n"
17171  "\n"
17172  "SYNOPSIS:\n"
17173  "\n"
17174  "plgfam(p_fam, p_num, p_bmax)\n"
17175  "\n"
17176  "ARGUMENTS:\n"
17177  "\n"
17178  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17179  " family flag value. If nonzero, familying is enabled for the\n"
17180  " current device.\n"
17181  "\n"
17182  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17183  " family file number.\n"
17184  "\n"
17185  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17186  " file size (in bytes) for a family file.\n"
17187  "\n"
17188  ""},
17189  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
17190  "Get FCI (font characterization integer)\n"
17191  "\n"
17192  "DESCRIPTION:\n"
17193  "\n"
17194  " Gets information about the current font using the FCI approach. See\n"
17195  " the PLplot documentation for more information.\n"
17196  "\n"
17197  " Redacted form: plgfci(p_fci)\n"
17198  "\n"
17199  " This function is used in example 23.\n"
17200  "\n"
17201  "\n"
17202  "\n"
17203  "SYNOPSIS:\n"
17204  "\n"
17205  "plgfci(p_fci)\n"
17206  "\n"
17207  "ARGUMENTS:\n"
17208  "\n"
17209  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17210  " FCI value.\n"
17211  "\n"
17212  ""},
17213  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
17214  "Get output file name\n"
17215  "\n"
17216  "DESCRIPTION:\n"
17217  "\n"
17218  " Gets the current output file name, if applicable.\n"
17219  "\n"
17220  " Redacted form: plgfnam(fnam)\n"
17221  "\n"
17222  " This function is used in example 31.\n"
17223  "\n"
17224  "\n"
17225  "\n"
17226  "SYNOPSIS:\n"
17227  "\n"
17228  "plgfnam(fnam)\n"
17229  "\n"
17230  "ARGUMENTS:\n"
17231  "\n"
17232  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17233  " (with preallocated length of 80 characters or more) containing the\n"
17234  " file name.\n"
17235  "\n"
17236  ""},
17237  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
17238  "Get family, style and weight of the current font\n"
17239  "\n"
17240  "DESCRIPTION:\n"
17241  "\n"
17242  " Gets information about current font. See the PLplot documentation for\n"
17243  " more information on font selection.\n"
17244  "\n"
17245  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17246  "\n"
17247  " This function is used in example 23.\n"
17248  "\n"
17249  "\n"
17250  "\n"
17251  "SYNOPSIS:\n"
17252  "\n"
17253  "plgfont(p_family, p_style, p_weight)\n"
17254  "\n"
17255  "ARGUMENTS:\n"
17256  "\n"
17257  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17258  " font family. The available values are given by the PL_FCI_*\n"
17259  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17260  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17261  " p_family is NULL then the font family is not returned.\n"
17262  "\n"
17263  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17264  " font style. The available values are given by the PL_FCI_*\n"
17265  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17266  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17267  " style is not returned.\n"
17268  "\n"
17269  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17270  " font weight. The available values are given by the PL_FCI_*\n"
17271  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17272  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17273  " returned.\n"
17274  "\n"
17275  ""},
17276  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
17277  "Get the (current) run level\n"
17278  "\n"
17279  "DESCRIPTION:\n"
17280  "\n"
17281  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17282  " 1, initialized\n"
17283  " 2, viewport defined\n"
17284  " 3, world coordinates defined\n"
17285  "\n"
17286  "\n"
17287  " Redacted form: plglevel(p_level)\n"
17288  "\n"
17289  " This function is used in example 31.\n"
17290  "\n"
17291  "\n"
17292  "\n"
17293  "SYNOPSIS:\n"
17294  "\n"
17295  "plglevel(p_level)\n"
17296  "\n"
17297  "ARGUMENTS:\n"
17298  "\n"
17299  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17300  " level.\n"
17301  "\n"
17302  ""},
17303  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
17304  "Get page parameters\n"
17305  "\n"
17306  "DESCRIPTION:\n"
17307  "\n"
17308  " Gets the current page configuration. The length and offset values are\n"
17309  " expressed in units that are specific to the current driver. For\n"
17310  " instance: screen drivers will usually interpret them as number of\n"
17311  " pixels, whereas printer drivers will usually use mm.\n"
17312  "\n"
17313  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17314  "\n"
17315  " This function is used in examples 14 and 31.\n"
17316  "\n"
17317  "\n"
17318  "\n"
17319  "SYNOPSIS:\n"
17320  "\n"
17321  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17322  "\n"
17323  "ARGUMENTS:\n"
17324  "\n"
17325  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17326  " pixels/inch (DPI) in x.\n"
17327  "\n"
17328  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17329  " pixels/inch (DPI) in y.\n"
17330  "\n"
17331  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17332  " length.\n"
17333  "\n"
17334  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17335  " length.\n"
17336  "\n"
17337  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17338  " offset.\n"
17339  "\n"
17340  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17341  " offset.\n"
17342  "\n"
17343  ""},
17344  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
17345  "Switch to graphics screen\n"
17346  "\n"
17347  "DESCRIPTION:\n"
17348  "\n"
17349  " Sets an interactive device to graphics mode, used in conjunction with\n"
17350  " pltext to allow graphics and text to be interspersed. On a device\n"
17351  " which supports separate text and graphics windows, this command causes\n"
17352  " control to be switched to the graphics window. If already in graphics\n"
17353  " mode, this command is ignored. It is also ignored on devices which\n"
17354  " only support a single window or use a different method for shifting\n"
17355  " focus. See also pltext.\n"
17356  "\n"
17357  " Redacted form: plgra()\n"
17358  "\n"
17359  " This function is used in example 1.\n"
17360  "\n"
17361  "\n"
17362  "\n"
17363  "SYNOPSIS:\n"
17364  "\n"
17365  "plgra()\n"
17366  "\n"
17367  ""},
17368  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
17369  "Grid data from irregularly sampled data\n"
17370  "\n"
17371  "DESCRIPTION:\n"
17372  "\n"
17373  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17374  " require data organized as a grid, i.e., with x sample point values\n"
17375  " independent of y coordinate and vice versa. This function takes\n"
17376  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17377  " vectors; reads the desired grid location from the input vectors\n"
17378  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17379  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17380  " interpolate the data to the grid is specified with the argument type\n"
17381  " which can have one parameter specified in argument data.\n"
17382  "\n"
17383  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17384  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17385  "\n"
17386  "\n"
17387  " This function is used in example 21.\n"
17388  "\n"
17389  "\n"
17390  "\n"
17391  "SYNOPSIS:\n"
17392  "\n"
17393  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17394  "\n"
17395  "ARGUMENTS:\n"
17396  "\n"
17397  " x (PLFLT_VECTOR, input) : The input x vector.\n"
17398  "\n"
17399  " y (PLFLT_VECTOR, input) : The input y vector.\n"
17400  "\n"
17401  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17402  " y[i], z[i] represents one data sample coordinate.\n"
17403  "\n"
17404  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17405  " vectors.\n"
17406  "\n"
17407  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17408  " in the x direction. Usually xg has nptsx equally spaced values\n"
17409  " from the minimum to the maximum values of the x input vector.\n"
17410  "\n"
17411  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17412  "\n"
17413  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17414  " in the y direction. Similar to the xg parameter.\n"
17415  "\n"
17416  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17417  "\n"
17418  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17419  " where data lies in the grid specified by xg and yg. Therefore the\n"
17420  " zg matrix must be dimensioned\n"
17421  " nptsx by\n"
17422  " nptsy.\n"
17423  "\n"
17424  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17425  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17426  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17427  " GRID_NNI: Natural Neighbors Interpolation\n"
17428  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17429  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17430  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17431  " Weighted\n"
17432  " For details of the algorithms read the source file plgridd.c.\n"
17433  "\n"
17434  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17435  " which can be specified through this argument. Currently, for\n"
17436  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17437  " use, the lower the value, the noisier (more local) the\n"
17438  " approximation is.\n"
17439  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17440  " range [1. .. 2.]. High values enable the usage of very thin\n"
17441  " triangles for interpolation, possibly resulting in error in\n"
17442  " the approximation.\n"
17443  " GRID_NNI, only weights greater than data will be accepted. If\n"
17444  " 0, all weights will be accepted.\n"
17445  "\n"
17446  ""},
17447  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
17448  "Get current subpage parameters\n"
17449  "\n"
17450  "DESCRIPTION:\n"
17451  "\n"
17452  " Gets the size of the current subpage in millimeters measured from the\n"
17453  " bottom left hand corner of the output device page or screen. Can be\n"
17454  " used in conjunction with plsvpa for setting the size of a viewport in\n"
17455  " absolute coordinates (millimeters).\n"
17456  "\n"
17457  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17458  "\n"
17459  " This function is used in example 23.\n"
17460  "\n"
17461  "\n"
17462  "\n"
17463  "SYNOPSIS:\n"
17464  "\n"
17465  "plgspa(xmin, xmax, ymin, ymax)\n"
17466  "\n"
17467  "ARGUMENTS:\n"
17468  "\n"
17469  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17470  " the left hand edge of the subpage in millimeters.\n"
17471  "\n"
17472  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17473  " the right hand edge of the subpage in millimeters.\n"
17474  "\n"
17475  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17476  " the bottom edge of the subpage in millimeters.\n"
17477  "\n"
17478  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17479  " the top edge of the subpage in millimeters.\n"
17480  "\n"
17481  ""},
17482  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
17483  "Get current stream number\n"
17484  "\n"
17485  "DESCRIPTION:\n"
17486  "\n"
17487  " Gets the number of the current output stream. See also plsstrm.\n"
17488  "\n"
17489  " Redacted form: plgstrm(p_strm)\n"
17490  "\n"
17491  " This function is used in example 1,20.\n"
17492  "\n"
17493  "\n"
17494  "\n"
17495  "SYNOPSIS:\n"
17496  "\n"
17497  "plgstrm(p_strm)\n"
17498  "\n"
17499  "ARGUMENTS:\n"
17500  "\n"
17501  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17502  " stream value.\n"
17503  "\n"
17504  ""},
17505  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
17506  "Get the current library version number\n"
17507  "\n"
17508  "DESCRIPTION:\n"
17509  "\n"
17510  " Get the current library version number. Note: you must have allocated\n"
17511  " space for this (80 characters is safe).\n"
17512  "\n"
17513  " Redacted form: plgver(p_ver)\n"
17514  "\n"
17515  " This function is used in example 1.\n"
17516  "\n"
17517  "\n"
17518  "\n"
17519  "SYNOPSIS:\n"
17520  "\n"
17521  "plgver(p_ver)\n"
17522  "\n"
17523  "ARGUMENTS:\n"
17524  "\n"
17525  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17526  " (with preallocated length of 80 characters or more) containing the\n"
17527  " PLplot version number.\n"
17528  "\n"
17529  ""},
17530  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
17531  "Get viewport limits in normalized device coordinates\n"
17532  "\n"
17533  "DESCRIPTION:\n"
17534  "\n"
17535  " Get viewport limits in normalized device coordinates.\n"
17536  "\n"
17537  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17538  "\n"
17539  "\n"
17540  " This function is used in example 31.\n"
17541  "\n"
17542  "\n"
17543  "\n"
17544  "SYNOPSIS:\n"
17545  "\n"
17546  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17547  "\n"
17548  "ARGUMENTS:\n"
17549  "\n"
17550  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17551  " viewport limit of the normalized device coordinate in x.\n"
17552  "\n"
17553  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17554  " viewport limit of the normalized device coordinate in x.\n"
17555  "\n"
17556  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17557  " viewport limit of the normalized device coordinate in y.\n"
17558  "\n"
17559  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17560  " viewport limit of the normalized device coordinate in y.\n"
17561  "\n"
17562  ""},
17563  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
17564  "Get viewport limits in world coordinates\n"
17565  "\n"
17566  "DESCRIPTION:\n"
17567  "\n"
17568  " Get viewport limits in world coordinates.\n"
17569  "\n"
17570  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17571  "\n"
17572  "\n"
17573  " This function is used in example 31.\n"
17574  "\n"
17575  "\n"
17576  "\n"
17577  "SYNOPSIS:\n"
17578  "\n"
17579  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17580  "\n"
17581  "ARGUMENTS:\n"
17582  "\n"
17583  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17584  " viewport limit of the world coordinate in x.\n"
17585  "\n"
17586  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17587  " viewport limit of the world coordinate in x.\n"
17588  "\n"
17589  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17590  " viewport limit of the world coordinate in y.\n"
17591  "\n"
17592  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17593  " viewport limit of the world coordinate in y.\n"
17594  "\n"
17595  ""},
17596  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
17597  "Get x axis parameters\n"
17598  "\n"
17599  "DESCRIPTION:\n"
17600  "\n"
17601  " Returns current values of the p_digmax and p_digits flags for the x\n"
17602  " axis. p_digits is updated after the plot is drawn, so this routine\n"
17603  " should only be called after the call to plbox (or plbox3) is complete.\n"
17604  " See the PLplot documentation for more information.\n"
17605  "\n"
17606  " Redacted form: plgxax(p_digmax, p_digits)\n"
17607  "\n"
17608  " This function is used in example 31.\n"
17609  "\n"
17610  "\n"
17611  "\n"
17612  "SYNOPSIS:\n"
17613  "\n"
17614  "plgxax(p_digmax, p_digits)\n"
17615  "\n"
17616  "ARGUMENTS:\n"
17617  "\n"
17618  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17619  " number of digits for the x axis. If nonzero, the printed label\n"
17620  " has been switched to a floating-point representation when the\n"
17621  " number of digits exceeds this value.\n"
17622  "\n"
17623  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17624  " number of digits for the numeric labels (x axis) from the last\n"
17625  " plot.\n"
17626  "\n"
17627  ""},
17628  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
17629  "Get y axis parameters\n"
17630  "\n"
17631  "DESCRIPTION:\n"
17632  "\n"
17633  " Identical to plgxax, except that arguments are flags for y axis. See\n"
17634  " the description of plgxax for more detail.\n"
17635  "\n"
17636  " Redacted form: plgyax(p_digmax, p_digits)\n"
17637  "\n"
17638  " This function is used in example 31.\n"
17639  "\n"
17640  "\n"
17641  "\n"
17642  "SYNOPSIS:\n"
17643  "\n"
17644  "plgyax(p_digmax, p_digits)\n"
17645  "\n"
17646  "ARGUMENTS:\n"
17647  "\n"
17648  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17649  " number of digits for the y axis. If nonzero, the printed label\n"
17650  " has been switched to a floating-point representation when the\n"
17651  " number of digits exceeds this value.\n"
17652  "\n"
17653  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17654  " number of digits for the numeric labels (y axis) from the last\n"
17655  " plot.\n"
17656  "\n"
17657  ""},
17658  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
17659  "Get z axis parameters\n"
17660  "\n"
17661  "DESCRIPTION:\n"
17662  "\n"
17663  " Identical to plgxax, except that arguments are flags for z axis. See\n"
17664  " the description of plgxax for more detail.\n"
17665  "\n"
17666  " Redacted form: plgzax(p_digmax, p_digits)\n"
17667  "\n"
17668  " This function is used in example 31.\n"
17669  "\n"
17670  "\n"
17671  "\n"
17672  "SYNOPSIS:\n"
17673  "\n"
17674  "plgzax(p_digmax, p_digits)\n"
17675  "\n"
17676  "ARGUMENTS:\n"
17677  "\n"
17678  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17679  " number of digits for the z axis. If nonzero, the printed label\n"
17680  " has been switched to a floating-point representation when the\n"
17681  " number of digits exceeds this value.\n"
17682  "\n"
17683  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17684  " number of digits for the numeric labels (z axis) from the last\n"
17685  " plot.\n"
17686  "\n"
17687  ""},
17688  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17689  "Plot a histogram from unbinned data\n"
17690  "\n"
17691  "DESCRIPTION:\n"
17692  "\n"
17693  " Plots a histogram from n data points stored in the data vector. This\n"
17694  " routine bins the data into nbin bins equally spaced between datmin and\n"
17695  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17696  " opt allows, among other things, the histogram either to be plotted in\n"
17697  " an existing window or causes plhist to call plenv with suitable limits\n"
17698  " before plotting the histogram.\n"
17699  "\n"
17700  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17701  "\n"
17702  " This function is used in example 5.\n"
17703  "\n"
17704  "\n"
17705  "\n"
17706  "SYNOPSIS:\n"
17707  "\n"
17708  "plhist(n, data, datmin, datmax, nbin, opt)\n"
17709  "\n"
17710  "ARGUMENTS:\n"
17711  "\n"
17712  " n (PLINT, input) : Number of data points.\n"
17713  "\n"
17714  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17715  " n data points.\n"
17716  "\n"
17717  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17718  "\n"
17719  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17720  "\n"
17721  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17722  " divide the interval xmin to xmax.\n"
17723  "\n"
17724  " opt (PLINT, input) : Is a combination of several flags:\n"
17725  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17726  " the histogram data, the outer bins are expanded to fill up the\n"
17727  " entire x-axis, data outside the given extremes are assigned to the\n"
17728  " outer bins and bins of zero height are simply drawn.\n"
17729  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17730  " to fit the histogram data, without this flag, plenv is called\n"
17731  " to set the world coordinates.\n"
17732  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17733  " extremes are not taken into account. This option should\n"
17734  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17735  " properly present the data.\n"
17736  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17737  " size as the ones inside.\n"
17738  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17739  " (there is a gap for such bins).\n"
17740  "\n"
17741  ""},
17742  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17743  "Convert HLS color to RGB\n"
17744  "\n"
17745  "DESCRIPTION:\n"
17746  "\n"
17747  " Convert HLS color coordinates to RGB.\n"
17748  "\n"
17749  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17750  "\n"
17751  "\n"
17752  " This function is used in example 2.\n"
17753  "\n"
17754  "\n"
17755  "\n"
17756  "SYNOPSIS:\n"
17757  "\n"
17758  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17759  "\n"
17760  "ARGUMENTS:\n"
17761  "\n"
17762  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17763  " cylinder.\n"
17764  "\n"
17765  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17766  " the axis of the color cylinder.\n"
17767  "\n"
17768  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17769  " the radius of the color cylinder.\n"
17770  "\n"
17771  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17772  " (0.0-1.0) of the color.\n"
17773  "\n"
17774  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17775  " intensity (0.0-1.0) of the color.\n"
17776  "\n"
17777  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17778  " intensity (0.0-1.0) of the color.\n"
17779  "\n"
17780  ""},
17781  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17782  "Initialize PLplot\n"
17783  "\n"
17784  "DESCRIPTION:\n"
17785  "\n"
17786  " Initializing the plotting package. The program prompts for the device\n"
17787  " keyword or number of the desired output device. Hitting a RETURN in\n"
17788  " response to the prompt is the same as selecting the first device.\n"
17789  " plinit will issue no prompt if either the device was specified\n"
17790  " previously (via command line flag, the plsetopt function, or the\n"
17791  " plsdev function), or if only one device is enabled when PLplot is\n"
17792  " installed. If subpages have been specified, the output device is\n"
17793  " divided into nx by ny subpages, each of which may be used\n"
17794  " independently. If plinit is called again during a program, the\n"
17795  " previously opened file will be closed. The subroutine pladv is used\n"
17796  " to advance from one subpage to the next.\n"
17797  "\n"
17798  " Redacted form: plinit()\n"
17799  "\n"
17800  " This function is used in all of the examples.\n"
17801  "\n"
17802  "\n"
17803  "\n"
17804  "SYNOPSIS:\n"
17805  "\n"
17806  "plinit()\n"
17807  "\n"
17808  ""},
17809  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17810  "Draw a line between two points\n"
17811  "\n"
17812  "DESCRIPTION:\n"
17813  "\n"
17814  " Joins the point (\n"
17815  " x1,\n"
17816  " y1) to (\n"
17817  " x2,\n"
17818  " y2).\n"
17819  "\n"
17820  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17821  "\n"
17822  " This function is used in examples 3 and 14.\n"
17823  "\n"
17824  "\n"
17825  "\n"
17826  "SYNOPSIS:\n"
17827  "\n"
17828  "pljoin(x1, y1, x2, y2)\n"
17829  "\n"
17830  "ARGUMENTS:\n"
17831  "\n"
17832  " x1 (PLFLT, input) : x coordinate of first point.\n"
17833  "\n"
17834  " y1 (PLFLT, input) : y coordinate of first point.\n"
17835  "\n"
17836  " x2 (PLFLT, input) : x coordinate of second point.\n"
17837  "\n"
17838  " y2 (PLFLT, input) : y coordinate of second point.\n"
17839  "\n"
17840  ""},
17841  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17842  "Simple routine to write labels\n"
17843  "\n"
17844  "DESCRIPTION:\n"
17845  "\n"
17846  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17847  "\n"
17848  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17849  "\n"
17850  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17851  "\n"
17852  "\n"
17853  "\n"
17854  "SYNOPSIS:\n"
17855  "\n"
17856  "pllab(xlabel, ylabel, tlabel)\n"
17857  "\n"
17858  "ARGUMENTS:\n"
17859  "\n"
17860  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17861  " the label for the x axis.\n"
17862  "\n"
17863  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17864  " the label for the y axis.\n"
17865  "\n"
17866  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17867  " the title of the plot.\n"
17868  "\n"
17869  ""},
17870  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17871  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17872  "\n"
17873  "DESCRIPTION:\n"
17874  "\n"
17875  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17876  " line, and/or line of symbols for each annotated legend entry. (See\n"
17877  " plcolorbar for similar functionality for creating continuous color\n"
17878  " bars.) The arguments of pllegend provide control over the location\n"
17879  " and size of the legend as well as the location and characteristics of\n"
17880  " the elements (most of which are optional) within that legend. The\n"
17881  " resulting legend is clipped at the boundaries of the current subpage.\n"
17882  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17883  " defined in the documentation of the position parameter.)\n"
17884  "\n"
17885  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17886  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17887  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17888  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17889  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17890  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17891  "\n"
17892  " This function is used in examples 4, 26, and 33.\n"
17893  "\n"
17894  "\n"
17895  "\n"
17896  "SYNOPSIS:\n"
17897  "\n"
17898  "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"
17899  "\n"
17900  "ARGUMENTS:\n"
17901  "\n"
17902  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17903  " legend width in adopted coordinates. This quantity is calculated\n"
17904  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17905  " the routine depending on nlegend and nrow), and the length\n"
17906  " (calculated internally) of the longest text string.\n"
17907  "\n"
17908  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17909  " legend height in adopted coordinates. This quantity is calculated\n"
17910  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17911  " the routine depending on nlegend and nrow).\n"
17912  "\n"
17913  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17914  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17915  " on the left of the legend and the plotted area on the right.\n"
17916  " Otherwise, put the text area on the right of the legend and the\n"
17917  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17918  " plot a (semitransparent) background for the legend. If the\n"
17919  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17920  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17921  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17922  " plot the resulting array of legend entries in row-major order.\n"
17923  " Otherwise, plot the legend entries in column-major order.\n"
17924  "\n"
17925  " position (PLINT, input) : position contains bits which control the\n"
17926  " overall position of the legend and the definition of the adopted\n"
17927  " coordinates used for positions just like what is done for the\n"
17928  " position argument for plcolorbar. However, note that the defaults\n"
17929  " for the position bits (see below) are different than the\n"
17930  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17931  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17932  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17933  " the 16 possible standard positions (the 4 corners and centers of\n"
17934  " the 4 sides for both the inside and outside cases) of the legend\n"
17935  " relative to the adopted coordinate system. The corner positions\n"
17936  " are specified by the appropriate combination of two of the\n"
17937  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17938  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17939  " value of one of those bits. The adopted coordinates are\n"
17940  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17941  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17942  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17943  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17944  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17945  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17946  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17947  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17948  "\n"
17949  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17950  " coordinates from the specified standard position of the legend.\n"
17951  " For positive x, the direction of motion away from the standard\n"
17952  " position is inward/outward from the standard corner positions or\n"
17953  " standard left or right positions if the\n"
17954  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17955  " For the standard top or bottom positions, the direction of motion\n"
17956  " is toward positive X.\n"
17957  "\n"
17958  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17959  " coordinates from the specified standard position of the legend.\n"
17960  " For positive y, the direction of motion away from the standard\n"
17961  " position is inward/outward from the standard corner positions or\n"
17962  " standard top or bottom positions if the\n"
17963  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17964  " the standard left or right positions, the direction of motion is\n"
17965  " toward positive Y.\n"
17966  "\n"
17967  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17968  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17969  " symbols are drawn) of the legend.\n"
17970  "\n"
17971  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17972  " legend (PL_LEGEND_BACKGROUND).\n"
17973  "\n"
17974  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17975  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17976  "\n"
17977  " bb_style (PLINT, input) : The pllsty style number for the\n"
17978  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17979  "\n"
17980  " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17981  " render the\n"
17982  " nlegend legend entries. For internal transformations of\n"
17983  " nrow, see further remarks under\n"
17984  " nlegend.\n"
17985  "\n"
17986  " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17987  " to render the\n"
17988  " nlegend legend entries. For internal transformations of\n"
17989  " ncolumn, see further remarks under\n"
17990  " nlegend.\n"
17991  "\n"
17992  " nlegend (PLINT, input) : Number of legend entries. The above\n"
17993  " nrow and\n"
17994  " ncolumn values are transformed internally to be consistent with\n"
17995  " nlegend. If either\n"
17996  " nrow or\n"
17997  " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17998  " of\n"
17999  " nrow and\n"
18000  " ncolumn is less than\n"
18001  " nlegend, the smaller of the two (or\n"
18002  " nrow, if\n"
18003  " nrow ==\n"
18004  " ncolumn) is increased so the product is >=\n"
18005  " nlegend. Thus, for example, the common\n"
18006  " nrow = 0,\n"
18007  " ncolumn = 0 case is transformed internally to\n"
18008  " nrow =\n"
18009  " nlegend,\n"
18010  " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18011  " column.\n"
18012  "\n"
18013  " opt_array (PLINT_VECTOR, input) : A vector of\n"
18014  " nlegend values of options to control each individual plotted area\n"
18015  " corresponding to a legend entry. If the\n"
18016  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18017  " area. If the\n"
18018  " PL_LEGEND_COLOR_BOX,\n"
18019  " PL_LEGEND_LINE, and/or\n"
18020  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18021  " entry is plotted with a colored box; a line; and/or a line of\n"
18022  " symbols.\n"
18023  "\n"
18024  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18025  " area in units of character width.\n"
18026  "\n"
18027  " text_scale (PLFLT, input) : Character height scale for text\n"
18028  " annotations.\n"
18029  "\n"
18030  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18031  " character height from one legend entry to the next.\n"
18032  "\n"
18033  " text_justification (PLFLT, input) : Justification parameter used\n"
18034  " for text justification. The most common values of\n"
18035  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18036  " is left justified, centred, or right justified within the text\n"
18037  " area, but other values are allowed as well.\n"
18038  "\n"
18039  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18040  " nlegend cmap0 text colors.\n"
18041  "\n"
18042  " text (PLCHAR_MATRIX, input) : A vector of\n"
18043  " nlegend UTF-8 character strings containing the legend annotations.\n"
18044  "\n"
18045  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18046  " nlegend cmap0 colors for the discrete colored boxes (\n"
18047  " PL_LEGEND_COLOR_BOX).\n"
18048  "\n"
18049  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18050  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18051  " PL_LEGEND_COLOR_BOX).\n"
18052  "\n"
18053  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18054  " nlegend scales (units of fraction of character height) for the height\n"
18055  " of the discrete colored boxes (\n"
18056  " PL_LEGEND_COLOR_BOX).\n"
18057  "\n"
18058  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18059  " nlegend line widths for the patterns specified by box_patterns (\n"
18060  " PL_LEGEND_COLOR_BOX).\n"
18061  "\n"
18062  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18063  " nlegend cmap0 line colors (\n"
18064  " PL_LEGEND_LINE).\n"
18065  "\n"
18066  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18067  " nlegend line styles (plsty indices) (\n"
18068  " PL_LEGEND_LINE).\n"
18069  "\n"
18070  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18071  " nlegend line widths (\n"
18072  " PL_LEGEND_LINE).\n"
18073  "\n"
18074  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18075  " nlegend cmap0 symbol colors (\n"
18076  " PL_LEGEND_SYMBOL).\n"
18077  "\n"
18078  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18079  " nlegend scale values for the symbol height (\n"
18080  " PL_LEGEND_SYMBOL).\n"
18081  "\n"
18082  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18083  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18084  " area (\n"
18085  " PL_LEGEND_SYMBOL).\n"
18086  "\n"
18087  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18088  " nlegend UTF-8 character strings containing the legend symbols. (\n"
18089  " PL_LEGEND_SYMBOL).\n"
18090  "\n"
18091  ""},
18092  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
18093  "Plot color bar for image, shade or gradient plots\n"
18094  "\n"
18095  "DESCRIPTION:\n"
18096  "\n"
18097  " Routine for creating a continuous color bar for image, shade, or\n"
18098  " gradient plots. (See pllegend for similar functionality for creating\n"
18099  " legends with discrete elements). The arguments of plcolorbar provide\n"
18100  " control over the location and size of the color bar as well as the\n"
18101  " location and characteristics of the elements (most of which are\n"
18102  " optional) within that color bar. The resulting color bar is clipped\n"
18103  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18104  " system used for some of the parameters is defined in the documentation\n"
18105  " of the position parameter.)\n"
18106  "\n"
18107  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18108  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18109  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18110  " labels, axis_opts, ticks, sub_ticks, values)\n"
18111  "\n"
18112  " This function is used in examples 16 and 33.\n"
18113  "\n"
18114  "\n"
18115  "\n"
18116  "SYNOPSIS:\n"
18117  "\n"
18118  "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"
18119  "\n"
18120  "ARGUMENTS:\n"
18121  "\n"
18122  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18123  " labelled and decorated color bar width in adopted coordinates.\n"
18124  "\n"
18125  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18126  " labelled and decorated color bar height in adopted coordinates.\n"
18127  "\n"
18128  " opt (PLINT, input) : opt contains bits controlling the overall\n"
18129  " color bar. The orientation (direction of the maximum value) of\n"
18130  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18131  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18132  " specified, the default orientation is toward the top if the\n"
18133  " colorbar is placed on the left or right of the viewport or toward\n"
18134  " the right if the colorbar is placed on the top or bottom of the\n"
18135  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18136  " (semitransparent) background for the color bar. If the\n"
18137  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18138  " color bar. The type of color bar must be specified with one of\n"
18139  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18140  " more than one of those bits is set only the first one in the above\n"
18141  " list is honored. The position of the (optional) label/title can be\n"
18142  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18143  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18144  " will be drawn. If more than one of this list of bits is specified,\n"
18145  " only the first one on the list is honored. End-caps for the color\n"
18146  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18147  " If a particular color bar cap option is not specified then no cap\n"
18148  " will be drawn for that end. As a special case for\n"
18149  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18150  " specified. If this option is provided then any tick marks and tick\n"
18151  " labels will be placed at the breaks between shaded segments. TODO:\n"
18152  " This should be expanded to support custom placement of tick marks\n"
18153  " and tick labels at custom value locations for any color bar type.\n"
18154  "\n"
18155  " position (PLINT, input) : position contains bits which control the\n"
18156  " overall position of the color bar and the definition of the\n"
18157  " adopted coordinates used for positions just like what is done for\n"
18158  " the position argument for pllegend. However, note that the\n"
18159  " defaults for the position bits (see below) are different than the\n"
18160  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18161  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18162  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18163  " the 16 possible standard positions (the 4 corners and centers of\n"
18164  " the 4 sides for both the inside and outside cases) of the color\n"
18165  " bar relative to the adopted coordinate system. The corner\n"
18166  " positions are specified by the appropriate combination of two of\n"
18167  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18168  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18169  " value of one of those bits. The adopted coordinates are\n"
18170  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18171  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18172  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18173  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18174  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18175  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18176  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18177  " PL_POSITION_VIEWPORT.\n"
18178  "\n"
18179  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18180  " coordinates from the specified standard position of the color bar.\n"
18181  " For positive x, the direction of motion away from the standard\n"
18182  " position is inward/outward from the standard corner positions or\n"
18183  " standard left or right positions if the\n"
18184  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18185  " For the standard top or bottom positions, the direction of motion\n"
18186  " is toward positive X.\n"
18187  "\n"
18188  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18189  " coordinates from the specified standard position of the color bar.\n"
18190  " For positive y, the direction of motion away from the standard\n"
18191  " position is inward/outward from the standard corner positions or\n"
18192  " standard top or bottom positions if the\n"
18193  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18194  " For the standard left or right positions, the direction of motion\n"
18195  " is toward positive Y.\n"
18196  "\n"
18197  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18198  " the X direction in adopted coordinates.\n"
18199  "\n"
18200  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18201  " the Y direction in adopted coordinates.\n"
18202  "\n"
18203  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18204  " color bar (PL_COLORBAR_BACKGROUND).\n"
18205  "\n"
18206  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18207  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18208  "\n"
18209  " bb_style (PLINT, input) : The pllsty style number for the\n"
18210  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18211  "\n"
18212  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18213  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18214  "\n"
18215  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18216  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18217  "\n"
18218  " cont_color (PLINT, input) : The cmap0 contour color for\n"
18219  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18220  " it will be interpreted according to the design of plshades.\n"
18221  "\n"
18222  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18223  " plots. This is passed directly to plshades, so it will be\n"
18224  " interpreted according to the design of plshades.\n"
18225  "\n"
18226  " n_labels (PLINT, input) : Number of labels to place around the\n"
18227  " color bar.\n"
18228  "\n"
18229  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18230  " n_labels labels.\n"
18231  "\n"
18232  " labels (PLCHAR_MATRIX, input) : A vector of\n"
18233  " n_labels UTF-8 character strings containing the labels for the color\n"
18234  " bar. Ignored if no label position is specified with one of the\n"
18235  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18236  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18237  " corresponding label_opts field.\n"
18238  "\n"
18239  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18240  " value must be greater than 0. It is typically 1 (numerical axis\n"
18241  " labels are provided for one of the long edges of the color bar),\n"
18242  " but it can be larger if multiple numerical axis labels for the\n"
18243  " long edges of the color bar are desired.\n"
18244  "\n"
18245  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18246  " n_axes ascii character strings containing options (interpreted as for\n"
18247  " plbox) for the color bar's axis definitions.\n"
18248  "\n"
18249  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18250  " spacing of the major tick marks (interpreted as for plbox) for the\n"
18251  " color bar's axis definitions.\n"
18252  "\n"
18253  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18254  " number of subticks (interpreted as for plbox) for the color bar's\n"
18255  " axis definitions.\n"
18256  "\n"
18257  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18258  " elements in each of the n_axes rows of the values matrix.\n"
18259  "\n"
18260  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18261  " values for the data range represented by the color bar. For a row\n"
18262  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18263  " elements in the row is specified by n_values[i_axis]. For\n"
18264  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18265  " is 2, and the corresponding row elements of the values matrix are\n"
18266  " the minimum and maximum value represented by the colorbar. For\n"
18267  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18268  " of the values matrix is interpreted the same as the nlevel and\n"
18269  " clevel arguments of plshades.\n"
18270  "\n"
18271  ""},
18272  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
18273  "Sets the 3D position of the light source\n"
18274  "\n"
18275  "DESCRIPTION:\n"
18276  "\n"
18277  " Sets the 3D position of the light source for use with plsurf3d and\n"
18278  " plsurf3dl\n"
18279  "\n"
18280  " Redacted form: pllightsource(x, y, z)\n"
18281  "\n"
18282  " This function is used in example 8.\n"
18283  "\n"
18284  "\n"
18285  "\n"
18286  "SYNOPSIS:\n"
18287  "\n"
18288  "pllightsource(x, y, z)\n"
18289  "\n"
18290  "ARGUMENTS:\n"
18291  "\n"
18292  " x (PLFLT, input) : X-coordinate of the light source.\n"
18293  "\n"
18294  " y (PLFLT, input) : Y-coordinate of the light source.\n"
18295  "\n"
18296  " z (PLFLT, input) : Z-coordinate of the light source.\n"
18297  "\n"
18298  ""},
18299  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
18300  "Draw a line\n"
18301  "\n"
18302  "DESCRIPTION:\n"
18303  "\n"
18304  " Draws line defined by n points in x and y.\n"
18305  "\n"
18306  " Redacted form: plline(x, y)\n"
18307  "\n"
18308  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18309  " 25-27, and 29.\n"
18310  "\n"
18311  "\n"
18312  "\n"
18313  "SYNOPSIS:\n"
18314  "\n"
18315  "plline(n, x, y)\n"
18316  "\n"
18317  "ARGUMENTS:\n"
18318  "\n"
18319  " n (PLINT, input) : Number of points defining line.\n"
18320  "\n"
18321  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18322  " points.\n"
18323  "\n"
18324  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18325  " points.\n"
18326  "\n"
18327  ""},
18328  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
18329  "Draw a line in 3 space\n"
18330  "\n"
18331  "DESCRIPTION:\n"
18332  "\n"
18333  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18334  " first set up the viewport, the 2d viewing window (in world\n"
18335  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18336  " more info.\n"
18337  "\n"
18338  " Redacted form: plline3(x, y, z)\n"
18339  "\n"
18340  " This function is used in example 18.\n"
18341  "\n"
18342  "\n"
18343  "\n"
18344  "SYNOPSIS:\n"
18345  "\n"
18346  "plline3(n, x, y, z)\n"
18347  "\n"
18348  "ARGUMENTS:\n"
18349  "\n"
18350  " n (PLINT, input) : Number of points defining line.\n"
18351  "\n"
18352  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18353  " points.\n"
18354  "\n"
18355  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18356  " points.\n"
18357  "\n"
18358  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18359  " points.\n"
18360  "\n"
18361  ""},
18362  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
18363  "Select line style\n"
18364  "\n"
18365  "DESCRIPTION:\n"
18366  "\n"
18367  " This sets the line style according to one of eight predefined patterns\n"
18368  " (also see plstyl).\n"
18369  "\n"
18370  " Redacted form: pllsty(lin)\n"
18371  "\n"
18372  " This function is used in examples 9, 12, 22, and 25.\n"
18373  "\n"
18374  "\n"
18375  "\n"
18376  "SYNOPSIS:\n"
18377  "\n"
18378  "pllsty(lin)\n"
18379  "\n"
18380  "ARGUMENTS:\n"
18381  "\n"
18382  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18383  " a continuous line, line style 2 is a line with short dashes and\n"
18384  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18385  " 4 has long dashes and short gaps and so on.\n"
18386  "\n"
18387  ""},
18388  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
18389  "Plot surface mesh\n"
18390  "\n"
18391  "DESCRIPTION:\n"
18392  "\n"
18393  " Plots a surface mesh within the environment set up by plw3d. The\n"
18394  " surface is defined by the matrix z[\n"
18395  " nx][\n"
18396  " ny] , the point z[i][j] being the value of the function at (\n"
18397  " x[i],\n"
18398  " y[j]). Note that the points in vectors x and y do not need to be\n"
18399  " equally spaced, but must be stored in ascending order. The parameter\n"
18400  " opt controls the way in which the surface is displayed. For further\n"
18401  " details see the PLplot documentation.\n"
18402  "\n"
18403  " Redacted form: plmesh(x, y, z, opt)\n"
18404  "\n"
18405  " This function is used in example 11.\n"
18406  "\n"
18407  "\n"
18408  "\n"
18409  "SYNOPSIS:\n"
18410  "\n"
18411  "plmesh(x, y, z, nx, ny, opt)\n"
18412  "\n"
18413  "ARGUMENTS:\n"
18414  "\n"
18415  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18416  " which the function is evaluated.\n"
18417  "\n"
18418  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18419  " which the function is evaluated.\n"
18420  "\n"
18421  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18422  " plot. Should have dimensions of\n"
18423  " nx by\n"
18424  " ny.\n"
18425  "\n"
18426  " nx (PLINT, input) : Number of x values at which function has been\n"
18427  " evaluated.\n"
18428  "\n"
18429  " ny (PLINT, input) : Number of y values at which function has been\n"
18430  " evaluated.\n"
18431  "\n"
18432  " opt (PLINT, input) : Determines the way in which the surface is\n"
18433  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18434  " function of x for each value of y[j] .\n"
18435  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18436  " for each value of x[i] .\n"
18437  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18438  " at which function is defined.\n"
18439  "\n"
18440  ""},
18441  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
18442  "Magnitude colored plot surface mesh with contour\n"
18443  "\n"
18444  "DESCRIPTION:\n"
18445  "\n"
18446  " A more powerful form of plmesh: the surface mesh can be colored\n"
18447  " accordingly to the current z value being plotted, a contour plot can\n"
18448  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18449  " plotted function border and the base XY plane.\n"
18450  "\n"
18451  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18452  "\n"
18453  " This function is used in example 11.\n"
18454  "\n"
18455  "\n"
18456  "\n"
18457  "SYNOPSIS:\n"
18458  "\n"
18459  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18460  "\n"
18461  "ARGUMENTS:\n"
18462  "\n"
18463  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18464  " which the function is evaluated.\n"
18465  "\n"
18466  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18467  " which the function is evaluated.\n"
18468  "\n"
18469  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18470  " plot. Should have dimensions of\n"
18471  " nx by\n"
18472  " ny.\n"
18473  "\n"
18474  " nx (PLINT, input) : Number of x values at which function is\n"
18475  " evaluated.\n"
18476  "\n"
18477  " ny (PLINT, input) : Number of y values at which function is\n"
18478  " evaluated.\n"
18479  "\n"
18480  " opt (PLINT, input) : Determines the way in which the surface is\n"
18481  " represented. To specify more than one option just add the options,\n"
18482  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18483  " showing z as a function of x for each value of y[j] .\n"
18484  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18485  " for each value of x[i] .\n"
18486  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18487  " at which function is defined.\n"
18488  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18489  " the z value being plotted. The color is used from the current\n"
18490  " cmap1.\n"
18491  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18492  " using parameters\n"
18493  " nlevel and\n"
18494  " clevel.\n"
18495  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18496  " the borders of the plotted function.\n"
18497  "\n"
18498  "\n"
18499  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18500  " levels.\n"
18501  "\n"
18502  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18503  "\n"
18504  ""},
18505  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
18506  "Creates a new stream and makes it the default\n"
18507  "\n"
18508  "DESCRIPTION:\n"
18509  "\n"
18510  " Creates a new stream and makes it the default. Differs from using\n"
18511  " plsstrm, in that a free stream number is found, and returned.\n"
18512  " Unfortunately, I have to start at stream 1 and work upward, since\n"
18513  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18514  " that no initial, library-opening call is required. So stream 0 must\n"
18515  " be preallocated, and there is no simple way of determining whether it\n"
18516  " is already in use or not.\n"
18517  "\n"
18518  " Redacted form: plmkstrm(p_strm)\n"
18519  "\n"
18520  " This function is used in examples 1 and 20.\n"
18521  "\n"
18522  "\n"
18523  "\n"
18524  "SYNOPSIS:\n"
18525  "\n"
18526  "plmkstrm(p_strm)\n"
18527  "\n"
18528  "ARGUMENTS:\n"
18529  "\n"
18530  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18531  " number of the created stream.\n"
18532  "\n"
18533  ""},
18534  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
18535  "Write text relative to viewport boundaries\n"
18536  "\n"
18537  "DESCRIPTION:\n"
18538  "\n"
18539  " Writes text at a specified position relative to the viewport\n"
18540  " boundaries. Text may be written inside or outside the viewport, but\n"
18541  " is clipped at the subpage boundaries. The reference point of a string\n"
18542  " lies along a line passing through the string at half the height of a\n"
18543  " capital letter. The position of the reference point along this line\n"
18544  " is determined by just, and the position of the reference point\n"
18545  " relative to the viewport is set by disp and pos.\n"
18546  "\n"
18547  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18548  "\n"
18549  "\n"
18550  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18551  " 26.\n"
18552  "\n"
18553  "\n"
18554  "\n"
18555  "SYNOPSIS:\n"
18556  "\n"
18557  "plmtex(side, disp, pos, just, text)\n"
18558  "\n"
18559  "ARGUMENTS:\n"
18560  "\n"
18561  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18562  " the side of the viewport along which the text is to be written.\n"
18563  " The string must be one of: b: Bottom of viewport, text written\n"
18564  " parallel to edge.\n"
18565  " bv: Bottom of viewport, text written at right angles to edge.\n"
18566  " l: Left of viewport, text written parallel to edge.\n"
18567  " lv: Left of viewport, text written at right angles to edge.\n"
18568  " r: Right of viewport, text written parallel to edge.\n"
18569  " rv: Right of viewport, text written at right angles to edge.\n"
18570  " t: Top of viewport, text written parallel to edge.\n"
18571  " tv: Top of viewport, text written at right angles to edge.\n"
18572  "\n"
18573  "\n"
18574  " disp (PLFLT, input) : Position of the reference point of string,\n"
18575  " measured outwards from the specified viewport edge in units of the\n"
18576  " current character height. Use negative disp to write within the\n"
18577  " viewport.\n"
18578  "\n"
18579  " pos (PLFLT, input) : Position of the reference point of string\n"
18580  " along the specified edge, expressed as a fraction of the length of\n"
18581  " the edge.\n"
18582  "\n"
18583  " just (PLFLT, input) : Specifies the position of the string relative\n"
18584  " to its reference point. If just=0. , the reference point is at\n"
18585  " the left and if just=1. , it is at the right of the string. Other\n"
18586  " values of just give intermediate justifications.\n"
18587  "\n"
18588  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18589  " written out.\n"
18590  "\n"
18591  ""},
18592  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
18593  "Write text relative to viewport boundaries in 3D plots\n"
18594  "\n"
18595  "DESCRIPTION:\n"
18596  "\n"
18597  " Writes text at a specified position relative to the viewport\n"
18598  " boundaries. Text may be written inside or outside the viewport, but\n"
18599  " is clipped at the subpage boundaries. The reference point of a string\n"
18600  " lies along a line passing through the string at half the height of a\n"
18601  " capital letter. The position of the reference point along this line\n"
18602  " is determined by just, and the position of the reference point\n"
18603  " relative to the viewport is set by disp and pos.\n"
18604  "\n"
18605  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18606  "\n"
18607  " This function is used in example 28.\n"
18608  "\n"
18609  "\n"
18610  "\n"
18611  "SYNOPSIS:\n"
18612  "\n"
18613  "plmtex3(side, disp, pos, just, text)\n"
18614  "\n"
18615  "ARGUMENTS:\n"
18616  "\n"
18617  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18618  " the side of the viewport along which the text is to be written.\n"
18619  " The string should contain one or more of the following characters:\n"
18620  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18621  " only label the X axis, not both the X and Y axes. x: Label the X\n"
18622  " axis.\n"
18623  " y: Label the Y axis.\n"
18624  " z: Label the Z axis.\n"
18625  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18626  " For X it is the axis that starts at y-min. For Y it is the\n"
18627  " axis that starts at x-min.\n"
18628  " s: Label the secondary axis.\n"
18629  " v: Draw the text perpendicular to the axis.\n"
18630  "\n"
18631  "\n"
18632  " disp (PLFLT, input) : Position of the reference point of string,\n"
18633  " measured outwards from the specified viewport edge in units of the\n"
18634  " current character height. Use negative disp to write within the\n"
18635  " viewport.\n"
18636  "\n"
18637  " pos (PLFLT, input) : Position of the reference point of string\n"
18638  " along the specified edge, expressed as a fraction of the length of\n"
18639  " the edge.\n"
18640  "\n"
18641  " just (PLFLT, input) : Specifies the position of the string relative\n"
18642  " to its reference point. If just=0. , the reference point is at\n"
18643  " the left and if just=1. , it is at the right of the string. Other\n"
18644  " values of just give intermediate justifications.\n"
18645  "\n"
18646  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18647  " written out.\n"
18648  "\n"
18649  ""},
18650  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
18651  "Plot 3-d surface plot\n"
18652  "\n"
18653  "DESCRIPTION:\n"
18654  "\n"
18655  " Plots a three-dimensional surface plot within the environment set up\n"
18656  " by plw3d. The surface is defined by the matrix z[\n"
18657  " nx][\n"
18658  " ny] , the point z[i][j] being the value of the function at (\n"
18659  " x[i],\n"
18660  " y[j]). Note that the points in vectors x and y do not need to be\n"
18661  " equally spaced, but must be stored in ascending order. The parameter\n"
18662  " opt controls the way in which the surface is displayed. For further\n"
18663  " details see the PLplot documentation. The only difference between\n"
18664  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18665  " while plot3d only draws the surface as viewed from the top.\n"
18666  "\n"
18667  " Redacted form: plot3d(x, y, z, opt, side)\n"
18668  "\n"
18669  " This function is used in examples 11 and 21.\n"
18670  "\n"
18671  "\n"
18672  "\n"
18673  "SYNOPSIS:\n"
18674  "\n"
18675  "plot3d(x, y, z, nx, ny, opt, side)\n"
18676  "\n"
18677  "ARGUMENTS:\n"
18678  "\n"
18679  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18680  " which the function is evaluated.\n"
18681  "\n"
18682  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18683  " which the function is evaluated.\n"
18684  "\n"
18685  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18686  " plot. Should have dimensions of\n"
18687  " nx by\n"
18688  " ny.\n"
18689  "\n"
18690  " nx (PLINT, input) : Number of x values at which function is\n"
18691  " evaluated.\n"
18692  "\n"
18693  " ny (PLINT, input) : Number of y values at which function is\n"
18694  " evaluated.\n"
18695  "\n"
18696  " opt (PLINT, input) : Determines the way in which the surface is\n"
18697  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18698  " function of x for each value of y[j] .\n"
18699  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18700  " for each value of x[i] .\n"
18701  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18702  " at which function is defined.\n"
18703  "\n"
18704  "\n"
18705  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18706  " should be draw on the figure. If side is true sides are drawn,\n"
18707  " otherwise no sides are drawn.\n"
18708  "\n"
18709  ""},
18710  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18711  "Magnitude colored plot surface with contour\n"
18712  "\n"
18713  "DESCRIPTION:\n"
18714  "\n"
18715  " Aside from dropping the\n"
18716  " side functionality this is a more powerful form of plot3d: the surface\n"
18717  " mesh can be colored accordingly to the current z value being plotted,\n"
18718  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18719  " drawn between the plotted function border and the base XY plane. The\n"
18720  " arguments are identical to those of plmeshc. The only difference\n"
18721  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18722  " the surface, while plot3dc only draws the surface as viewed from the\n"
18723  " top.\n"
18724  "\n"
18725  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18726  "\n"
18727  "\n"
18728  " This function is used in example 21.\n"
18729  "\n"
18730  "\n"
18731  "\n"
18732  "SYNOPSIS:\n"
18733  "\n"
18734  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18735  "\n"
18736  "ARGUMENTS:\n"
18737  "\n"
18738  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18739  " which the function is evaluated.\n"
18740  "\n"
18741  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18742  " which the function is evaluated.\n"
18743  "\n"
18744  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18745  " plot. Should have dimensions of\n"
18746  " nx by\n"
18747  " ny.\n"
18748  "\n"
18749  " nx (PLINT, input) : Number of x values at which function is\n"
18750  " evaluated.\n"
18751  "\n"
18752  " ny (PLINT, input) : Number of y values at which function is\n"
18753  " evaluated.\n"
18754  "\n"
18755  " opt (PLINT, input) : Determines the way in which the surface is\n"
18756  " represented. To specify more than one option just add the options,\n"
18757  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18758  " showing z as a function of x for each value of y[j] .\n"
18759  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18760  " for each value of x[i] .\n"
18761  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18762  " at which function is defined.\n"
18763  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18764  " the z value being plotted. The color is used from the current\n"
18765  " cmap1.\n"
18766  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18767  " using parameters\n"
18768  " nlevel and\n"
18769  " clevel.\n"
18770  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18771  " the borders of the plotted function.\n"
18772  "\n"
18773  "\n"
18774  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18775  " levels.\n"
18776  "\n"
18777  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18778  "\n"
18779  ""},
18780  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18781  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18782  "\n"
18783  "DESCRIPTION:\n"
18784  "\n"
18785  " When the implementation is completed this variant of plot3dc (see that\n"
18786  " function's documentation for more details) should be suitable for the\n"
18787  " case where the area of the x, y coordinate grid where z is defined can\n"
18788  " be non-rectangular. The implementation is incomplete so the last 4\n"
18789  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18790  " indexymax; are currently ignored and the functionality is otherwise\n"
18791  " identical to that of plot3dc.\n"
18792  "\n"
18793  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18794  " indexymin, indexymax)\n"
18795  "\n"
18796  "\n"
18797  " This function is not used in any example.\n"
18798  "\n"
18799  "\n"
18800  "\n"
18801  "SYNOPSIS:\n"
18802  "\n"
18803  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18804  "\n"
18805  "ARGUMENTS:\n"
18806  "\n"
18807  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18808  " which the function is evaluated.\n"
18809  "\n"
18810  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18811  " which the function is evaluated.\n"
18812  "\n"
18813  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18814  " plot. Should have dimensions of\n"
18815  " nx by\n"
18816  " ny.\n"
18817  "\n"
18818  " nx (PLINT, input) : Number of x values at which the function is\n"
18819  " evaluated.\n"
18820  "\n"
18821  " ny (PLINT, input) : Number of y values at which the function is\n"
18822  " evaluated.\n"
18823  "\n"
18824  " opt (PLINT, input) : Determines the way in which the surface is\n"
18825  " represented. To specify more than one option just add the options,\n"
18826  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18827  " showing z as a function of x for each value of y[j] .\n"
18828  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18829  " for each value of x[i] .\n"
18830  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18831  " at which function is defined.\n"
18832  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18833  " the z value being plotted. The color is used from the current\n"
18834  " cmap1.\n"
18835  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18836  " using parameters\n"
18837  " nlevel and\n"
18838  " clevel.\n"
18839  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18840  " the borders of the plotted function.\n"
18841  "\n"
18842  "\n"
18843  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18844  " levels.\n"
18845  "\n"
18846  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18847  "\n"
18848  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18849  " corresponds to the first x index where z is defined.\n"
18850  "\n"
18851  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18852  " which corresponds (by convention) to one more than the last x\n"
18853  " index value where z is defined.\n"
18854  "\n"
18855  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18856  " values which all must be ≥ 0. These values are the first y index\n"
18857  " where z is defined for a particular x index in the range from\n"
18858  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18859  " indexxmax.\n"
18860  "\n"
18861  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18862  " values which all must be ≤ ny. These values correspond (by\n"
18863  " convention) to one more than the last y index where z is defined\n"
18864  " for a particular x index in the range from indexxmin to indexxmax\n"
18865  " - 1. The dimension of indexymax is indexxmax.\n"
18866  "\n"
18867  ""},
18868  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18869  "Plot shaded 3-d surface plot\n"
18870  "\n"
18871  "DESCRIPTION:\n"
18872  "\n"
18873  " Plots a three-dimensional shaded surface plot within the environment\n"
18874  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18875  " z[\n"
18876  " nx][\n"
18877  " ny], the point z[i][j] being the value of the function at (\n"
18878  " x[i],\n"
18879  " y[j]). Note that the points in vectors x and y do not need to be\n"
18880  " equally spaced, but must be stored in ascending order. For further\n"
18881  " details see the PLplot documentation.\n"
18882  "\n"
18883  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18884  "\n"
18885  " This function is not used in any examples.\n"
18886  "\n"
18887  "\n"
18888  "\n"
18889  "SYNOPSIS:\n"
18890  "\n"
18891  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18892  "\n"
18893  "ARGUMENTS:\n"
18894  "\n"
18895  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18896  " which the function is evaluated.\n"
18897  "\n"
18898  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18899  " which the function is evaluated.\n"
18900  "\n"
18901  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18902  " plot. Should have dimensions of\n"
18903  " nx by\n"
18904  " ny.\n"
18905  "\n"
18906  " nx (PLINT, input) : Number of x values at which function is\n"
18907  " evaluated.\n"
18908  "\n"
18909  " ny (PLINT, input) : Number of y values at which function is\n"
18910  " evaluated.\n"
18911  "\n"
18912  " opt (PLINT, input) : Determines the way in which the surface is\n"
18913  " represented. To specify more than one option just add the options,\n"
18914  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18915  " connecting points at which function is defined.\n"
18916  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18917  " using parameters\n"
18918  " nlevel and\n"
18919  " clevel.\n"
18920  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18921  " using parameters\n"
18922  " nlevel and\n"
18923  " clevel.\n"
18924  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18925  " the borders of the plotted function.\n"
18926  " opt=MAG_COLOR : the surface is colored according to the value\n"
18927  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18928  " according to the intensity of the reflected light in the\n"
18929  " surface from a light source whose position is set using\n"
18930  " pllightsource.\n"
18931  "\n"
18932  "\n"
18933  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18934  " levels.\n"
18935  "\n"
18936  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18937  "\n"
18938  ""},
18939  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18940  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18941  "\n"
18942  "DESCRIPTION:\n"
18943  "\n"
18944  " This variant of plsurf3d (see that function's documentation for more\n"
18945  " details) should be suitable for the case where the area of the x, y\n"
18946  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18947  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18948  " indexymin, and indexymax.\n"
18949  "\n"
18950  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18951  " indexymax)\n"
18952  "\n"
18953  " This function is used in example 8.\n"
18954  "\n"
18955  "\n"
18956  "\n"
18957  "SYNOPSIS:\n"
18958  "\n"
18959  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18960  "\n"
18961  "ARGUMENTS:\n"
18962  "\n"
18963  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18964  " which the function is evaluated.\n"
18965  "\n"
18966  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18967  " which the function is evaluated.\n"
18968  "\n"
18969  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18970  " plot. Should have dimensions of\n"
18971  " nx by\n"
18972  " ny.\n"
18973  "\n"
18974  " nx (PLINT, input) : Number of x values at which function is\n"
18975  " evaluated.\n"
18976  "\n"
18977  " ny (PLINT, input) : Number of y values at which function is\n"
18978  " evaluated.\n"
18979  "\n"
18980  " opt (PLINT, input) : Determines the way in which the surface is\n"
18981  " represented. To specify more than one option just add the options,\n"
18982  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18983  " connecting points at which function is defined.\n"
18984  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18985  " using parameters\n"
18986  " nlevel and\n"
18987  " clevel.\n"
18988  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18989  " using parameters\n"
18990  " nlevel and\n"
18991  " clevel.\n"
18992  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18993  " the borders of the plotted function.\n"
18994  " opt=MAG_COLOR : the surface is colored according to the value\n"
18995  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18996  " according to the intensity of the reflected light in the\n"
18997  " surface from a light source whose position is set using\n"
18998  " pllightsource.\n"
18999  "\n"
19000  "\n"
19001  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19002  " levels.\n"
19003  "\n"
19004  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19005  "\n"
19006  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19007  " corresponds to the first x index where z is defined.\n"
19008  "\n"
19009  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19010  " which corresponds (by convention) to one more than the last x\n"
19011  " index value where z is defined.\n"
19012  "\n"
19013  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19014  " values which all must be ≥ 0. These values are the first y index\n"
19015  " where z is defined for a particular x index in the range from\n"
19016  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19017  " indexxmax.\n"
19018  "\n"
19019  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19020  " values which all must be ≤ ny. These values correspond (by\n"
19021  " convention) to one more than the last y index where z is defined\n"
19022  " for a particular x index in the range from indexxmin to indexxmax\n"
19023  " - 1. The dimension of indexymax is indexxmax.\n"
19024  "\n"
19025  ""},
19026  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
19027  "Parse command-line arguments\n"
19028  "\n"
19029  "DESCRIPTION:\n"
19030  "\n"
19031  " Parse command-line arguments.\n"
19032  "\n"
19033  " plparseopts removes all recognized flags (decreasing argc\n"
19034  " accordingly), so that invalid input may be readily detected. It can\n"
19035  " also be used to process user command line flags. The user can merge\n"
19036  " an option table of type PLOptionTable into the internal option table\n"
19037  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19038  " the external table(s) be parsed by calling plClearOpts before\n"
19039  " plMergeOpts.\n"
19040  "\n"
19041  " The default action taken by plparseopts is as follows:\n"
19042  " Returns with an error if an unrecognized option or badly formed\n"
19043  " option-value pair are encountered.\n"
19044  " Returns immediately (return code 0) when the first non-option command\n"
19045  " line argument is found.\n"
19046  " Returns with the return code of the option handler, if one was called.\n"
19047  "\n"
19048  " Deletes command line arguments from argv list as they are found, and\n"
19049  " decrements argc accordingly.\n"
19050  " Does not show \"invisible\" options in usage or help messages.\n"
19051  " Assumes the program name is contained in argv[0].\n"
19052  "\n"
19053  " These behaviors may be controlled through the\n"
19054  " mode argument.\n"
19055  "\n"
19056  " Redacted form: General: plparseopts(argv, mode)\n"
19057  "\n"
19058  "\n"
19059  " This function is used in all of the examples.\n"
19060  "\n"
19061  "\n"
19062  "\n"
19063  "SYNOPSIS:\n"
19064  "\n"
19065  "PLINT plparseopts(p_argc, argv, mode)\n"
19066  "\n"
19067  "ARGUMENTS:\n"
19068  "\n"
19069  " p_argc (int *, input/output) : Number of arguments.\n"
19070  "\n"
19071  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19072  " strings containing *p_argc command-line arguments.\n"
19073  "\n"
19074  " mode (PLINT, input) : Parsing mode with the following\n"
19075  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19076  " and all error messages enabled, including program exit when an\n"
19077  " error occurs. Anything on the command line that isn't recognized\n"
19078  " as a valid option or option argument is flagged as an error.\n"
19079  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19080  " of errors.\n"
19081  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19082  " arguments.\n"
19083  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19084  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19085  " pointer to the program name.\n"
19086  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19087  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19088  " unrecognized arguments.\n"
19089  "\n"
19090  ""},
19091  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
19092  "Set area line fill pattern\n"
19093  "\n"
19094  "DESCRIPTION:\n"
19095  "\n"
19096  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19097  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19098  " inclinations and spacings. The arguments to this routine are the\n"
19099  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19100  " elements) specifying the inclinations in tenths of a degree and the\n"
19101  " spacing in micrometers. (See also plpsty)\n"
19102  "\n"
19103  " Redacted form: General: plpat(inc, del)\n"
19104  "\n"
19105  "\n"
19106  " This function is used in example 15.\n"
19107  "\n"
19108  "\n"
19109  "\n"
19110  "SYNOPSIS:\n"
19111  "\n"
19112  "plpat(nlin, inc, del)\n"
19113  "\n"
19114  "ARGUMENTS:\n"
19115  "\n"
19116  " nlin (PLINT, input) : Number of sets of lines making up the\n"
19117  " pattern, either 1 or 2.\n"
19118  "\n"
19119  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19120  " inclination in tenths of a degree. (Should be between -900 and\n"
19121  " 900).\n"
19122  "\n"
19123  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19124  " spacing in micrometers between the lines making up the pattern.\n"
19125  "\n"
19126  ""},
19127  { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
19128  "Draw a line between two points, accounting for coordinate transforms\n"
19129  "\n"
19130  "DESCRIPTION:\n"
19131  "\n"
19132  " Joins the point (\n"
19133  " x1,\n"
19134  " y1) to (\n"
19135  " x2,\n"
19136  " y2) . If a global coordinate transform is defined then the line is\n"
19137  " broken in to n segments to approximate the path. If no transform is\n"
19138  " defined then this simply acts like a call to pljoin.\n"
19139  "\n"
19140  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19141  "\n"
19142  " This function is used in example 22.\n"
19143  "\n"
19144  "\n"
19145  "\n"
19146  "SYNOPSIS:\n"
19147  "\n"
19148  "plpath(n, x1, y1, x2, y2)\n"
19149  "\n"
19150  "ARGUMENTS:\n"
19151  "\n"
19152  " n (PLINT, input) : number of points to use to approximate the path.\n"
19153  "\n"
19154  " x1 (PLFLT, input) : x coordinate of first point.\n"
19155  "\n"
19156  " y1 (PLFLT, input) : y coordinate of first point.\n"
19157  "\n"
19158  " x2 (PLFLT, input) : x coordinate of second point.\n"
19159  "\n"
19160  " y2 (PLFLT, input) : y coordinate of second point.\n"
19161  "\n"
19162  ""},
19163  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
19164  "Plot a glyph at the specified points\n"
19165  "\n"
19166  "DESCRIPTION:\n"
19167  "\n"
19168  " Plot a glyph at the specified points. (This function is largely\n"
19169  " superseded by plstring which gives access to many[!] more glyphs.)\n"
19170  " code=-1 means try to just draw a point. Right now it's just a move\n"
19171  " and a draw at the same place. Not ideal, since a sufficiently\n"
19172  " intelligent output device may optimize it away, or there may be faster\n"
19173  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19174  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19175  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19176  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19177  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19178  "\n"
19179  " Redacted form: plpoin(x, y, code)\n"
19180  "\n"
19181  " This function is used in examples 1, 6, 14, and 29.\n"
19182  "\n"
19183  "\n"
19184  "\n"
19185  "SYNOPSIS:\n"
19186  "\n"
19187  "plpoin(n, x, y, code)\n"
19188  "\n"
19189  "ARGUMENTS:\n"
19190  "\n"
19191  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19192  "\n"
19193  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19194  " points.\n"
19195  "\n"
19196  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19197  " points.\n"
19198  "\n"
19199  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19200  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19201  " each of the n points.\n"
19202  "\n"
19203  ""},
19204  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
19205  "Plot a glyph at the specified 3D points\n"
19206  "\n"
19207  "DESCRIPTION:\n"
19208  "\n"
19209  " Plot a glyph at the specified 3D points. (This function is largely\n"
19210  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19211  " Set up the call to this function similar to what is done for plline3.\n"
19212  " code=-1 means try to just draw a point. Right now it's just a move\n"
19213  " and a draw at the same place. Not ideal, since a sufficiently\n"
19214  " intelligent output device may optimize it away, or there may be faster\n"
19215  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19216  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19217  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19218  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19219  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19220  "\n"
19221  " Redacted form: plpoin3(x, y, z, code)\n"
19222  "\n"
19223  " This function is not used in any example.\n"
19224  "\n"
19225  "\n"
19226  "\n"
19227  "SYNOPSIS:\n"
19228  "\n"
19229  "plpoin3(n, x, y, z, code)\n"
19230  "\n"
19231  "ARGUMENTS:\n"
19232  "\n"
19233  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19234  "\n"
19235  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19236  " points.\n"
19237  "\n"
19238  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19239  " points.\n"
19240  "\n"
19241  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19242  " points.\n"
19243  "\n"
19244  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19245  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19246  " each of the n points.\n"
19247  "\n"
19248  ""},
19249  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
19250  "Draw a polygon in 3 space\n"
19251  "\n"
19252  "DESCRIPTION:\n"
19253  "\n"
19254  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19255  " like plline3, but differs from that function in that plpoly3 attempts\n"
19256  " to determine if the polygon is viewable depending on the order of the\n"
19257  " points within the vector and the value of ifcc. If the back of\n"
19258  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19259  " you want, then use plline3 instead.\n"
19260  "\n"
19261  " The points are assumed to be in a plane, and the directionality of the\n"
19262  " plane is determined from the first three points. Additional points do\n"
19263  " not have to lie on the plane defined by the first three, but if they\n"
19264  " do not, then the determination of visibility obviously can't be 100%\n"
19265  " accurate... So if you're 3 space polygons are too far from planar,\n"
19266  " consider breaking them into smaller polygons. 3 points define a plane\n"
19267  " :-).\n"
19268  "\n"
19269  " Bugs: If one of the first two segments is of zero length, or if they\n"
19270  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19271  " being correct. Avoid such situations :-). See x18c.c for an example\n"
19272  " of this problem. (Search for 20.1).\n"
19273  "\n"
19274  " Redacted form: plpoly3(x, y, z, code)\n"
19275  "\n"
19276  " This function is used in example 18.\n"
19277  "\n"
19278  "\n"
19279  "\n"
19280  "SYNOPSIS:\n"
19281  "\n"
19282  "plpoly3(n, x, y, z, draw, ifcc)\n"
19283  "\n"
19284  "ARGUMENTS:\n"
19285  "\n"
19286  " n (PLINT, input) : Number of points defining line.\n"
19287  "\n"
19288  " x (PLFLT_VECTOR, input) : A vector containing\n"
19289  " n x coordinates of points.\n"
19290  "\n"
19291  " y (PLFLT_VECTOR, input) : A vector containing\n"
19292  " n y coordinates of points.\n"
19293  "\n"
19294  " z (PLFLT_VECTOR, input) : A vector containing\n"
19295  " n z coordinates of points.\n"
19296  "\n"
19297  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19298  " n-1 Boolean values which control drawing the segments of the polygon.\n"
19299  " If draw[i] is true, then the polygon segment from index [i] to\n"
19300  " [i+1] is drawn, otherwise, not.\n"
19301  "\n"
19302  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19303  " polygon is determined by assuming the points are laid out in a\n"
19304  " counter-clockwise order. Otherwise, the directionality of the\n"
19305  " polygon is determined by assuming the points are laid out in a\n"
19306  " clockwise order.\n"
19307  "\n"
19308  ""},
19309  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
19310  "Set precision in numeric labels\n"
19311  "\n"
19312  "DESCRIPTION:\n"
19313  "\n"
19314  " Sets the number of places after the decimal point in numeric labels.\n"
19315  "\n"
19316  " Redacted form: plprec(setp, prec)\n"
19317  "\n"
19318  " This function is used in example 29.\n"
19319  "\n"
19320  "\n"
19321  "\n"
19322  "SYNOPSIS:\n"
19323  "\n"
19324  "plprec(setp, prec)\n"
19325  "\n"
19326  "ARGUMENTS:\n"
19327  "\n"
19328  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19329  " automatically determines the number of places to use after the\n"
19330  " decimal point in numeric labels (like those used to label axes).\n"
19331  " If setp is 1 then prec sets the number of places.\n"
19332  "\n"
19333  " prec (PLINT, input) : The number of characters to draw after the\n"
19334  " decimal point in numeric labels.\n"
19335  "\n"
19336  ""},
19337  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
19338  "Select area fill pattern\n"
19339  "\n"
19340  "DESCRIPTION:\n"
19341  "\n"
19342  " If\n"
19343  " patt is zero or less use either a hardware solid fill if the drivers\n"
19344  " have that capability (virtually all do) or fall back to a software\n"
19345  " emulation of a solid fill using the eighth area line fill pattern. If\n"
19346  " 0 <\n"
19347  " patt <= 8, then select one of eight predefined area line fill patterns\n"
19348  " to use (see plpat if you desire other patterns).\n"
19349  "\n"
19350  " Redacted form: plpsty(patt)\n"
19351  "\n"
19352  " This function is used in examples 12, 13, 15, 16, and 25.\n"
19353  "\n"
19354  "\n"
19355  "\n"
19356  "SYNOPSIS:\n"
19357  "\n"
19358  "plpsty(patt)\n"
19359  "\n"
19360  "ARGUMENTS:\n"
19361  "\n"
19362  " patt (PLINT, input) : The desired pattern index. If\n"
19363  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19364  " above) used. For\n"
19365  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19366  " line fill capability itself (most deliberately do not so that line\n"
19367  " fill patterns look identical for those drivers), the patterns\n"
19368  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19369  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19370  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19371  " (8) lines at both 45 degrees and -45 degrees.\n"
19372  "\n"
19373  ""},
19374  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
19375  "Write text inside the viewport\n"
19376  "\n"
19377  "DESCRIPTION:\n"
19378  "\n"
19379  " Writes text at a specified position and inclination within the\n"
19380  " viewport. Text is clipped at the viewport boundaries. The reference\n"
19381  " point of a string lies along a line passing through the string at half\n"
19382  " the height of a capital letter. The position of the reference point\n"
19383  " along this line is determined by just, the reference point is placed\n"
19384  " at world coordinates (\n"
19385  " x,\n"
19386  " y) within the viewport. The inclination of the string is specified\n"
19387  " in terms of differences of world coordinates making it easy to write\n"
19388  " text parallel to a line in a graph.\n"
19389  "\n"
19390  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19391  "\n"
19392  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19393  "\n"
19394  "\n"
19395  "\n"
19396  "SYNOPSIS:\n"
19397  "\n"
19398  "plptex(x, y, dx, dy, just, text)\n"
19399  "\n"
19400  "ARGUMENTS:\n"
19401  "\n"
19402  " x (PLFLT, input) : x coordinate of reference point of string.\n"
19403  "\n"
19404  " y (PLFLT, input) : y coordinate of reference point of string.\n"
19405  "\n"
19406  " dx (PLFLT, input) : Together with dy, this specifies the\n"
19407  " inclination of the string. The baseline of the string is parallel\n"
19408  " to a line joining (\n"
19409  " x,\n"
19410  " y) to (\n"
19411  " x+\n"
19412  " dx,\n"
19413  " y+\n"
19414  " dy) .\n"
19415  "\n"
19416  " dy (PLFLT, input) : Together with dx, this specifies the\n"
19417  " inclination of the string.\n"
19418  "\n"
19419  " just (PLFLT, input) : Specifies the position of the string relative\n"
19420  " to its reference point. If just=0. , the reference point is at\n"
19421  " the left and if just=1. , it is at the right of the string. Other\n"
19422  " values of just give intermediate justifications.\n"
19423  "\n"
19424  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19425  " written out.\n"
19426  "\n"
19427  ""},
19428  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
19429  "Write text inside the viewport of a 3D plot\n"
19430  "\n"
19431  "DESCRIPTION:\n"
19432  "\n"
19433  " Writes text at a specified position and inclination and with a\n"
19434  " specified shear within the viewport. Text is clipped at the viewport\n"
19435  " boundaries. The reference point of a string lies along a line passing\n"
19436  " through the string at half the height of a capital letter. The\n"
19437  " position of the reference point along this line is determined by just,\n"
19438  " and the reference point is placed at world coordinates (\n"
19439  " wx,\n"
19440  " wy,\n"
19441  " wz) within the viewport. The inclination and shear of the string is\n"
19442  " specified in terms of differences of world coordinates making it easy\n"
19443  " to write text parallel to a line in a graph.\n"
19444  "\n"
19445  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19446  "\n"
19447  " This function is used in example 28.\n"
19448  "\n"
19449  "\n"
19450  "\n"
19451  "SYNOPSIS:\n"
19452  "\n"
19453  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19454  "\n"
19455  "ARGUMENTS:\n"
19456  "\n"
19457  " wx (PLFLT, input) : x world coordinate of reference point of\n"
19458  " string.\n"
19459  "\n"
19460  " wy (PLFLT, input) : y world coordinate of reference point of\n"
19461  " string.\n"
19462  "\n"
19463  " wz (PLFLT, input) : z world coordinate of reference point of\n"
19464  " string.\n"
19465  "\n"
19466  " dx (PLFLT, input) : Together with dy and\n"
19467  " dz , this specifies the inclination of the string. The baseline of\n"
19468  " the string is parallel to a line joining (\n"
19469  " x,\n"
19470  " y,\n"
19471  " z) to (\n"
19472  " x+\n"
19473  " dx,\n"
19474  " y+\n"
19475  " dy,\n"
19476  " z+\n"
19477  " dz) .\n"
19478  "\n"
19479  " dy (PLFLT, input) : Together with dx and\n"
19480  " dz, this specifies the inclination of the string.\n"
19481  "\n"
19482  " dz (PLFLT, input) : Together with dx and\n"
19483  " dy, this specifies the inclination of the string.\n"
19484  "\n"
19485  " sx (PLFLT, input) : Together with sy and\n"
19486  " sz , this specifies the shear of the string. The string is sheared so\n"
19487  " that the characters are vertically parallel to a line joining (\n"
19488  " x,\n"
19489  " y,\n"
19490  " z) to (\n"
19491  " x+\n"
19492  " sx,\n"
19493  " y+\n"
19494  " sy,\n"
19495  " z+\n"
19496  " sz) . If sx =\n"
19497  " sy =\n"
19498  " sz = 0.) then the text is not sheared.\n"
19499  "\n"
19500  " sy (PLFLT, input) : Together with sx and\n"
19501  " sz, this specifies shear of the string.\n"
19502  "\n"
19503  " sz (PLFLT, input) : Together with sx and\n"
19504  " sy, this specifies shear of the string.\n"
19505  "\n"
19506  " just (PLFLT, input) : Specifies the position of the string relative\n"
19507  " to its reference point. If just=0. , the reference point is at\n"
19508  " the left and if just=1. , it is at the right of the string. Other\n"
19509  " values of just give intermediate justifications.\n"
19510  "\n"
19511  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19512  " written out.\n"
19513  "\n"
19514  ""},
19515  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
19516  "Random number generator returning a real random number in the range [0,1]\n"
19517  "\n"
19518  "DESCRIPTION:\n"
19519  "\n"
19520  " Random number generator returning a real random number in the range\n"
19521  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19522  " / compilers provide their own random number generator, and so this is\n"
19523  " provided purely for convenience and to give a consistent random number\n"
19524  " generator across all languages supported by PLplot. This is\n"
19525  " particularly useful for comparing results from the test suite of\n"
19526  " examples.\n"
19527  "\n"
19528  " Redacted form: plrandd()\n"
19529  "\n"
19530  " This function is used in examples 17 and 21.\n"
19531  "\n"
19532  "\n"
19533  "\n"
19534  "SYNOPSIS:\n"
19535  "\n"
19536  "plrandd()\n"
19537  "\n"
19538  ""},
19539  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
19540  "Replays contents of plot buffer to current device/file\n"
19541  "\n"
19542  "DESCRIPTION:\n"
19543  "\n"
19544  " Replays contents of plot buffer to current device/file.\n"
19545  "\n"
19546  " Redacted form: plreplot()\n"
19547  "\n"
19548  " This function is used in example 1,20.\n"
19549  "\n"
19550  "\n"
19551  "\n"
19552  "SYNOPSIS:\n"
19553  "\n"
19554  "plreplot()\n"
19555  "\n"
19556  ""},
19557  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
19558  "Convert RGB color to HLS\n"
19559  "\n"
19560  "DESCRIPTION:\n"
19561  "\n"
19562  " Convert RGB color coordinates to HLS\n"
19563  "\n"
19564  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19565  "\n"
19566  "\n"
19567  " This function is used in example 2.\n"
19568  "\n"
19569  "\n"
19570  "\n"
19571  "SYNOPSIS:\n"
19572  "\n"
19573  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19574  "\n"
19575  "ARGUMENTS:\n"
19576  "\n"
19577  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19578  "\n"
19579  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19580  "\n"
19581  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19582  "\n"
19583  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19584  " degrees (0.0-360.0) on the color cylinder.\n"
19585  "\n"
19586  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19587  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19588  " cylinder.\n"
19589  "\n"
19590  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19591  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19592  " cylinder.\n"
19593  "\n"
19594  ""},
19595  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
19596  "Set character size\n"
19597  "\n"
19598  "DESCRIPTION:\n"
19599  "\n"
19600  " This sets up the size of all subsequent characters drawn. The actual\n"
19601  " height of a character is the product of the default character size and\n"
19602  " a scaling factor.\n"
19603  "\n"
19604  " Redacted form: plschr(def, scale)\n"
19605  "\n"
19606  " This function is used in examples 2, 13, 23, and 24.\n"
19607  "\n"
19608  "\n"
19609  "\n"
19610  "SYNOPSIS:\n"
19611  "\n"
19612  "plschr(def, scale)\n"
19613  "\n"
19614  "ARGUMENTS:\n"
19615  "\n"
19616  " def (PLFLT, input) : The default height of a character in\n"
19617  " millimeters, should be set to zero if the default height is to\n"
19618  " remain unchanged. For rasterized drivers the dx and dy values\n"
19619  " specified in plspage are used to convert from mm to pixels (note\n"
19620  " the different unit systems used). This dpi aware scaling is not\n"
19621  " implemented for all drivers yet.\n"
19622  "\n"
19623  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19624  " actual character height.\n"
19625  "\n"
19626  ""},
19627  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
19628  "Set cmap0 colors by 8-bit RGB values\n"
19629  "\n"
19630  "DESCRIPTION:\n"
19631  "\n"
19632  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19633  " documentation). This sets the entire color map -- only as many colors\n"
19634  " as specified will be allocated.\n"
19635  "\n"
19636  " Redacted form: plscmap0(r, g, b)\n"
19637  "\n"
19638  " This function is used in examples 2 and 24.\n"
19639  "\n"
19640  "\n"
19641  "\n"
19642  "SYNOPSIS:\n"
19643  "\n"
19644  "plscmap0(r, g, b, ncol0)\n"
19645  "\n"
19646  "ARGUMENTS:\n"
19647  "\n"
19648  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19649  " integers (0-255) representing the degree of red in the color.\n"
19650  "\n"
19651  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19652  " integers (0-255) representing the degree of green in the color.\n"
19653  "\n"
19654  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19655  " integers (0-255) representing the degree of blue in the color.\n"
19656  "\n"
19657  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19658  "\n"
19659  ""},
19660  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
19661  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19662  "\n"
19663  "DESCRIPTION:\n"
19664  "\n"
19665  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19666  " and PLFLT alpha transparency value. This sets the entire color map --\n"
19667  " only as many colors as specified will be allocated.\n"
19668  "\n"
19669  " Redacted form: plscmap0a(r, g, b, alpha)\n"
19670  "\n"
19671  " This function is used in examples 30.\n"
19672  "\n"
19673  "\n"
19674  "\n"
19675  "SYNOPSIS:\n"
19676  "\n"
19677  "plscmap0a(r, g, b, alpha, ncol0)\n"
19678  "\n"
19679  "ARGUMENTS:\n"
19680  "\n"
19681  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19682  " integers (0-255) representing the degree of red in the color.\n"
19683  "\n"
19684  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19685  " integers (0-255) representing the degree of green in the color.\n"
19686  "\n"
19687  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19688  " integers (0-255) representing the degree of blue in the color.\n"
19689  "\n"
19690  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19691  " representing the alpha transparency of the color.\n"
19692  "\n"
19693  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19694  " vectors.\n"
19695  "\n"
19696  ""},
19697  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
19698  "Set number of colors in cmap0\n"
19699  "\n"
19700  "DESCRIPTION:\n"
19701  "\n"
19702  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19703  " (or reallocate) cmap0, and fill with default values for those colors\n"
19704  " not previously allocated. The first 16 default colors are given in\n"
19705  " the plcol0 documentation. For larger indices the default color is\n"
19706  " red.\n"
19707  "\n"
19708  " The drivers are not guaranteed to support more than 16 colors.\n"
19709  "\n"
19710  " Redacted form: plscmap0n(ncol0)\n"
19711  "\n"
19712  " This function is used in examples 15, 16, and 24.\n"
19713  "\n"
19714  "\n"
19715  "\n"
19716  "SYNOPSIS:\n"
19717  "\n"
19718  "plscmap0n(ncol0)\n"
19719  "\n"
19720  "ARGUMENTS:\n"
19721  "\n"
19722  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19723  " the cmap0 palette. If this number is zero or less, then the value\n"
19724  " from the previous call to plscmap0n is used and if there is no\n"
19725  " previous call, then a default value is used.\n"
19726  "\n"
19727  ""},
19728  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19729  "Set opaque RGB cmap1 colors values\n"
19730  "\n"
19731  "DESCRIPTION:\n"
19732  "\n"
19733  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19734  " vector values. This function also sets the number of cmap1 colors.\n"
19735  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19736  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19737  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19738  " to\n"
19739  " ncol1-1. So in order for this continuous color model to work\n"
19740  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19741  " that these RGB vectors are continuous functions of their integer\n"
19742  " indices.\n"
19743  "\n"
19744  " Redacted form: plscmap1(r, g, b)\n"
19745  "\n"
19746  " This function is used in example 31.\n"
19747  "\n"
19748  "\n"
19749  "\n"
19750  "SYNOPSIS:\n"
19751  "\n"
19752  "plscmap1(r, g, b, ncol1)\n"
19753  "\n"
19754  "ARGUMENTS:\n"
19755  "\n"
19756  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19757  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19758  " color as a continuous function of the integer index of the vector.\n"
19759  "\n"
19760  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19761  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19762  " color as a continuous function of the integer index of the vector.\n"
19763  "\n"
19764  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19765  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19766  " color as a continuous function of the integer index of the vector.\n"
19767  "\n"
19768  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19769  "\n"
19770  ""},
19771  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19772  "Set semitransparent cmap1 RGBA colors.\n"
19773  "\n"
19774  "DESCRIPTION:\n"
19775  "\n"
19776  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19777  " RGBA vector values. This function also sets the number of cmap1\n"
19778  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19779  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19780  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19781  " vectors in the range from 0 to\n"
19782  " ncol1-1. So in order for this continuous color model to work\n"
19783  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19784  " that these RGBA vectors are continuous functions of their integer\n"
19785  " indices.\n"
19786  "\n"
19787  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19788  "\n"
19789  " This function is used in example 31.\n"
19790  "\n"
19791  "\n"
19792  "\n"
19793  "SYNOPSIS:\n"
19794  "\n"
19795  "plscmap1a(r, g, b, alpha, ncol1)\n"
19796  "\n"
19797  "ARGUMENTS:\n"
19798  "\n"
19799  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19800  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19801  " color as a continuous function of the integer index of the vector.\n"
19802  "\n"
19803  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19804  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19805  " color as a continuous function of the integer index of the vector.\n"
19806  "\n"
19807  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19808  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19809  " color as a continuous function of the integer index of the vector.\n"
19810  "\n"
19811  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19812  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19813  " completely transparent and 1.0 corresponds to completely opaque)\n"
19814  " the alpha transparency of the color as a continuous function of\n"
19815  " the integer index of the vector.\n"
19816  "\n"
19817  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19818  " vectors.\n"
19819  "\n"
19820  ""},
19821  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19822  "Set cmap1 colors using a piece-wise linear relationship\n"
19823  "\n"
19824  "DESCRIPTION:\n"
19825  "\n"
19826  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19827  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19828  " (see the PLplot documentation). May be called at any time.\n"
19829  "\n"
19830  " The idea here is to specify a number of control points that define the\n"
19831  " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19832  " these points, linear interpolation is used which gives a smooth\n"
19833  " variation of color with intensity index. Any number of control points\n"
19834  " may be specified, located at arbitrary positions, although typically 2\n"
19835  " - 4 are enough. Another way of stating this is that we are traversing\n"
19836  " a given number of lines through HLS or RGB space as we move through\n"
19837  " cmap1 intensity indices. The control points at the minimum and\n"
19838  " maximum position (0 and 1) must always be specified. By adding more\n"
19839  " control points you can get more variation. One good technique for\n"
19840  " plotting functions that vary about some expected average is to use an\n"
19841  " additional 2 control points in the center (position ~= 0.5) that are\n"
19842  " the same lightness as the background (typically white for paper\n"
19843  " output, black for crt), and same hue as the boundary control points.\n"
19844  " This allows the highs and lows to be very easily distinguished.\n"
19845  "\n"
19846  " Each control point must specify the cmap1 intensity index and the\n"
19847  " associated three coordinates in HLS or RGB space. The first point\n"
19848  " must correspond to position = 0, and the last to position = 1.\n"
19849  "\n"
19850  " If RGB colors are provided then the interpolation takes place in RGB\n"
19851  " space and is trivial. However if HLS colors are provided then, because\n"
19852  " of the circular nature of the color wheel for the hue coordinate, the\n"
19853  " interpolation could be performed in either direction around the color\n"
19854  " wheel. The default behaviour is for the hue to be linearly\n"
19855  " interpolated ignoring this circular property of hue. So for example,\n"
19856  " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19857  " green and cyan. If instead you wish to interpolate the other way\n"
19858  " around the color wheel you have two options. You may provide hues\n"
19859  " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19860  " for red the interpolation will proceed via magenta. Alternatively you\n"
19861  " can utilise the alt_hue_path variable to reverse the direction of\n"
19862  " interpolation if you need to provide hues within the [0-360) range.\n"
19863  "\n"
19864  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19865  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19866  " -120]falsegreen-yellow-red-magenta-blue[240\n"
19867  " 480]falseblue-magenta-red-yellow-green[120\n"
19868  " 240]truegreen-yellow-red-magenta-blue[240\n"
19869  " 120]trueblue-magenta-red-yellow-green\n"
19870  "\n"
19871  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19872  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19873  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19874  "\n"
19875  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19876  " alt_hue_path)\n"
19877  "\n"
19878  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19879  "\n"
19880  "\n"
19881  "\n"
19882  "SYNOPSIS:\n"
19883  "\n"
19884  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19885  "\n"
19886  "ARGUMENTS:\n"
19887  "\n"
19888  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19889  "\n"
19890  " npts (PLINT, input) : number of control points\n"
19891  "\n"
19892  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19893  " intensity index (0.0-1.0) in ascending order for each control\n"
19894  " point.\n"
19895  "\n"
19896  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19897  " coordinate (H or R) for each control point.\n"
19898  "\n"
19899  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19900  " coordinate (L or G) for each control point.\n"
19901  "\n"
19902  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19903  " coordinate (S or B) for each control point.\n"
19904  "\n"
19905  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19906  " npts - 1 elements), each containing either true to use the reversed\n"
19907  " HLS interpolation or false to use the regular HLS interpolation.\n"
19908  " (alt_hue_path[i] refers to the interpolation interval between the\n"
19909  " i and i + 1 control points). This parameter is not used for RGB\n"
19910  " colors (\n"
19911  " itype = true).\n"
19912  "\n"
19913  ""},
19914  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19915  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19916  "\n"
19917  "DESCRIPTION:\n"
19918  "\n"
19919  " This is a variant of plscmap1l that supports alpha channel\n"
19920  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19921  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19922  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19923  " transparency value (0.0-1.0). It may be called at any time.\n"
19924  "\n"
19925  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19926  " alpha, alt_hue_path)\n"
19927  "\n"
19928  " This function is used in example 30.\n"
19929  "\n"
19930  "\n"
19931  "\n"
19932  "SYNOPSIS:\n"
19933  "\n"
19934  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19935  "\n"
19936  "ARGUMENTS:\n"
19937  "\n"
19938  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19939  "\n"
19940  " npts (PLINT, input) : number of control points.\n"
19941  "\n"
19942  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19943  " intensity index (0.0-1.0) in ascending order for each control\n"
19944  " point.\n"
19945  "\n"
19946  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19947  " coordinate (H or R) for each control point.\n"
19948  "\n"
19949  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19950  " coordinate (L or G) for each control point.\n"
19951  "\n"
19952  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19953  " coordinate (S or B) for each control point.\n"
19954  "\n"
19955  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19956  " transparency value (0.0-1.0) for each control point.\n"
19957  "\n"
19958  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19959  " npts - 1 elements) containing the alternative interpolation method\n"
19960  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19961  " refers to the interpolation interval between the i and i + 1\n"
19962  " control points).\n"
19963  "\n"
19964  ""},
19965  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19966  "Set number of colors in cmap1\n"
19967  "\n"
19968  "DESCRIPTION:\n"
19969  "\n"
19970  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19971  " values if this is the first allocation (see the PLplot documentation).\n"
19972  "\n"
19973  " Redacted form: plscmap1n(ncol1)\n"
19974  "\n"
19975  " This function is used in examples 8, 11, 20, and 21.\n"
19976  "\n"
19977  "\n"
19978  "\n"
19979  "SYNOPSIS:\n"
19980  "\n"
19981  "plscmap1n(ncol1)\n"
19982  "\n"
19983  "ARGUMENTS:\n"
19984  "\n"
19985  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19986  " the cmap1 palette. If this number is zero or less, then the value\n"
19987  " from the previous call to plscmap1n is used and if there is no\n"
19988  " previous call, then a default value is used.\n"
19989  "\n"
19990  ""},
19991  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
19992  "Set the cmap1 argument range for continuous color plots\n"
19993  "\n"
19994  "DESCRIPTION:\n"
19995  "\n"
19996  " Set the cmap1 argument range for continuous color plots that\n"
19997  " corresponds to the range of data values. The maximum range\n"
19998  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19999  " the cmap1 argument range that is specified with this routine, the\n"
20000  " smaller the subset of the cmap1 color palette that is used to\n"
20001  " represent the continuous data being plotted. If\n"
20002  " min_color is greater than\n"
20003  " max_color or\n"
20004  " max_color is greater than 1.0 or\n"
20005  " min_color is less than 0.0 then no change is made to the cmap1\n"
20006  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20007  "\n"
20008  " Redacted form: plscmap1_range(min_color, max_color)\n"
20009  "\n"
20010  " This function is currently used in example 33.\n"
20011  "\n"
20012  "\n"
20013  "\n"
20014  "SYNOPSIS:\n"
20015  "\n"
20016  "plscmap1_range(min_color, max_color)\n"
20017  "\n"
20018  "ARGUMENTS:\n"
20019  "\n"
20020  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20021  " than 0.0, then 0.0 is used instead.\n"
20022  "\n"
20023  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20024  " than 1.0, then 1.0 is used instead.\n"
20025  "\n"
20026  ""},
20027  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
20028  "Get the cmap1 argument range for continuous color plots\n"
20029  "\n"
20030  "DESCRIPTION:\n"
20031  "\n"
20032  " Get the cmap1 argument range for continuous color plots. (Use\n"
20033  " plscmap1_range to set the cmap1 argument range.)\n"
20034  "\n"
20035  " Redacted form: plgcmap1_range(min_color, max_color)\n"
20036  "\n"
20037  " This function is currently not used in any example.\n"
20038  "\n"
20039  "\n"
20040  "\n"
20041  "SYNOPSIS:\n"
20042  "\n"
20043  "plgcmap1_range(min_color, max_color)\n"
20044  "\n"
20045  "ARGUMENTS:\n"
20046  "\n"
20047  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20048  " minimum cmap1 argument.\n"
20049  "\n"
20050  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20051  " maximum cmap1 argument.\n"
20052  "\n"
20053  ""},
20054  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
20055  "Set 8-bit RGB values for given cmap0 color index\n"
20056  "\n"
20057  "DESCRIPTION:\n"
20058  "\n"
20059  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20060  " index. Overwrites the previous color value for the given index and,\n"
20061  " thus, does not result in any additional allocation of space for\n"
20062  " colors.\n"
20063  "\n"
20064  " Redacted form: plscol0(icol0, r, g, b)\n"
20065  "\n"
20066  " This function is used in any example 31.\n"
20067  "\n"
20068  "\n"
20069  "\n"
20070  "SYNOPSIS:\n"
20071  "\n"
20072  "plscol0(icol0, r, g, b)\n"
20073  "\n"
20074  "ARGUMENTS:\n"
20075  "\n"
20076  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20077  " number of colors (which is set by default, by plscmap0n, or even\n"
20078  " by plscmap0).\n"
20079  "\n"
20080  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20081  " degree of red in the color.\n"
20082  "\n"
20083  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20084  " degree of green in the color.\n"
20085  "\n"
20086  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20087  " degree of blue in the color.\n"
20088  "\n"
20089  ""},
20090  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
20091  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20092  "\n"
20093  "DESCRIPTION:\n"
20094  "\n"
20095  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20096  " (see the PLplot documentation) index. Overwrites the previous color\n"
20097  " value for the given index and, thus, does not result in any additional\n"
20098  " allocation of space for colors.\n"
20099  "\n"
20100  " This function is used in example 30.\n"
20101  "\n"
20102  "\n"
20103  "\n"
20104  "SYNOPSIS:\n"
20105  "\n"
20106  "plscol0a(icol0, r, g, b, alpha)\n"
20107  "\n"
20108  "ARGUMENTS:\n"
20109  "\n"
20110  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20111  " number of colors (which is set by default, by plscmap0n, or even\n"
20112  " by plscmap0).\n"
20113  "\n"
20114  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20115  " degree of red in the color.\n"
20116  "\n"
20117  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20118  " degree of green in the color.\n"
20119  "\n"
20120  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20121  " degree of blue in the color.\n"
20122  "\n"
20123  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20124  " (0.0-1.0).\n"
20125  "\n"
20126  ""},
20127  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
20128  "Set the background color by 8-bit RGB value\n"
20129  "\n"
20130  "DESCRIPTION:\n"
20131  "\n"
20132  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20133  " the PLplot documentation).\n"
20134  "\n"
20135  " Redacted form: plscolbg(r, g, b)\n"
20136  "\n"
20137  " This function is used in examples 15 and 31.\n"
20138  "\n"
20139  "\n"
20140  "\n"
20141  "SYNOPSIS:\n"
20142  "\n"
20143  "plscolbg(r, g, b)\n"
20144  "\n"
20145  "ARGUMENTS:\n"
20146  "\n"
20147  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20148  " degree of red in the color.\n"
20149  "\n"
20150  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20151  " degree of green in the color.\n"
20152  "\n"
20153  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20154  " degree of blue in the color.\n"
20155  "\n"
20156  ""},
20157  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
20158  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20159  "\n"
20160  "DESCRIPTION:\n"
20161  "\n"
20162  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20163  " PLFLT alpha transparency value (see the PLplot documentation).\n"
20164  "\n"
20165  " This function is used in example 31.\n"
20166  "\n"
20167  "\n"
20168  "\n"
20169  "SYNOPSIS:\n"
20170  "\n"
20171  "plscolbga(r, g, b, alpha)\n"
20172  "\n"
20173  "ARGUMENTS:\n"
20174  "\n"
20175  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20176  " degree of red in the color.\n"
20177  "\n"
20178  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20179  " degree of green in the color.\n"
20180  "\n"
20181  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20182  " degree of blue in the color.\n"
20183  "\n"
20184  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20185  " (0.0-1.0).\n"
20186  "\n"
20187  ""},
20188  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
20189  "Used to globally turn color output on/off\n"
20190  "\n"
20191  "DESCRIPTION:\n"
20192  "\n"
20193  " Used to globally turn color output on/off for those drivers/devices\n"
20194  " that support it.\n"
20195  "\n"
20196  " Redacted form: plscolor(color)\n"
20197  "\n"
20198  " This function is used in example 31.\n"
20199  "\n"
20200  "\n"
20201  "\n"
20202  "SYNOPSIS:\n"
20203  "\n"
20204  "plscolor(color)\n"
20205  "\n"
20206  "ARGUMENTS:\n"
20207  "\n"
20208  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20209  " turned off. If non-zero, color is turned on.\n"
20210  "\n"
20211  ""},
20212  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
20213  "Set device-compression level\n"
20214  "\n"
20215  "DESCRIPTION:\n"
20216  "\n"
20217  " Set device-compression level. Only used for drivers that provide\n"
20218  " compression. This function, if used, should be invoked before a call\n"
20219  " to plinit.\n"
20220  "\n"
20221  " Redacted form: plscompression(compression)\n"
20222  "\n"
20223  " This function is used in example 31.\n"
20224  "\n"
20225  "\n"
20226  "\n"
20227  "SYNOPSIS:\n"
20228  "\n"
20229  "plscompression(compression)\n"
20230  "\n"
20231  "ARGUMENTS:\n"
20232  "\n"
20233  " compression (PLINT, input) : The desired compression level. This is\n"
20234  " a device-dependent value. Currently only the jpeg and png devices\n"
20235  " use these values. For jpeg value is the jpeg quality which should\n"
20236  " normally be in the range 0-95. Higher values denote higher quality\n"
20237  " and hence larger image sizes. For png values are in the range -1\n"
20238  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20239  " A value of -1 denotes the default zlib compression level. Values\n"
20240  " in the range 10-99 are divided by 10 and then used as the zlib\n"
20241  " compression level. Higher compression levels correspond to greater\n"
20242  " compression and small file sizes at the expense of more\n"
20243  " computation.\n"
20244  "\n"
20245  ""},
20246  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
20247  "Set the device (keyword) name\n"
20248  "\n"
20249  "DESCRIPTION:\n"
20250  "\n"
20251  " Set the device (keyword) name.\n"
20252  "\n"
20253  " Redacted form: plsdev(devname)\n"
20254  "\n"
20255  " This function is used in examples 1, 14, and 20.\n"
20256  "\n"
20257  "\n"
20258  "\n"
20259  "SYNOPSIS:\n"
20260  "\n"
20261  "plsdev(devname)\n"
20262  "\n"
20263  "ARGUMENTS:\n"
20264  "\n"
20265  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20266  " containing the device name keyword of the required output device.\n"
20267  " If\n"
20268  " devname is NULL or if the first character of the string is a ``?'',\n"
20269  " the normal (prompted) start up is used.\n"
20270  "\n"
20271  ""},
20272  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
20273  "Set parameters that define current device-space window\n"
20274  "\n"
20275  "DESCRIPTION:\n"
20276  "\n"
20277  " Set relative margin width, aspect ratio, and relative justification\n"
20278  " that define current device-space window. If you want to just use the\n"
20279  " previous value for any of these, just pass in the magic value\n"
20280  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20281  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20282  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20283  " to a device-specific value.\n"
20284  "\n"
20285  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20286  "\n"
20287  " This function is used in example 31.\n"
20288  "\n"
20289  "\n"
20290  "\n"
20291  "SYNOPSIS:\n"
20292  "\n"
20293  "plsdidev(mar, aspect, jx, jy)\n"
20294  "\n"
20295  "ARGUMENTS:\n"
20296  "\n"
20297  " mar (PLFLT, input) : Relative margin width.\n"
20298  "\n"
20299  " aspect (PLFLT, input) : Aspect ratio.\n"
20300  "\n"
20301  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20302  " the range -0.5 to 0.5.\n"
20303  "\n"
20304  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20305  " the range -0.5 to 0.5.\n"
20306  "\n"
20307  ""},
20308  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
20309  "Set up transformation from metafile coordinates\n"
20310  "\n"
20311  "DESCRIPTION:\n"
20312  "\n"
20313  " Set up transformation from metafile coordinates. The size of the plot\n"
20314  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20315  " general-purpose facility just yet (not sure why the user would need\n"
20316  " it, for one).\n"
20317  "\n"
20318  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20319  " dimypmm)\n"
20320  "\n"
20321  " This function is not used in any examples.\n"
20322  "\n"
20323  "\n"
20324  "\n"
20325  "SYNOPSIS:\n"
20326  "\n"
20327  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20328  "\n"
20329  "ARGUMENTS:\n"
20330  "\n"
20331  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20332  "\n"
20333  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20334  "\n"
20335  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20336  "\n"
20337  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20338  "\n"
20339  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20340  "\n"
20341  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20342  "\n"
20343  ""},
20344  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
20345  "Set plot orientation\n"
20346  "\n"
20347  "DESCRIPTION:\n"
20348  "\n"
20349  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20350  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20351  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20352  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20353  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20354  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20355  " not called the default value of rot is 0.\n"
20356  "\n"
20357  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20358  " probably want to change the aspect ratio to a value suitable for the\n"
20359  " plot orientation using a call to plsdidev or the command-line options\n"
20360  " -a or -freeaspect. For more documentation of those options see the\n"
20361  " PLplot documentation. Such command-line options can be set internally\n"
20362  " using plsetopt or set directly using the command line and parsed using\n"
20363  " a call to plparseopts.\n"
20364  "\n"
20365  " Redacted form: plsdiori(rot)\n"
20366  "\n"
20367  " This function is not used in any examples.\n"
20368  "\n"
20369  "\n"
20370  "\n"
20371  "SYNOPSIS:\n"
20372  "\n"
20373  "plsdiori(rot)\n"
20374  "\n"
20375  "ARGUMENTS:\n"
20376  "\n"
20377  " rot (PLFLT, input) : Plot orientation parameter.\n"
20378  "\n"
20379  ""},
20380  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
20381  "Set parameters that define current plot-space window\n"
20382  "\n"
20383  "DESCRIPTION:\n"
20384  "\n"
20385  " Set relative minima and maxima that define the current plot-space\n"
20386  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20387  " xmax, and ymax are 0., 0., 1., and 1.\n"
20388  "\n"
20389  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20390  "\n"
20391  " This function is used in example 31.\n"
20392  "\n"
20393  "\n"
20394  "\n"
20395  "SYNOPSIS:\n"
20396  "\n"
20397  "plsdiplt(xmin, ymin, xmax, ymax)\n"
20398  "\n"
20399  "ARGUMENTS:\n"
20400  "\n"
20401  " xmin (PLFLT, input) : Relative minimum in x.\n"
20402  "\n"
20403  " ymin (PLFLT, input) : Relative minimum in y.\n"
20404  "\n"
20405  " xmax (PLFLT, input) : Relative maximum in x.\n"
20406  "\n"
20407  " ymax (PLFLT, input) : Relative maximum in y.\n"
20408  "\n"
20409  ""},
20410  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
20411  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20412  "\n"
20413  "DESCRIPTION:\n"
20414  "\n"
20415  " Set relative minima and maxima incrementally (zoom mode) that define\n"
20416  " the current plot-space window. This function has the same effect as\n"
20417  " plsdiplt if that function has not been previously called. Otherwise,\n"
20418  " this function implements zoom mode using the transformation min_used =\n"
20419  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20420  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20421  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20422  "\n"
20423  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20424  "\n"
20425  " This function is used in example 31.\n"
20426  "\n"
20427  "\n"
20428  "\n"
20429  "SYNOPSIS:\n"
20430  "\n"
20431  "plsdiplz(xmin, ymin, xmax, ymax)\n"
20432  "\n"
20433  "ARGUMENTS:\n"
20434  "\n"
20435  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20436  "\n"
20437  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20438  "\n"
20439  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20440  "\n"
20441  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20442  "\n"
20443  ""},
20444  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
20445  "Set seed for internal random number generator.\n"
20446  "\n"
20447  "DESCRIPTION:\n"
20448  "\n"
20449  " Set the seed for the internal random number generator. See plrandd for\n"
20450  " further details.\n"
20451  "\n"
20452  " Redacted form: plseed(seed)\n"
20453  "\n"
20454  " This function is used in example 21.\n"
20455  "\n"
20456  "\n"
20457  "\n"
20458  "SYNOPSIS:\n"
20459  "\n"
20460  "plseed(seed)\n"
20461  "\n"
20462  "ARGUMENTS:\n"
20463  "\n"
20464  " seed (unsigned int, input) : Seed for random number generator.\n"
20465  "\n"
20466  ""},
20467  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
20468  "Set the escape character for text strings\n"
20469  "\n"
20470  "DESCRIPTION:\n"
20471  "\n"
20472  " Set the escape character for text strings. From C (in contrast to\n"
20473  " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20474  " characters are allowed to prevent the user from shooting himself in\n"
20475  " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20476  " use of backslash as a character escape). Here are the allowed escape\n"
20477  " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20478  " #, ASCII 35\n"
20479  " $, ASCII 36\n"
20480  " %, ASCII 37\n"
20481  " &, ASCII 38\n"
20482  " *, ASCII 42\n"
20483  " @, ASCII 64\n"
20484  " ^, ASCII 94\n"
20485  " ~, ASCII 126\n"
20486  "\n"
20487  "\n"
20488  " Redacted form: General: plsesc(esc)\n"
20489  "\n"
20490  "\n"
20491  " This function is used in example 29.\n"
20492  "\n"
20493  "\n"
20494  "\n"
20495  "SYNOPSIS:\n"
20496  "\n"
20497  "plsesc(esc)\n"
20498  "\n"
20499  "ARGUMENTS:\n"
20500  "\n"
20501  " esc (char, input) : Escape character.\n"
20502  "\n"
20503  ""},
20504  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
20505  "Set any command-line option\n"
20506  "\n"
20507  "DESCRIPTION:\n"
20508  "\n"
20509  " Set any command-line option internally from a program before it\n"
20510  " invokes plinit. opt is the name of the command-line option and optarg\n"
20511  " is the corresponding command-line option argument.\n"
20512  "\n"
20513  " This function returns 0 on success.\n"
20514  "\n"
20515  " Redacted form: plsetopt(opt, optarg)\n"
20516  "\n"
20517  " This function is used in example 14.\n"
20518  "\n"
20519  "\n"
20520  "\n"
20521  "SYNOPSIS:\n"
20522  "\n"
20523  "PLINT plsetopt(opt, optarg)\n"
20524  "\n"
20525  "ARGUMENTS:\n"
20526  "\n"
20527  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20528  " the command-line option.\n"
20529  "\n"
20530  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20531  " containing the argument of the command-line option.\n"
20532  "\n"
20533  ""},
20534  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
20535  "Set family file parameters\n"
20536  "\n"
20537  "DESCRIPTION:\n"
20538  "\n"
20539  " Sets variables dealing with output file familying. Does nothing if\n"
20540  " familying not supported by the driver. This routine, if used, must be\n"
20541  " called before initializing PLplot. See the PLplot documentation for\n"
20542  " more information.\n"
20543  "\n"
20544  " Redacted form: plsfam(fam, num, bmax)\n"
20545  "\n"
20546  " This function is used in examples 14 and 31.\n"
20547  "\n"
20548  "\n"
20549  "\n"
20550  "SYNOPSIS:\n"
20551  "\n"
20552  "plsfam(fam, num, bmax)\n"
20553  "\n"
20554  "ARGUMENTS:\n"
20555  "\n"
20556  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20557  " is enabled.\n"
20558  "\n"
20559  " num (PLINT, input) : Current family file number.\n"
20560  "\n"
20561  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20562  " file.\n"
20563  "\n"
20564  ""},
20565  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
20566  "Set FCI (font characterization integer)\n"
20567  "\n"
20568  "DESCRIPTION:\n"
20569  "\n"
20570  " Sets font characteristics to be used at the start of the next string\n"
20571  " using the FCI approach. See the PLplot documentation for more\n"
20572  " information. Note, plsfont (which calls plsfci internally) provides a\n"
20573  " more user-friendly API for setting the font characterisitics.\n"
20574  "\n"
20575  " Redacted form: General: plsfci(fci)\n"
20576  "\n"
20577  "\n"
20578  " This function is used in example 23.\n"
20579  "\n"
20580  "\n"
20581  "\n"
20582  "SYNOPSIS:\n"
20583  "\n"
20584  "plsfci(fci)\n"
20585  "\n"
20586  "ARGUMENTS:\n"
20587  "\n"
20588  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20589  " of FCI.\n"
20590  "\n"
20591  ""},
20592  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
20593  "Set output file name\n"
20594  "\n"
20595  "DESCRIPTION:\n"
20596  "\n"
20597  " Sets the current output file name, if applicable. If the file name\n"
20598  " has not been specified and is required by the driver, the user will be\n"
20599  " prompted for it. If using the X-windows output driver, this sets the\n"
20600  " display name. This routine, if used, must be called before\n"
20601  " initializing PLplot.\n"
20602  "\n"
20603  " Redacted form: plsfnam(fnam)\n"
20604  "\n"
20605  " This function is used in examples 1 and 20.\n"
20606  "\n"
20607  "\n"
20608  "\n"
20609  "SYNOPSIS:\n"
20610  "\n"
20611  "plsfnam(fnam)\n"
20612  "\n"
20613  "ARGUMENTS:\n"
20614  "\n"
20615  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20616  " the file name.\n"
20617  "\n"
20618  ""},
20619  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
20620  "Set family, style and weight of the current font\n"
20621  "\n"
20622  "DESCRIPTION:\n"
20623  "\n"
20624  " Sets the current font. See the PLplot documentation for more\n"
20625  " information on font selection.\n"
20626  "\n"
20627  " Redacted form: plsfont(family, style, weight)\n"
20628  "\n"
20629  " This function is used in example 23.\n"
20630  "\n"
20631  "\n"
20632  "\n"
20633  "SYNOPSIS:\n"
20634  "\n"
20635  "plsfont(family, style, weight)\n"
20636  "\n"
20637  "ARGUMENTS:\n"
20638  "\n"
20639  " family (PLINT, input) : Font family to select for the current font.\n"
20640  " The available values are given by the PL_FCI_* constants in\n"
20641  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20642  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20643  " signifies that the font family should not be altered.\n"
20644  "\n"
20645  " style (PLINT, input) : Font style to select for the current font.\n"
20646  " The available values are given by the PL_FCI_* constants in\n"
20647  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20648  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20649  " should not be altered.\n"
20650  "\n"
20651  " weight (PLINT, input) : Font weight to select for the current font.\n"
20652  " The available values are given by the PL_FCI_* constants in\n"
20653  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20654  " negative value signifies that the font weight should not be\n"
20655  " altered.\n"
20656  "\n"
20657  ""},
20658  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
20659  "Shade regions on the basis of value\n"
20660  "\n"
20661  "DESCRIPTION:\n"
20662  "\n"
20663  " Shade regions on the basis of value. This is the high-level routine\n"
20664  " for making continuous color shaded plots with cmap1 while plshade\n"
20665  " should be used to plot individual shaded regions using either cmap0 or\n"
20666  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20667  " our supported languages.\n"
20668  "\n"
20669  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20670  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20671  " pltr_data)\n"
20672  "\n"
20673  "\n"
20674  " This function is used in examples 16, 21, and 22.\n"
20675  "\n"
20676  "\n"
20677  "\n"
20678  "SYNOPSIS:\n"
20679  "\n"
20680  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20681  "\n"
20682  "ARGUMENTS:\n"
20683  "\n"
20684  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20685  " plot. Should have dimensions of\n"
20686  " nx by\n"
20687  " ny.\n"
20688  "\n"
20689  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20690  "\n"
20691  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20692  "\n"
20693  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20694  " the region that should be plotted in the shade plot. This\n"
20695  " function accepts x and y coordinates as input arguments and must\n"
20696  " return 1 if the point is to be included in the shade plot and 0\n"
20697  " otherwise. If you want to plot the entire shade plot (the usual\n"
20698  " case), this argument should be set to NULL.\n"
20699  "\n"
20700  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20701  " pltr below for how these arguments are used (only for the special case\n"
20702  " when the callback function\n"
20703  " pltr is not supplied).\n"
20704  "\n"
20705  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20706  " corresponding to the edges of each shaded region that will be\n"
20707  " plotted by this function. To work properly the levels should be\n"
20708  " monotonic.\n"
20709  "\n"
20710  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20711  " of shade edge values in clevel).\n"
20712  "\n"
20713  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20714  " pattern.\n"
20715  "\n"
20716  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20717  " contours defining edges of shaded regions. The pen color is only\n"
20718  " temporary set for the contour drawing. Set this value to zero or\n"
20719  " less if no shade edge contours are wanted.\n"
20720  "\n"
20721  " cont_width (PLFLT, input) : Defines line width used for contours\n"
20722  " defining edges of shaded regions. This value may not be honored\n"
20723  " by all drivers. The pen width is only temporary set for the\n"
20724  " contour drawing. Set this value to zero or less if no shade edge\n"
20725  " contours are wanted.\n"
20726  "\n"
20727  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20728  " region. Use plfill for this purpose.\n"
20729  "\n"
20730  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20731  " map to rectangles after coordinate transformation with pltrl.\n"
20732  " Otherwise, set rectangular to false. If rectangular is set to\n"
20733  " true, plshade tries to save time by filling large rectangles.\n"
20734  " This optimization fails if the coordinate transformation distorts\n"
20735  " the shape of rectangles. For example a plot in polar coordinates\n"
20736  " has to have rectangular set to false.\n"
20737  "\n"
20738  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20739  " defines the transformation between the zero-based indices of the\n"
20740  " matrix a and world coordinates. If\n"
20741  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20742  " indices of a are mapped to the range\n"
20743  " xmin through\n"
20744  " xmax and the y indices of a are mapped to the range\n"
20745  " ymin through\n"
20746  " ymax.For the C case, transformation functions are provided in the\n"
20747  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20748  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20749  " matrices. In addition, C callback routines for the transformation\n"
20750  " can be supplied by the user such as the mypltr function in\n"
20751  " examples/c/x09c.c which provides a general linear transformation\n"
20752  " between index coordinates and world coordinates.For languages\n"
20753  " other than C you should consult the PLplot documentation for the\n"
20754  " details concerning how PLTRANSFORM_callback arguments are\n"
20755  " interfaced. However, in general, a particular pattern of\n"
20756  " callback-associated arguments such as a tr vector with 6 elements;\n"
20757  " xg and yg vectors; or xg and yg matrices are respectively\n"
20758  " interfaced to a linear-transformation routine similar to the above\n"
20759  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20760  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20761  " support native language callbacks for handling index to\n"
20762  " world-coordinate transformations. Examples of these various\n"
20763  " approaches are given in examples/<language>x09*,\n"
20764  " examples/<language>x16*, examples/<language>x20*,\n"
20765  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20766  " supported languages.\n"
20767  "\n"
20768  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20769  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20770  " externally supplied.\n"
20771  "\n"
20772  ""},
20773  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20774  "Shade individual region on the basis of value\n"
20775  "\n"
20776  "DESCRIPTION:\n"
20777  "\n"
20778  " Shade individual region on the basis of value. Use plshades if you\n"
20779  " want to shade a number of contiguous regions using continuous colors.\n"
20780  " In particular the edge contours are treated properly in plshades. If\n"
20781  " you attempt to do contiguous regions with plshade the contours at the\n"
20782  " edge of the shade are partially obliterated by subsequent plots of\n"
20783  " contiguous shaded regions.\n"
20784  "\n"
20785  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20786  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20787  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20788  "\n"
20789  "\n"
20790  " This function is used in example 15.\n"
20791  "\n"
20792  "\n"
20793  "\n"
20794  "SYNOPSIS:\n"
20795  "\n"
20796  "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"
20797  "\n"
20798  "ARGUMENTS:\n"
20799  "\n"
20800  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20801  " plot. Should have dimensions of\n"
20802  " nx by\n"
20803  " ny.\n"
20804  "\n"
20805  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20806  "\n"
20807  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20808  "\n"
20809  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20810  " the region that should be plotted in the shade plot. This\n"
20811  " function accepts x and y coordinates as input arguments and must\n"
20812  " return 1 if the point is to be included in the shade plot and 0\n"
20813  " otherwise. If you want to plot the entire shade plot (the usual\n"
20814  " case), this argument should be set to NULL.\n"
20815  "\n"
20816  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20817  " pltr below for how these arguments are used (only for the special case\n"
20818  " when the callback function\n"
20819  " pltr is not supplied).\n"
20820  "\n"
20821  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20822  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20823  "\n"
20824  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20825  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20826  "\n"
20827  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20828  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20829  " then sh_color is interpreted as a cmap1 argument in the range\n"
20830  " (0.0-1.0).\n"
20831  "\n"
20832  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20833  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20834  "\n"
20835  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20836  "\n"
20837  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20838  " boundary of shaded region. The min values are used for the\n"
20839  " shade_min boundary, and the max values are used on the shade_max\n"
20840  " boundary. Set color and width to zero for no plotted boundaries.\n"
20841  "\n"
20842  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20843  " boundary of shaded region. The min values are used for the\n"
20844  " shade_min boundary, and the max values are used on the shade_max\n"
20845  " boundary. Set color and width to zero for no plotted boundaries.\n"
20846  "\n"
20847  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20848  " boundary of shaded region. The min values are used for the\n"
20849  " shade_min boundary, and the max values are used on the shade_max\n"
20850  " boundary. Set color and width to zero for no plotted boundaries.\n"
20851  "\n"
20852  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20853  " boundary of shaded region. The min values are used for the\n"
20854  " shade_min boundary, and the max values are used on the shade_max\n"
20855  " boundary. Set color and width to zero for no plotted boundaries.\n"
20856  "\n"
20857  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20858  " Use plfill. Future version of PLplot may have other fill\n"
20859  " routines.\n"
20860  "\n"
20861  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20862  " map to rectangles after coordinate transformation with pltrl.\n"
20863  " Otherwise, set rectangular to false. If rectangular is set to\n"
20864  " true, plshade tries to save time by filling large rectangles.\n"
20865  " This optimization fails if the coordinate transformation distorts\n"
20866  " the shape of rectangles. For example a plot in polar coordinates\n"
20867  " has to have rectangular set to false.\n"
20868  "\n"
20869  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20870  " defines the transformation between the zero-based indices of the\n"
20871  " matrix a and world coordinates. If\n"
20872  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20873  " indices of a are mapped to the range\n"
20874  " xmin through\n"
20875  " xmax and the y indices of a are mapped to the range\n"
20876  " ymin through\n"
20877  " ymax.For the C case, transformation functions are provided in the\n"
20878  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20879  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20880  " matrices. In addition, C callback routines for the transformation\n"
20881  " can be supplied by the user such as the mypltr function in\n"
20882  " examples/c/x09c.c which provides a general linear transformation\n"
20883  " between index coordinates and world coordinates.For languages\n"
20884  " other than C you should consult the PLplot documentation for the\n"
20885  " details concerning how PLTRANSFORM_callback arguments are\n"
20886  " interfaced. However, in general, a particular pattern of\n"
20887  " callback-associated arguments such as a tr vector with 6 elements;\n"
20888  " xg and yg vectors; or xg and yg matrices are respectively\n"
20889  " interfaced to a linear-transformation routine similar to the above\n"
20890  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20891  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20892  " support native language callbacks for handling index to\n"
20893  " world-coordinate transformations. Examples of these various\n"
20894  " approaches are given in examples/<language>x09*,\n"
20895  " examples/<language>x16*, examples/<language>x20*,\n"
20896  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20897  " supported languages.\n"
20898  "\n"
20899  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20900  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20901  " externally supplied.\n"
20902  "\n"
20903  ""},
20904  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20905  "Assign a function to use for generating custom axis labels\n"
20906  "\n"
20907  "DESCRIPTION:\n"
20908  "\n"
20909  " This function allows a user to provide their own function to provide\n"
20910  " axis label text. The user function is given the numeric value for a\n"
20911  " point on an axis and returns a string label to correspond with that\n"
20912  " value. Custom axis labels can be enabled by passing appropriate\n"
20913  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20914  "\n"
20915  " This function is used in example 19.\n"
20916  "\n"
20917  "\n"
20918  "\n"
20919  "SYNOPSIS:\n"
20920  "\n"
20921  "plslabelfunc(label_func, label_data)\n"
20922  "\n"
20923  "ARGUMENTS:\n"
20924  "\n"
20925  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20926  " label function. In order to reset to the default labelling, set\n"
20927  " this to NULL. The labelling function parameters are, in order:\n"
20928  " axis: This indicates which axis a label is being requested for.\n"
20929  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20930  "\n"
20931  " value: This is the value along the axis which is being labelled.\n"
20932  "\n"
20933  " label_text: The string representation of the label value.\n"
20934  "\n"
20935  " length: The maximum length in characters allowed for label_text.\n"
20936  "\n"
20937  "\n"
20938  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20939  " data to the label_func function.\n"
20940  "\n"
20941  ""},
20942  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20943  "Set length of major ticks\n"
20944  "\n"
20945  "DESCRIPTION:\n"
20946  "\n"
20947  " This sets up the length of the major ticks. The actual length is the\n"
20948  " product of the default length and a scaling factor as for character\n"
20949  " height.\n"
20950  "\n"
20951  " Redacted form: plsmaj(def, scale)\n"
20952  "\n"
20953  " This function is used in example 29.\n"
20954  "\n"
20955  "\n"
20956  "\n"
20957  "SYNOPSIS:\n"
20958  "\n"
20959  "plsmaj(def, scale)\n"
20960  "\n"
20961  "ARGUMENTS:\n"
20962  "\n"
20963  " def (PLFLT, input) : The default length of a major tick in\n"
20964  " millimeters, should be set to zero if the default length is to\n"
20965  " remain unchanged.\n"
20966  "\n"
20967  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20968  " actual tick length.\n"
20969  "\n"
20970  ""},
20971  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20972  "Set the memory area to be plotted (RGB)\n"
20973  "\n"
20974  "DESCRIPTION:\n"
20975  "\n"
20976  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20977  " the dev member of the stream structure. Also set the number of pixels\n"
20978  " in the memory passed in\n"
20979  " plotmem, which is a block of memory\n"
20980  " maxy by\n"
20981  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20982  "\n"
20983  " This memory will have to be freed by the user!\n"
20984  "\n"
20985  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20986  "\n"
20987  " This function is not used in any examples.\n"
20988  "\n"
20989  "\n"
20990  "\n"
20991  "SYNOPSIS:\n"
20992  "\n"
20993  "plsmem(maxx, maxy, plotmem)\n"
20994  "\n"
20995  "ARGUMENTS:\n"
20996  "\n"
20997  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20998  "\n"
20999  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21000  "\n"
21001  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21002  " user-supplied writeable memory area.\n"
21003  "\n"
21004  ""},
21005  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
21006  "Set the memory area to be plotted (RGBA)\n"
21007  "\n"
21008  "DESCRIPTION:\n"
21009  "\n"
21010  " Set the memory area to be plotted (with the memcairo driver) as the\n"
21011  " dev member of the stream structure. Also set the number of pixels in\n"
21012  " the memory passed in\n"
21013  " plotmem, which is a block of memory\n"
21014  " maxy by\n"
21015  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21016  "\n"
21017  " This memory will have to be freed by the user!\n"
21018  "\n"
21019  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21020  "\n"
21021  " This function is not used in any examples.\n"
21022  "\n"
21023  "\n"
21024  "\n"
21025  "SYNOPSIS:\n"
21026  "\n"
21027  "plsmema(maxx, maxy, plotmem)\n"
21028  "\n"
21029  "ARGUMENTS:\n"
21030  "\n"
21031  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21032  "\n"
21033  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21034  "\n"
21035  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21036  " user-supplied writeable memory area.\n"
21037  "\n"
21038  ""},
21039  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
21040  "Set length of minor ticks\n"
21041  "\n"
21042  "DESCRIPTION:\n"
21043  "\n"
21044  " This sets up the length of the minor ticks and the length of the\n"
21045  " terminals on error bars. The actual length is the product of the\n"
21046  " default length and a scaling factor as for character height.\n"
21047  "\n"
21048  " Redacted form: plsmin(def, scale)\n"
21049  "\n"
21050  " This function is used in example 29.\n"
21051  "\n"
21052  "\n"
21053  "\n"
21054  "SYNOPSIS:\n"
21055  "\n"
21056  "plsmin(def, scale)\n"
21057  "\n"
21058  "ARGUMENTS:\n"
21059  "\n"
21060  " def (PLFLT, input) : The default length of a minor tick in\n"
21061  " millimeters, should be set to zero if the default length is to\n"
21062  " remain unchanged.\n"
21063  "\n"
21064  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21065  " actual tick length.\n"
21066  "\n"
21067  ""},
21068  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
21069  "Set orientation\n"
21070  "\n"
21071  "DESCRIPTION:\n"
21072  "\n"
21073  " Set integer plot orientation parameter. This function is identical to\n"
21074  " plsdiori except for the type of the argument, and should be used in\n"
21075  " the same way. See the documentation of plsdiori for details.\n"
21076  "\n"
21077  " Redacted form: plsori(ori)\n"
21078  "\n"
21079  " This function is used in example 3.\n"
21080  "\n"
21081  "\n"
21082  "\n"
21083  "SYNOPSIS:\n"
21084  "\n"
21085  "plsori(ori)\n"
21086  "\n"
21087  "ARGUMENTS:\n"
21088  "\n"
21089  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21090  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21091  " angle.\n"
21092  "\n"
21093  ""},
21094  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
21095  "Set page parameters\n"
21096  "\n"
21097  "DESCRIPTION:\n"
21098  "\n"
21099  " Sets the page configuration (optional). If an individual parameter is\n"
21100  " zero then that parameter value is not updated. Not all parameters are\n"
21101  " recognized by all drivers and the interpretation is device-dependent.\n"
21102  " The X-window driver uses the length and offset parameters to determine\n"
21103  " the window size and location. The length and offset values are\n"
21104  " expressed in units that are specific to the current driver. For\n"
21105  " instance: screen drivers will usually interpret them as number of\n"
21106  " pixels, whereas printer drivers will usually use mm.\n"
21107  "\n"
21108  " This routine, if used, must be called before initializing PLplot. It\n"
21109  " may be called at later times for interactive drivers to change only\n"
21110  " the dpi for subsequent redraws which you can force via a call to\n"
21111  " plreplot. If this function is not called then the page size defaults\n"
21112  " to landscape A4 for drivers which use real world page sizes and 744\n"
21113  " pixels wide by 538 pixels high for raster drivers. The default value\n"
21114  " for dx and dy is 90 pixels per inch for raster drivers.\n"
21115  "\n"
21116  "\n"
21117  "\n"
21118  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21119  "\n"
21120  " This function is used in examples 14 and 31.\n"
21121  "\n"
21122  "\n"
21123  "\n"
21124  "SYNOPSIS:\n"
21125  "\n"
21126  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21127  "\n"
21128  "ARGUMENTS:\n"
21129  "\n"
21130  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21131  " by raster drivers, ignored by drivers which use \"real world\" units\n"
21132  " (e.g. mm).\n"
21133  "\n"
21134  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21135  " by raster drivers, ignored by drivers which use \"real world\" units\n"
21136  " (e.g. mm).\n"
21137  "\n"
21138  " xleng (PLINT, input) : Page length, x.\n"
21139  "\n"
21140  " yleng (PLINT, input) : Page length, y.\n"
21141  "\n"
21142  " xoff (PLINT, input) : Page offset, x.\n"
21143  "\n"
21144  " yoff (PLINT, input) : Page offset, y.\n"
21145  "\n"
21146  ""},
21147  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
21148  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21149  "\n"
21150  "DESCRIPTION:\n"
21151  "\n"
21152  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21153  "\n"
21154  " Redacted form: plspal0(filename)\n"
21155  "\n"
21156  " This function is in example 16.\n"
21157  "\n"
21158  "\n"
21159  "\n"
21160  "SYNOPSIS:\n"
21161  "\n"
21162  "plspal0(filename)\n"
21163  "\n"
21164  "ARGUMENTS:\n"
21165  "\n"
21166  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21167  " containing the name of the cmap0*.pal file. If this string is\n"
21168  " empty, use the default cmap0*.pal file.\n"
21169  "\n"
21170  ""},
21171  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
21172  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21173  "\n"
21174  "DESCRIPTION:\n"
21175  "\n"
21176  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21177  "\n"
21178  " Redacted form: plspal1(filename, interpolate)\n"
21179  "\n"
21180  " This function is used in example 16.\n"
21181  "\n"
21182  "\n"
21183  "\n"
21184  "SYNOPSIS:\n"
21185  "\n"
21186  "plspal1(filename, interpolate)\n"
21187  "\n"
21188  "ARGUMENTS:\n"
21189  "\n"
21190  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21191  " containing the name of the cmap1*.pal file. If this string is\n"
21192  " empty, use the default cmap1*.pal file.\n"
21193  "\n"
21194  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21195  " columns containing the intensity index, r, g, b, alpha and\n"
21196  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21197  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21198  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21199  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21200  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21201  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21202  " are used instead to set the cmap1 palette directly with a call to\n"
21203  " plscmap1a.\n"
21204  "\n"
21205  ""},
21206  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
21207  "Set the pause (on end-of-page) status\n"
21208  "\n"
21209  "DESCRIPTION:\n"
21210  "\n"
21211  " Set the pause (on end-of-page) status.\n"
21212  "\n"
21213  " Redacted form: plspause(pause)\n"
21214  "\n"
21215  " This function is in examples 14,20.\n"
21216  "\n"
21217  "\n"
21218  "\n"
21219  "SYNOPSIS:\n"
21220  "\n"
21221  "plspause(pause)\n"
21222  "\n"
21223  "ARGUMENTS:\n"
21224  "\n"
21225  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21226  " end-of-page for those drivers which support this. Otherwise there\n"
21227  " is no pause.\n"
21228  "\n"
21229  ""},
21230  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
21231  "Set current output stream\n"
21232  "\n"
21233  "DESCRIPTION:\n"
21234  "\n"
21235  " Sets the number of the current output stream. The stream number\n"
21236  " defaults to 0 unless changed by this routine. The first use of this\n"
21237  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21238  "\n"
21239  " Redacted form: plsstrm(strm)\n"
21240  "\n"
21241  " This function is examples 1,14,20.\n"
21242  "\n"
21243  "\n"
21244  "\n"
21245  "SYNOPSIS:\n"
21246  "\n"
21247  "plsstrm(strm)\n"
21248  "\n"
21249  "ARGUMENTS:\n"
21250  "\n"
21251  " strm (PLINT, input) : The current stream number.\n"
21252  "\n"
21253  ""},
21254  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
21255  "Set the number of subpages in x and y\n"
21256  "\n"
21257  "DESCRIPTION:\n"
21258  "\n"
21259  " Set the number of subpages in x and y.\n"
21260  "\n"
21261  " Redacted form: plssub(nx, ny)\n"
21262  "\n"
21263  " This function is examples 1,2,14,21,25,27.\n"
21264  "\n"
21265  "\n"
21266  "\n"
21267  "SYNOPSIS:\n"
21268  "\n"
21269  "plssub(nx, ny)\n"
21270  "\n"
21271  "ARGUMENTS:\n"
21272  "\n"
21273  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21274  " of window columns).\n"
21275  "\n"
21276  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21277  " of window rows).\n"
21278  "\n"
21279  ""},
21280  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
21281  "Set symbol size\n"
21282  "\n"
21283  "DESCRIPTION:\n"
21284  "\n"
21285  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21286  " plsym. The actual height of a symbol is the product of the default\n"
21287  " symbol size and a scaling factor as for the character height.\n"
21288  "\n"
21289  " Redacted form: plssym(def, scale)\n"
21290  "\n"
21291  " This function is used in example 29.\n"
21292  "\n"
21293  "\n"
21294  "\n"
21295  "SYNOPSIS:\n"
21296  "\n"
21297  "plssym(def, scale)\n"
21298  "\n"
21299  "ARGUMENTS:\n"
21300  "\n"
21301  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21302  " should be set to zero if the default height is to remain\n"
21303  " unchanged.\n"
21304  "\n"
21305  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21306  " actual symbol height.\n"
21307  "\n"
21308  ""},
21309  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
21310  "Initialization\n"
21311  "\n"
21312  "DESCRIPTION:\n"
21313  "\n"
21314  " Initializing the plotting package. The program prompts for the device\n"
21315  " keyword or number of the desired output device. Hitting a RETURN in\n"
21316  " response to the prompt is the same as selecting the first device. If\n"
21317  " only one device is enabled when PLplot is installed, plstar will issue\n"
21318  " no prompt. The output device is divided into nx by ny subpages, each\n"
21319  " of which may be used independently. The subroutine pladv is used to\n"
21320  " advance from one subpage to the next.\n"
21321  "\n"
21322  " Redacted form: plstar(nx, ny)\n"
21323  "\n"
21324  " This function is used in example 1.\n"
21325  "\n"
21326  "\n"
21327  "\n"
21328  "SYNOPSIS:\n"
21329  "\n"
21330  "plstar(nx, ny)\n"
21331  "\n"
21332  "ARGUMENTS:\n"
21333  "\n"
21334  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21335  " x direction.\n"
21336  "\n"
21337  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21338  " y direction.\n"
21339  "\n"
21340  ""},
21341  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
21342  "Initialization\n"
21343  "\n"
21344  "DESCRIPTION:\n"
21345  "\n"
21346  " Alternative to plstar for initializing the plotting package. The\n"
21347  " device name keyword for the desired output device must be supplied as\n"
21348  " an argument. These keywords are the same as those printed out by\n"
21349  " plstar. If the requested device is not available, or if the input\n"
21350  " string is empty or begins with ``?'', the prompted start up of plstar\n"
21351  " is used. This routine also divides the output device page into nx by\n"
21352  " ny subpages, each of which may be used independently. The subroutine\n"
21353  " pladv is used to advance from one subpage to the next.\n"
21354  "\n"
21355  " Redacted form: General: plstart(devname, nx, ny)\n"
21356  "\n"
21357  "\n"
21358  " This function is not used in any examples.\n"
21359  "\n"
21360  "\n"
21361  "\n"
21362  "SYNOPSIS:\n"
21363  "\n"
21364  "plstart(devname, nx, ny)\n"
21365  "\n"
21366  "ARGUMENTS:\n"
21367  "\n"
21368  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21369  " containing the device name keyword of the required output device.\n"
21370  " If\n"
21371  " devname is NULL or if the first character of the string is a ``?'',\n"
21372  " the normal (prompted) start up is used.\n"
21373  "\n"
21374  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21375  " x direction.\n"
21376  "\n"
21377  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21378  " y direction.\n"
21379  "\n"
21380  ""},
21381  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
21382  "Set a global coordinate transform function\n"
21383  "\n"
21384  "DESCRIPTION:\n"
21385  "\n"
21386  " This function can be used to define a coordinate transformation which\n"
21387  " affects all elements drawn within the current plot window. The\n"
21388  " coordinate_transform callback function is similar to that provided for\n"
21389  " the plmap and plmeridians functions. The coordinate_transform_data\n"
21390  " parameter may be used to pass extra data to coordinate_transform.\n"
21391  "\n"
21392  " Redacted form: General: plstransform(coordinate_transform,\n"
21393  " coordinate_transform_data)\n"
21394  "\n"
21395  "\n"
21396  " This function is used in examples 19 and 22.\n"
21397  "\n"
21398  "\n"
21399  "\n"
21400  "SYNOPSIS:\n"
21401  "\n"
21402  "plstransform(coordinate_transform, coordinate_transform_data)\n"
21403  "\n"
21404  "ARGUMENTS:\n"
21405  "\n"
21406  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21407  " function that defines the transformation from the input (x, y)\n"
21408  " world coordinates to new PLplot world coordinates. If\n"
21409  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21410  " case), then no transform is applied.\n"
21411  "\n"
21412  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21413  " for\n"
21414  " coordinate_transform.\n"
21415  "\n"
21416  ""},
21417  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
21418  "Plot a glyph at the specified points\n"
21419  "\n"
21420  "DESCRIPTION:\n"
21421  "\n"
21422  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21423  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21424  " is specified with a PLplot user string. Note that the user string is\n"
21425  " not actually limited to one glyph so it is possible (but not normally\n"
21426  " useful) to plot more than one glyph at the specified points with this\n"
21427  " function. As with plmtex and plptex, the user string can contain FCI\n"
21428  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21429  " else PLplot escapes for Hershey or unicode text to determine the\n"
21430  " glyph.\n"
21431  "\n"
21432  " Redacted form: plstring(x, y, string)\n"
21433  "\n"
21434  " This function is used in examples 4, 21 and 26.\n"
21435  "\n"
21436  "\n"
21437  "\n"
21438  "SYNOPSIS:\n"
21439  "\n"
21440  "plstring(n, x, y, string)\n"
21441  "\n"
21442  "ARGUMENTS:\n"
21443  "\n"
21444  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21445  "\n"
21446  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21447  " the points.\n"
21448  "\n"
21449  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21450  " the points.\n"
21451  "\n"
21452  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21453  " the glyph(s) to be plotted at each of the n points.\n"
21454  "\n"
21455  ""},
21456  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
21457  "Plot a glyph at the specified 3D points\n"
21458  "\n"
21459  "DESCRIPTION:\n"
21460  "\n"
21461  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21462  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21463  " this function similar to what is done for plline3. The glyph is\n"
21464  " specified with a PLplot user string. Note that the user string is not\n"
21465  " actually limited to one glyph so it is possible (but not normally\n"
21466  " useful) to plot more than one glyph at the specified points with this\n"
21467  " function. As with plmtex and plptex, the user string can contain FCI\n"
21468  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21469  " else PLplot escapes for Hershey or unicode text to determine the\n"
21470  " glyph.\n"
21471  "\n"
21472  " Redacted form: plstring3(x, y, z, string)\n"
21473  "\n"
21474  " This function is used in example 18.\n"
21475  "\n"
21476  "\n"
21477  "\n"
21478  "SYNOPSIS:\n"
21479  "\n"
21480  "plstring3(n, x, y, z, string)\n"
21481  "\n"
21482  "ARGUMENTS:\n"
21483  "\n"
21484  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21485  "\n"
21486  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21487  " the points.\n"
21488  "\n"
21489  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21490  " the points.\n"
21491  "\n"
21492  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21493  " the points.\n"
21494  "\n"
21495  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21496  " the glyph(s) to be plotted at each of the n points. points.\n"
21497  "\n"
21498  ""},
21499  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
21500  "Add a point to a strip chart\n"
21501  "\n"
21502  "DESCRIPTION:\n"
21503  "\n"
21504  " Add a point to a given pen of a given strip chart. There is no need\n"
21505  " for all pens to have the same number of points or to be equally\n"
21506  " sampled in the x coordinate. Allocates memory and rescales as\n"
21507  " necessary.\n"
21508  "\n"
21509  " Redacted form: plstripa(id, pen, x, y)\n"
21510  "\n"
21511  " This function is used in example 17.\n"
21512  "\n"
21513  "\n"
21514  "\n"
21515  "SYNOPSIS:\n"
21516  "\n"
21517  "plstripa(id, pen, x, y)\n"
21518  "\n"
21519  "ARGUMENTS:\n"
21520  "\n"
21521  " id (PLINT, input) : Identification number of the strip chart (set\n"
21522  " up in plstripc).\n"
21523  "\n"
21524  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21525  "\n"
21526  " x (PLFLT, input) : X coordinate of point to plot.\n"
21527  "\n"
21528  " y (PLFLT, input) : Y coordinate of point to plot.\n"
21529  "\n"
21530  ""},
21531  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
21532  "Create a 4-pen strip chart\n"
21533  "\n"
21534  "DESCRIPTION:\n"
21535  "\n"
21536  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21537  "\n"
21538  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21539  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21540  " styline, legline, labx, laby, labz)\n"
21541  "\n"
21542  "\n"
21543  " This function is used in example 17.\n"
21544  "\n"
21545  "\n"
21546  "\n"
21547  "SYNOPSIS:\n"
21548  "\n"
21549  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21550  "\n"
21551  "ARGUMENTS:\n"
21552  "\n"
21553  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21554  " number of the strip chart to use on plstripa and plstripd.\n"
21555  "\n"
21556  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21557  " the x-axis specification as in plbox.\n"
21558  "\n"
21559  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21560  " the y-axis specification as in plbox.\n"
21561  "\n"
21562  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21563  " change as data are added.\n"
21564  "\n"
21565  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21566  " change as data are added.\n"
21567  "\n"
21568  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21569  " is multiplied by the factor (1 +\n"
21570  " xjump) .\n"
21571  "\n"
21572  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21573  " change as data are added.\n"
21574  "\n"
21575  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21576  " change as data are added.\n"
21577  "\n"
21578  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21579  "\n"
21580  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21581  "\n"
21582  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21583  " true, otherwise not.\n"
21584  "\n"
21585  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21586  " otherwise slide display.\n"
21587  "\n"
21588  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21589  "\n"
21590  " collab (PLINT, input) : Legend color index (cmap0).\n"
21591  "\n"
21592  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21593  " indices for the 4 pens.\n"
21594  "\n"
21595  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21596  " indices for the 4 pens.\n"
21597  "\n"
21598  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21599  " strings containing legends for the 4 pens.\n"
21600  "\n"
21601  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21602  " the label for the x axis.\n"
21603  "\n"
21604  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21605  " the label for the y axis.\n"
21606  "\n"
21607  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21608  " the plot title.\n"
21609  "\n"
21610  ""},
21611  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
21612  "Deletes and releases memory used by a strip chart\n"
21613  "\n"
21614  "DESCRIPTION:\n"
21615  "\n"
21616  " Deletes and releases memory used by a strip chart.\n"
21617  "\n"
21618  " Redacted form: plstripd(id)\n"
21619  "\n"
21620  " This function is used in example 17.\n"
21621  "\n"
21622  "\n"
21623  "\n"
21624  "SYNOPSIS:\n"
21625  "\n"
21626  "plstripd(id)\n"
21627  "\n"
21628  "ARGUMENTS:\n"
21629  "\n"
21630  " id (PLINT, input) : Identification number of strip chart to delete.\n"
21631  "\n"
21632  ""},
21633  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
21634  "Set line style\n"
21635  "\n"
21636  "DESCRIPTION:\n"
21637  "\n"
21638  " This sets up the line style for all lines subsequently drawn. A line\n"
21639  " consists of segments in which the pen is alternately down and up. The\n"
21640  " lengths of these segments are passed in the vectors mark and space\n"
21641  " respectively. The number of mark-space pairs is specified by nms. In\n"
21642  " order to return the line style to the default continuous line, plstyl\n"
21643  " should be called with nms =0 .(see also pllsty)\n"
21644  "\n"
21645  " Redacted form: plstyl(mark, space)\n"
21646  "\n"
21647  " This function is used in examples 1, 9, and 14.\n"
21648  "\n"
21649  "\n"
21650  "\n"
21651  "SYNOPSIS:\n"
21652  "\n"
21653  "plstyl(nms, mark, space)\n"
21654  "\n"
21655  "ARGUMENTS:\n"
21656  "\n"
21657  " nms (PLINT, input) : The number of mark and space elements in a\n"
21658  " line. Thus a simple broken line can be obtained by setting nms=1\n"
21659  " . A continuous line is specified by setting nms=0 .\n"
21660  "\n"
21661  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21662  " segments during which the pen is down, measured in micrometers.\n"
21663  "\n"
21664  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21665  " the segments during which the pen is up, measured in micrometers.\n"
21666  "\n"
21667  ""},
21668  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
21669  "Set arrow style for vector plots\n"
21670  "\n"
21671  "DESCRIPTION:\n"
21672  "\n"
21673  " Set the style for the arrow used by plvect to plot vectors.\n"
21674  "\n"
21675  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21676  "\n"
21677  " This function is used in example 22.\n"
21678  "\n"
21679  "\n"
21680  "\n"
21681  "SYNOPSIS:\n"
21682  "\n"
21683  "plsvect(arrowx, arrowy, npts, fill)\n"
21684  "\n"
21685  "ARGUMENTS:\n"
21686  "\n"
21687  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21688  " the x and y points which make up the arrow. The arrow is plotted\n"
21689  " by joining these points to form a polygon. The scaling assumes\n"
21690  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21691  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21692  " will be reset to its default.\n"
21693  "\n"
21694  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21695  " arrowy.\n"
21696  "\n"
21697  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21698  " fill is false then the arrow is open.\n"
21699  "\n"
21700  ""},
21701  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
21702  "Specify viewport in absolute coordinates\n"
21703  "\n"
21704  "DESCRIPTION:\n"
21705  "\n"
21706  " Alternate routine to plvpor for setting up the viewport. This routine\n"
21707  " should be used only if the viewport is required to have a definite\n"
21708  " size in millimeters. The routine plgspa is useful for finding out the\n"
21709  " size of the current subpage.\n"
21710  "\n"
21711  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21712  "\n"
21713  " This function is used in example 10.\n"
21714  "\n"
21715  "\n"
21716  "\n"
21717  "SYNOPSIS:\n"
21718  "\n"
21719  "plsvpa(xmin, xmax, ymin, ymax)\n"
21720  "\n"
21721  "ARGUMENTS:\n"
21722  "\n"
21723  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21724  " viewport from the left-hand edge of the subpage in millimeters.\n"
21725  "\n"
21726  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21727  " viewport from the left-hand edge of the subpage in millimeters.\n"
21728  "\n"
21729  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21730  " viewport from the bottom edge of the subpage in millimeters.\n"
21731  "\n"
21732  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21733  " from the bottom edge of the subpage in millimeters.\n"
21734  "\n"
21735  ""},
21736  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
21737  "Set x axis parameters\n"
21738  "\n"
21739  "DESCRIPTION:\n"
21740  "\n"
21741  " Sets values of the digmax and digits flags for the x axis. See the\n"
21742  " PLplot documentation for more information.\n"
21743  "\n"
21744  " Redacted form: plsxax(digmax, digits)\n"
21745  "\n"
21746  " This function is used in example 31.\n"
21747  "\n"
21748  "\n"
21749  "\n"
21750  "SYNOPSIS:\n"
21751  "\n"
21752  "plsxax(digmax, digits)\n"
21753  "\n"
21754  "ARGUMENTS:\n"
21755  "\n"
21756  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21757  " digits for the x axis. If nonzero, the printed label will be\n"
21758  " switched to a floating-point representation when the number of\n"
21759  " digits exceeds digmax.\n"
21760  "\n"
21761  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21762  " its value here has no effect since it is set only by plbox or\n"
21763  " plbox3. However, the user may obtain its value after a call to\n"
21764  " either of these functions by calling plgxax.\n"
21765  "\n"
21766  ""},
21767  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
21768  "Set y axis parameters\n"
21769  "\n"
21770  "DESCRIPTION:\n"
21771  "\n"
21772  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21773  " the description of plsxax for more detail.\n"
21774  "\n"
21775  " Redacted form: plsyax(digmax, digits)\n"
21776  "\n"
21777  " This function is used in examples 1, 14, and 31.\n"
21778  "\n"
21779  "\n"
21780  "\n"
21781  "SYNOPSIS:\n"
21782  "\n"
21783  "plsyax(digmax, digits)\n"
21784  "\n"
21785  "ARGUMENTS:\n"
21786  "\n"
21787  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21788  " digits for the y axis. If nonzero, the printed label will be\n"
21789  " switched to a floating-point representation when the number of\n"
21790  " digits exceeds digmax.\n"
21791  "\n"
21792  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21793  " its value here has no effect since it is set only by plbox or\n"
21794  " plbox3. However, the user may obtain its value after a call to\n"
21795  " either of these functions by calling plgyax.\n"
21796  "\n"
21797  ""},
21798  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
21799  "Plot a glyph at the specified points\n"
21800  "\n"
21801  "DESCRIPTION:\n"
21802  "\n"
21803  " Plot a glyph at the specified points. (This function is largely\n"
21804  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21805  "\n"
21806  " Redacted form: plsym(x, y, code)\n"
21807  "\n"
21808  " This function is used in example 7.\n"
21809  "\n"
21810  "\n"
21811  "\n"
21812  "SYNOPSIS:\n"
21813  "\n"
21814  "plsym(n, x, y, code)\n"
21815  "\n"
21816  "ARGUMENTS:\n"
21817  "\n"
21818  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21819  "\n"
21820  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21821  " the points.\n"
21822  "\n"
21823  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21824  " the points.\n"
21825  "\n"
21826  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21827  " to be plotted at each of the n points.\n"
21828  "\n"
21829  ""},
21830  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21831  "Set z axis parameters\n"
21832  "\n"
21833  "DESCRIPTION:\n"
21834  "\n"
21835  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21836  " the description of plsxax for more detail.\n"
21837  "\n"
21838  " Redacted form: plszax(digmax, digits)\n"
21839  "\n"
21840  " This function is used in example 31.\n"
21841  "\n"
21842  "\n"
21843  "\n"
21844  "SYNOPSIS:\n"
21845  "\n"
21846  "plszax(digmax, digits)\n"
21847  "\n"
21848  "ARGUMENTS:\n"
21849  "\n"
21850  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21851  " digits for the z axis. If nonzero, the printed label will be\n"
21852  " switched to a floating-point representation when the number of\n"
21853  " digits exceeds digmax.\n"
21854  "\n"
21855  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21856  " its value here has no effect since it is set only by plbox or\n"
21857  " plbox3. However, the user may obtain its value after a call to\n"
21858  " either of these functions by calling plgzax.\n"
21859  "\n"
21860  ""},
21861  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21862  "Switch to text screen\n"
21863  "\n"
21864  "DESCRIPTION:\n"
21865  "\n"
21866  " Sets an interactive device to text mode, used in conjunction with\n"
21867  " plgra to allow graphics and text to be interspersed. On a device\n"
21868  " which supports separate text and graphics windows, this command causes\n"
21869  " control to be switched to the text window. This can be useful for\n"
21870  " printing diagnostic messages or getting user input, which would\n"
21871  " otherwise interfere with the plots. The program must switch back to\n"
21872  " the graphics window before issuing plot commands, as the text (or\n"
21873  " console) device will probably become quite confused otherwise. If\n"
21874  " already in text mode, this command is ignored. It is also ignored on\n"
21875  " devices which only support a single window or use a different method\n"
21876  " for shifting focus (see also plgra).\n"
21877  "\n"
21878  " Redacted form: pltext()\n"
21879  "\n"
21880  " This function is used in example 1.\n"
21881  "\n"
21882  "\n"
21883  "\n"
21884  "SYNOPSIS:\n"
21885  "\n"
21886  "pltext()\n"
21887  "\n"
21888  ""},
21889  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21890  "Set format for date / time labels\n"
21891  "\n"
21892  "DESCRIPTION:\n"
21893  "\n"
21894  " Sets the format for date / time labels. To enable date / time format\n"
21895  " labels see the options to plbox, plbox3, and plenv.\n"
21896  "\n"
21897  " Redacted form: pltimefmt(fmt)\n"
21898  "\n"
21899  " This function is used in example 29.\n"
21900  "\n"
21901  "\n"
21902  "\n"
21903  "SYNOPSIS:\n"
21904  "\n"
21905  "pltimefmt(fmt)\n"
21906  "\n"
21907  "ARGUMENTS:\n"
21908  "\n"
21909  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21910  " interpreted similarly to the format specifier of typical system\n"
21911  " strftime routines except that PLplot ignores locale and also\n"
21912  " supplies some useful extensions in the context of plotting. All\n"
21913  " text in the string is printed as-is other than conversion\n"
21914  " specifications which take the form of a '%' character followed by\n"
21915  " further conversion specification character. The conversion\n"
21916  " specifications which are similar to those provided by system\n"
21917  " strftime routines are the following: %a: The abbreviated (English)\n"
21918  " weekday name.\n"
21919  " %A: The full (English) weekday name.\n"
21920  " %b: The abbreviated (English) month name.\n"
21921  " %B: The full (English) month name.\n"
21922  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21923  " %C: The century number (year/100) as a 2-digit integer.\n"
21924  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21925  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21926  " %e: Like %d, but a leading zero is replaced by a space.\n"
21927  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21928  " %h: Equivalent to %b.\n"
21929  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21930  " 00 to 23).\n"
21931  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21932  " 01 to 12).\n"
21933  " %j: The day of the year as a decimal number (range 001 to\n"
21934  " 366).\n"
21935  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21936  " 23); single digits are preceded by a blank. (See also %H.)\n"
21937  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21938  " 12); single digits are preceded by a blank. (See also %I.)\n"
21939  " %m: The month as a decimal number (range 01 to 12).\n"
21940  " %M: The minute as a decimal number (range 00 to 59).\n"
21941  " %n: A newline character.\n"
21942  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21943  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21944  " %r: Equivalent to %I:%M:%S %p.\n"
21945  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21946  " including the seconds, see %T below.\n"
21947  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21948  " +0000 (UTC).\n"
21949  " %S: The second as a decimal number (range 00 to 60). (The\n"
21950  " range is up to 60 to allow for occasional leap seconds.)\n"
21951  " %t: A tab character.\n"
21952  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21953  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21954  " being 1. See also %w.\n"
21955  " %U: The week number of the current year as a decimal number,\n"
21956  " range 00 to 53, starting with the first Sunday as the first\n"
21957  " day of week 01. See also %V and %W.\n"
21958  " %v: Equivalent to %e-%b-%Y.\n"
21959  " %V: The ISO 8601 week number of the current year as a decimal\n"
21960  " number, range 01 to 53, where week 1 is the first week that\n"
21961  " has at least 4 days in the new year. See also %U and %W.\n"
21962  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21963  " being 0. See also %u.\n"
21964  " %W: The week number of the current year as a decimal number,\n"
21965  " range 00 to 53, starting with the first Monday as the first\n"
21966  " day of week 01.\n"
21967  " %x: Equivalent to %a %b %d %Y.\n"
21968  " %X: Equivalent to %T.\n"
21969  " %y: The year as a decimal number without a century (range 00\n"
21970  " to 99).\n"
21971  " %Y: The year as a decimal number including a century.\n"
21972  " %z: The UTC time-zone string = \"+0000\".\n"
21973  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21974  " %+: The UTC date and time in default format of the Unix date\n"
21975  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21976  " %%: A literal \"%\" character.\n"
21977  " The conversion specifications which are extensions to those normally\n"
21978  " provided by system strftime routines are the following: %(0-9):\n"
21979  " The fractional part of the seconds field (including leading\n"
21980  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21981  " seconds to millisecond accuracy (00.000).\n"
21982  " %.: The fractional part of the seconds field (including\n"
21983  " leading decimal point) to the maximum available accuracy. Thus\n"
21984  " %S%. would give seconds with fractional part up to 9 decimal\n"
21985  " places if available.\n"
21986  "\n"
21987  ""},
21988  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
21989  "Specify viewport using aspect ratio only\n"
21990  "\n"
21991  "DESCRIPTION:\n"
21992  "\n"
21993  " Selects the largest viewport with the given aspect ratio within the\n"
21994  " subpage that leaves a standard margin (left-hand margin of eight\n"
21995  " character heights, and a margin around the other three sides of five\n"
21996  " character heights).\n"
21997  "\n"
21998  " Redacted form: plvasp(aspect)\n"
21999  "\n"
22000  " This function is used in example 13.\n"
22001  "\n"
22002  "\n"
22003  "\n"
22004  "SYNOPSIS:\n"
22005  "\n"
22006  "plvasp(aspect)\n"
22007  "\n"
22008  "ARGUMENTS:\n"
22009  "\n"
22010  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22011  " axis of resulting viewport.\n"
22012  "\n"
22013  ""},
22014  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
22015  "Vector plot\n"
22016  "\n"
22017  "DESCRIPTION:\n"
22018  "\n"
22019  " Draws a plot of vector data contained in the matrices (\n"
22020  " u[\n"
22021  " nx][\n"
22022  " ny],\n"
22023  " v[\n"
22024  " nx][\n"
22025  " ny]) . The scaling factor for the vectors is given by scale. A\n"
22026  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22027  " additional data required by the transformation routine to map indices\n"
22028  " within the matrices to the world coordinates. The style of the vector\n"
22029  " arrow may be set using plsvect.\n"
22030  "\n"
22031  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22032  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22033  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22034  " with either one or two dimensions.\n"
22035  "\n"
22036  " This function is used in example 22.\n"
22037  "\n"
22038  "\n"
22039  "\n"
22040  "SYNOPSIS:\n"
22041  "\n"
22042  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22043  "\n"
22044  "ARGUMENTS:\n"
22045  "\n"
22046  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22047  " and y components of the vector data to be plotted.\n"
22048  "\n"
22049  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22050  "\n"
22051  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22052  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22053  " automatically calculated for the data. If scale < 0 then the\n"
22054  " scaling factor is automatically calculated for the data and then\n"
22055  " multiplied by -\n"
22056  " scale. If scale > 0 then the scaling factor is set to scale.\n"
22057  "\n"
22058  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22059  " defines the transformation between the zero-based indices of the\n"
22060  " matrices u and v and world coordinates.For the C case,\n"
22061  " transformation functions are provided in the PLplot library: pltr0\n"
22062  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22063  " mappings respectively defined by vectors and matrices. In\n"
22064  " addition, C callback routines for the transformation can be\n"
22065  " supplied by the user such as the mypltr function in\n"
22066  " examples/c/x09c.c which provides a general linear transformation\n"
22067  " between index coordinates and world coordinates.For languages\n"
22068  " other than C you should consult the PLplot documentation for the\n"
22069  " details concerning how PLTRANSFORM_callback arguments are\n"
22070  " interfaced. However, in general, a particular pattern of\n"
22071  " callback-associated arguments such as a tr vector with 6 elements;\n"
22072  " xg and yg vectors; or xg and yg matrices are respectively\n"
22073  " interfaced to a linear-transformation routine similar to the above\n"
22074  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22075  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22076  " support native language callbacks for handling index to\n"
22077  " world-coordinate transformations. Examples of these various\n"
22078  " approaches are given in examples/<language>x09*,\n"
22079  " examples/<language>x16*, examples/<language>x20*,\n"
22080  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22081  " supported languages.\n"
22082  "\n"
22083  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22084  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22085  " that is externally supplied.\n"
22086  "\n"
22087  ""},
22088  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
22089  "Specify viewport using coordinates and aspect ratio\n"
22090  "\n"
22091  "DESCRIPTION:\n"
22092  "\n"
22093  " Device-independent routine for setting up the viewport. The viewport\n"
22094  " is chosen to be the largest with the given aspect ratio that fits\n"
22095  " within the specified region (in terms of normalized subpage\n"
22096  " coordinates). This routine is functionally equivalent to plvpor when\n"
22097  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22098  " routine reserves no extra space at the edges for labels.\n"
22099  "\n"
22100  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22101  "\n"
22102  " This function is used in example 9.\n"
22103  "\n"
22104  "\n"
22105  "\n"
22106  "SYNOPSIS:\n"
22107  "\n"
22108  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22109  "\n"
22110  "ARGUMENTS:\n"
22111  "\n"
22112  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22113  " left-hand edge of the viewport.\n"
22114  "\n"
22115  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22116  " right-hand edge of the viewport.\n"
22117  "\n"
22118  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22119  " bottom edge of the viewport.\n"
22120  "\n"
22121  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22122  " edge of the viewport.\n"
22123  "\n"
22124  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22125  " axis.\n"
22126  "\n"
22127  ""},
22128  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
22129  "Specify viewport using normalized subpage coordinates\n"
22130  "\n"
22131  "DESCRIPTION:\n"
22132  "\n"
22133  " Device-independent routine for setting up the viewport. This defines\n"
22134  " the viewport in terms of normalized subpage coordinates which run from\n"
22135  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22136  " current subpage. Use the alternate routine plsvpa in order to create\n"
22137  " a viewport of a definite size.\n"
22138  "\n"
22139  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22140  "\n"
22141  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22142  " 24, 26, 27, and 31.\n"
22143  "\n"
22144  "\n"
22145  "\n"
22146  "SYNOPSIS:\n"
22147  "\n"
22148  "plvpor(xmin, xmax, ymin, ymax)\n"
22149  "\n"
22150  "ARGUMENTS:\n"
22151  "\n"
22152  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22153  " left-hand edge of the viewport.\n"
22154  "\n"
22155  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22156  " right-hand edge of the viewport.\n"
22157  "\n"
22158  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22159  " bottom edge of the viewport.\n"
22160  "\n"
22161  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22162  " edge of the viewport.\n"
22163  "\n"
22164  ""},
22165  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
22166  "Select standard viewport\n"
22167  "\n"
22168  "DESCRIPTION:\n"
22169  "\n"
22170  " Selects the largest viewport within the subpage that leaves a standard\n"
22171  " margin (left-hand margin of eight character heights, and a margin\n"
22172  " around the other three sides of five character heights).\n"
22173  "\n"
22174  " Redacted form: plvsta()\n"
22175  "\n"
22176  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22177  "\n"
22178  "\n"
22179  "\n"
22180  "SYNOPSIS:\n"
22181  "\n"
22182  "plvsta()\n"
22183  "\n"
22184  ""},
22185  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
22186  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22187  "\n"
22188  "DESCRIPTION:\n"
22189  "\n"
22190  " Configure the transformations required for projecting a 3D surface on\n"
22191  " an existing 2D window. Those transformations (see the PLplot\n"
22192  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22193  " surface which has its limits expressed in 3D world coordinates and\n"
22194  " also normalized 3D coordinates (used for interpreting the altitude and\n"
22195  " azimuth of the viewing angle). The transformations consist of the\n"
22196  " linear transform from 3D world coordinates to normalized 3D\n"
22197  " coordinates, and the 3D rotation of normalized coordinates required to\n"
22198  " align the pole of the new 3D coordinate system with the viewing\n"
22199  " direction specified by altitude and azimuth so that x and y of the\n"
22200  " surface elements in that transformed coordinate system are the\n"
22201  " projection of the 3D surface with given viewing direction on the 2D\n"
22202  " window.\n"
22203  "\n"
22204  " The enclosing rectangular cuboid for the surface plot is defined by\n"
22205  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22206  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22207  " sizes of basex by basey by height so that xmin maps to -\n"
22208  " basex/2, xmax maps to basex/2, ymin maps to -\n"
22209  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22210  " The resulting rectangular cuboid in normalized coordinates is then\n"
22211  " viewed by an observer at altitude alt and azimuth az. This routine\n"
22212  " must be called before plbox3 or any of the 3D surface plotting\n"
22213  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22214  " plsurf3dl or plfill3.\n"
22215  "\n"
22216  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22217  " zmin, zmax, alt, az)\n"
22218  "\n"
22219  " This function is examples 8, 11, 18, and 21.\n"
22220  "\n"
22221  "\n"
22222  "\n"
22223  "SYNOPSIS:\n"
22224  "\n"
22225  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22226  "\n"
22227  "ARGUMENTS:\n"
22228  "\n"
22229  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22230  " rectangular cuboid.\n"
22231  "\n"
22232  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22233  " rectangular cuboid.\n"
22234  "\n"
22235  " height (PLFLT, input) : The normalized z coordinate size of the\n"
22236  " rectangular cuboid.\n"
22237  "\n"
22238  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22239  " rectangular cuboid.\n"
22240  "\n"
22241  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22242  " rectangular cuboid.\n"
22243  "\n"
22244  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22245  " rectangular cuboid.\n"
22246  "\n"
22247  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22248  " rectangular cuboid.\n"
22249  "\n"
22250  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22251  " rectangular cuboid.\n"
22252  "\n"
22253  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22254  " rectangular cuboid.\n"
22255  "\n"
22256  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22257  " plane of the rectangular cuboid in normalized coordinates.\n"
22258  "\n"
22259  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22260  " rectangular cuboid in normalized coordinates. When az=0, the\n"
22261  " observer is looking face onto the zx plane of the rectangular\n"
22262  " cuboid in normalized coordinates, and as az is increased, the\n"
22263  " observer moves clockwise around that cuboid when viewed from above\n"
22264  " the xy plane.\n"
22265  "\n"
22266  ""},
22267  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
22268  "Set pen width\n"
22269  "\n"
22270  "DESCRIPTION:\n"
22271  "\n"
22272  " Sets the pen width.\n"
22273  "\n"
22274  " Redacted form: plwidth(width)\n"
22275  "\n"
22276  " This function is used in examples 1 and 2.\n"
22277  "\n"
22278  "\n"
22279  "\n"
22280  "SYNOPSIS:\n"
22281  "\n"
22282  "plwidth(width)\n"
22283  "\n"
22284  "ARGUMENTS:\n"
22285  "\n"
22286  " width (PLFLT, input) : The desired pen width. If width is negative\n"
22287  " or the same as the previous value no action is taken. width = 0.\n"
22288  " should be interpreted as as the minimum valid pen width for the\n"
22289  " device. The interpretation of positive width values is also\n"
22290  " device dependent.\n"
22291  "\n"
22292  ""},
22293  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
22294  "Specify window\n"
22295  "\n"
22296  "DESCRIPTION:\n"
22297  "\n"
22298  " Specify the window, i.e., the world coordinates of the edges of the\n"
22299  " viewport.\n"
22300  "\n"
22301  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22302  "\n"
22303  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22304  " 29, and 31.\n"
22305  "\n"
22306  "\n"
22307  "\n"
22308  "SYNOPSIS:\n"
22309  "\n"
22310  "plwind(xmin, xmax, ymin, ymax)\n"
22311  "\n"
22312  "ARGUMENTS:\n"
22313  "\n"
22314  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22315  " of the viewport.\n"
22316  "\n"
22317  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22318  " of the viewport.\n"
22319  "\n"
22320  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22321  " the viewport.\n"
22322  "\n"
22323  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22324  " viewport.\n"
22325  "\n"
22326  ""},
22327  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
22328  "Enter or leave xor mode\n"
22329  "\n"
22330  "DESCRIPTION:\n"
22331  "\n"
22332  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22333  " those drivers (e.g., the xwin driver) that support it. Enables\n"
22334  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22335  " is not capable of xor operation it returns a status of false.\n"
22336  "\n"
22337  " Redacted form: plxormod(mode, status)\n"
22338  "\n"
22339  " This function is used in examples 1 and 20.\n"
22340  "\n"
22341  "\n"
22342  "\n"
22343  "SYNOPSIS:\n"
22344  "\n"
22345  "plxormod(mode, status)\n"
22346  "\n"
22347  "ARGUMENTS:\n"
22348  "\n"
22349  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22350  " is false means leave xor mode.\n"
22351  "\n"
22352  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22353  " modestatus of true (false) means driver is capable (incapable) of\n"
22354  " xor mode.\n"
22355  "\n"
22356  ""},
22357  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
22358  "Plot continental outline or shapefile data in world coordinates\n"
22359  "\n"
22360  "DESCRIPTION:\n"
22361  "\n"
22362  " Plots continental outlines or shapefile data in world coordinates. A\n"
22363  " demonstration of how to use this function to create different\n"
22364  " projections can be found in examples/c/x19c. PLplot is provided with\n"
22365  " basic coastal outlines and USA state borders. To use the map\n"
22366  " functionality PLplot must be compiled with the shapelib library.\n"
22367  " Shapefiles have become a popular standard for geographical data and\n"
22368  " data in this format can be easily found from a number of online\n"
22369  " sources. Shapefile data is actually provided as three or more files\n"
22370  " with the same filename, but different extensions. The .shp and .shx\n"
22371  " files are required for plotting Shapefile data with PLplot.\n"
22372  "\n"
22373  " PLplot currently supports the point, multipoint, polyline and polygon\n"
22374  " objects within shapefiles. However holes in polygons are not\n"
22375  " supported. When plmap is used the type of object is derived from the\n"
22376  " shapefile, if you wish to override the type then use one of the other\n"
22377  " plmap variants. The built in maps have line data only.\n"
22378  "\n"
22379  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22380  "\n"
22381  " This function is used in example 19.\n"
22382  "\n"
22383  "\n"
22384  "\n"
22385  "SYNOPSIS:\n"
22386  "\n"
22387  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22388  "\n"
22389  "ARGUMENTS:\n"
22390  "\n"
22391  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22392  " transform the original map data coordinates to a new coordinate\n"
22393  " system. The PLplot-supplied map data is provided as latitudes and\n"
22394  " longitudes; other Shapefile data may be provided in other\n"
22395  " coordinate systems as can be found in their .prj plain text files.\n"
22396  " For example, by using this transform we can change from a\n"
22397  " longitude, latitude coordinate to a polar stereographic\n"
22398  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22399  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22400  " corresponding y coordinates (latitudes for the PLplot supplied\n"
22401  " data). After the call to mapform(), x[] and y[] should be\n"
22402  " replaced by the corresponding plot coordinates. If no transform is\n"
22403  " desired, mapform can be replaced by NULL.\n"
22404  "\n"
22405  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22406  " the type of map plotted. This is either one of the PLplot built-in\n"
22407  " maps or the file name of a set of Shapefile files without the file\n"
22408  " extensions. For the PLplot built-in maps the possible values are:\n"
22409  " \"globe\" -- continental outlines\n"
22410  " \"usa\" -- USA and state boundaries\n"
22411  " \"cglobe\" -- continental outlines and countries\n"
22412  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22413  "\n"
22414  "\n"
22415  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22416  " drawn. The units must match the shapefile (built in maps are\n"
22417  " degrees lat/lon). Objects in the file which do not encroach on the\n"
22418  " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22419  " note this is simply an optimisation, not a clipping so for objects\n"
22420  " with some points inside the box and some points outside the box\n"
22421  " all the points will be rendered. These parameters also define\n"
22422  " latitude and longitude wrapping for shapefiles using these units.\n"
22423  " Longitude points will be wrapped by integer multiples of 360\n"
22424  " degrees to place them in the box. This allows the same data to be\n"
22425  " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22426  " you plot from -180-540 you will get two cycles of data drawn. The\n"
22427  " value of minx must be less than the value of maxx. Passing in a\n"
22428  " nan, max/-max floating point number or +/-infinity will case the\n"
22429  " bounding box from the shapefile to be used.\n"
22430  "\n"
22431  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22432  " drawn - see minx.\n"
22433  "\n"
22434  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22435  " drawn - see minx.\n"
22436  "\n"
22437  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22438  " drawn - see minx.\n"
22439  "\n"
22440  ""},
22441  { (char *)"plmapline", _wrap_plmapline, METH_VARARGS, (char *)"\n"
22442  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22443  "\n"
22444  "DESCRIPTION:\n"
22445  "\n"
22446  " Plot all or a subset of Shapefile data using lines in world\n"
22447  " coordinates. Our 19th standard example demonstrates how to use this\n"
22448  " function. This function plots data from a Shapefile using lines as in\n"
22449  " plmap, however it also has the option of also only drawing specified\n"
22450  " elements from the Shapefile. The vector of indices of the required\n"
22451  " elements are passed as a function argument. The Shapefile data should\n"
22452  " include a metadata file (extension.dbf) listing all items within the\n"
22453  " Shapefile. This file can be opened by most popular spreadsheet\n"
22454  " programs and can be used to decide which indices to pass to this\n"
22455  " function.\n"
22456  "\n"
22457  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22458  " plotentries)\n"
22459  "\n"
22460  " This function is used in example 19.\n"
22461  "\n"
22462  "\n"
22463  "\n"
22464  "SYNOPSIS:\n"
22465  "\n"
22466  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22467  "\n"
22468  "ARGUMENTS:\n"
22469  "\n"
22470  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22471  " transform the coordinates given in the shapefile into a plot\n"
22472  " coordinate system. By using this transform, we can change from a\n"
22473  " longitude, latitude coordinate to a polar stereographic project,\n"
22474  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22475  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22476  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22477  " plot coordinates. If no transform is desired, mapform can be\n"
22478  " replaced by NULL.\n"
22479  "\n"
22480  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22481  " the file name of a set of Shapefile files without the file\n"
22482  " extension.\n"
22483  "\n"
22484  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22485  " be in the same units as used by the Shapefile. You could use a\n"
22486  " very large negative number to plot everything, but you can improve\n"
22487  " performance by limiting the area drawn. The units must match those\n"
22488  " of the Shapefile projection, which may be for example longitude or\n"
22489  " distance. The value of minx must be less than the value of maxx.\n"
22490  "\n"
22491  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22492  " use a very large number to plot everything, but you can improve\n"
22493  " performance by limiting the area drawn.\n"
22494  "\n"
22495  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22496  " be in the same units as used by the Shapefile. You could use a\n"
22497  " very large negative number to plot everything, but you can improve\n"
22498  " performance by limiting the area drawn. The units must match those\n"
22499  " of the Shapefile projection, which may be for example latitude or\n"
22500  " distance. The value of miny must be less than the value of maxy.\n"
22501  "\n"
22502  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22503  " use a very large number to plot everything, but you can improve\n"
22504  " performance by limiting the area drawn.\n"
22505  "\n"
22506  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22507  " zero-based indices of the Shapefile elements which will be drawn.\n"
22508  " Setting\n"
22509  " plotentries to NULL will plot all elements of the Shapefile.\n"
22510  "\n"
22511  " nplotentries (PLINT, input) : The number of items in\n"
22512  " plotentries. Ignored if\n"
22513  " plotentries is NULL.\n"
22514  "\n"
22515  ""},
22516  { (char *)"plmapstring", _wrap_plmapstring, METH_VARARGS, (char *)"\n"
22517  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22518  "\n"
22519  "DESCRIPTION:\n"
22520  "\n"
22521  " As per plmapline, however the items are plotted as strings or points\n"
22522  " in the same way as plstring.\n"
22523  "\n"
22524  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22525  " maxy, plotentries)\n"
22526  "\n"
22527  " This function is not used in any examples.\n"
22528  "\n"
22529  "\n"
22530  "\n"
22531  "SYNOPSIS:\n"
22532  "\n"
22533  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22534  "\n"
22535  "ARGUMENTS:\n"
22536  "\n"
22537  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22538  " transform the coordinates given in the shapefile into a plot\n"
22539  " coordinate system. By using this transform, we can change from a\n"
22540  " longitude, latitude coordinate to a polar stereographic project,\n"
22541  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22542  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22543  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22544  " plot coordinates. If no transform is desired, mapform can be\n"
22545  " replaced by NULL.\n"
22546  "\n"
22547  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22548  " the file name of a set of Shapefile files without the file\n"
22549  " extension.\n"
22550  "\n"
22551  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22552  " drawn.\n"
22553  "\n"
22554  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22555  " be in the same units as used by the Shapefile. You could use a\n"
22556  " very large negative number to plot everything, but you can improve\n"
22557  " performance by limiting the area drawn. The units must match those\n"
22558  " of the Shapefile projection, which may be for example longitude or\n"
22559  " distance. The value of minx must be less than the value of maxx.\n"
22560  "\n"
22561  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22562  " use a very large number to plot everything, but you can improve\n"
22563  " performance by limiting the area drawn.\n"
22564  "\n"
22565  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22566  " be in the same units as used by the Shapefile. You could use a\n"
22567  " very large negative number to plot everything, but you can improve\n"
22568  " performance by limiting the area drawn. The units must match those\n"
22569  " of the Shapefile projection, which may be for example latitude or\n"
22570  " distance. The value of miny must be less than the value of maxy.\n"
22571  "\n"
22572  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22573  " use a very large number to plot everything, but you can improve\n"
22574  " performance by limiting the area drawn.\n"
22575  "\n"
22576  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22577  " zero-based indices of the Shapefile elements which will be drawn.\n"
22578  " Setting\n"
22579  " plotentries to NULL will plot all elements of the Shapefile.\n"
22580  "\n"
22581  " nplotentries (PLINT, input) : The number of items in\n"
22582  " plotentries. Ignored if\n"
22583  " plotentries is NULL.\n"
22584  "\n"
22585  ""},
22586  { (char *)"plmaptex", _wrap_plmaptex, METH_VARARGS, (char *)"\n"
22587  "Draw text at points defined by Shapefile data in world coordinates\n"
22588  "\n"
22589  "DESCRIPTION:\n"
22590  "\n"
22591  " As per plmapline, however the items are plotted as text in the same\n"
22592  " way as plptex.\n"
22593  "\n"
22594  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22595  " miny, maxy, plotentry)\n"
22596  "\n"
22597  " This function is used in example 19.\n"
22598  "\n"
22599  "\n"
22600  "\n"
22601  "SYNOPSIS:\n"
22602  "\n"
22603  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22604  "\n"
22605  "ARGUMENTS:\n"
22606  "\n"
22607  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22608  " transform the coordinates given in the shapefile into a plot\n"
22609  " coordinate system. By using this transform, we can change from a\n"
22610  " longitude, latitude coordinate to a polar stereographic project,\n"
22611  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22612  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22613  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22614  " plot coordinates. If no transform is desired, mapform can be\n"
22615  " replaced by NULL.\n"
22616  "\n"
22617  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22618  " the file name of a set of Shapefile files without the file\n"
22619  " extension.\n"
22620  "\n"
22621  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22622  " dy/dx.\n"
22623  "\n"
22624  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22625  " dy/dx.\n"
22626  "\n"
22627  " just (PLFLT, input) : Set the justification of the text. The value\n"
22628  " given will be the fraction of the distance along the string that\n"
22629  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22630  " centralized text and 1.0 gives right aligned text.\n"
22631  "\n"
22632  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22633  "\n"
22634  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22635  " be in the same units as used by the Shapefile. You could use a\n"
22636  " very large negative number to plot everything, but you can improve\n"
22637  " performance by limiting the area drawn. The units must match those\n"
22638  " of the Shapefile projection, which may be for example longitude or\n"
22639  " distance. The value of minx must be less than the value of maxx.\n"
22640  "\n"
22641  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22642  " use a very large number to plot everything, but you can improve\n"
22643  " performance by limiting the area drawn.\n"
22644  "\n"
22645  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22646  " be in the same units as used by the Shapefile. You could use a\n"
22647  " very large negative number to plot everything, but you can improve\n"
22648  " performance by limiting the area drawn. The units must match those\n"
22649  " of the Shapefile projection, which may be for example latitude or\n"
22650  " distance. The value of miny must be less than the value of maxy.\n"
22651  "\n"
22652  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22653  " use a very large number to plot everything, but you can improve\n"
22654  " performance by limiting the area drawn.\n"
22655  "\n"
22656  " plotentry (PLINT, input) : An integer indicating which text string\n"
22657  " of the Shapefile (zero indexed) will be drawn.\n"
22658  "\n"
22659  ""},
22660  { (char *)"plmapfill", _wrap_plmapfill, METH_VARARGS, (char *)"\n"
22661  "Plot all or a subset of Shapefile data, filling the polygons\n"
22662  "\n"
22663  "DESCRIPTION:\n"
22664  "\n"
22665  " As per plmapline, however the items are filled in the same way as\n"
22666  " plfill.\n"
22667  "\n"
22668  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22669  " plotentries)\n"
22670  "\n"
22671  " This function is used in example 19.\n"
22672  "\n"
22673  "\n"
22674  "\n"
22675  "SYNOPSIS:\n"
22676  "\n"
22677  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22678  "\n"
22679  "ARGUMENTS:\n"
22680  "\n"
22681  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22682  " transform the coordinates given in the shapefile into a plot\n"
22683  " coordinate system. By using this transform, we can change from a\n"
22684  " longitude, latitude coordinate to a polar stereographic project,\n"
22685  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22686  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22687  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22688  " plot coordinates. If no transform is desired, mapform can be\n"
22689  " replaced by NULL.\n"
22690  "\n"
22691  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22692  " the file name of a set of Shapefile files without the file\n"
22693  " extension.\n"
22694  "\n"
22695  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22696  " be in the same units as used by the Shapefile. You could use a\n"
22697  " very large negative number to plot everything, but you can improve\n"
22698  " performance by limiting the area drawn. The units must match those\n"
22699  " of the Shapefile projection, which may be for example longitude or\n"
22700  " distance. The value of minx must be less than the value of maxx.\n"
22701  "\n"
22702  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22703  " use a very large number to plot everything, but you can improve\n"
22704  " performance by limiting the area drawn.\n"
22705  "\n"
22706  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22707  " be in the same units as used by the Shapefile. You could use a\n"
22708  " very large negative number to plot everything, but you can improve\n"
22709  " performance by limiting the area drawn. The units must match those\n"
22710  " of the Shapefile projection, which may be for example latitude or\n"
22711  " distance. The value of miny must be less than the value of maxy.\n"
22712  "\n"
22713  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22714  " use a very large number to plot everything, but you can improve\n"
22715  " performance by limiting the area drawn.\n"
22716  "\n"
22717  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22718  " zero-based indices of the Shapefile elements which will be drawn.\n"
22719  " Setting\n"
22720  " plotentries to NULL will plot all elements of the Shapefile.\n"
22721  "\n"
22722  " nplotentries (PLINT, input) : The number of items in\n"
22723  " plotentries. Ignored if\n"
22724  " plotentries is NULL.\n"
22725  "\n"
22726  ""},
22727  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
22728  "Plot latitude and longitude lines\n"
22729  "\n"
22730  "DESCRIPTION:\n"
22731  "\n"
22732  " Displays latitude and longitude on the current plot. The lines are\n"
22733  " plotted in the current color and line style.\n"
22734  "\n"
22735  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22736  " minlat, maxlat)\n"
22737  "\n"
22738  " This function is used in example 19.\n"
22739  "\n"
22740  "\n"
22741  "\n"
22742  "SYNOPSIS:\n"
22743  "\n"
22744  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22745  "\n"
22746  "ARGUMENTS:\n"
22747  "\n"
22748  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22749  " transform the coordinate longitudes and latitudes to a plot\n"
22750  " coordinate system. By using this transform, we can change from a\n"
22751  " longitude, latitude coordinate to a polar stereographic project,\n"
22752  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22753  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22754  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22755  " plot coordinates. If no transform is desired, mapform can be\n"
22756  " replaced by NULL.\n"
22757  "\n"
22758  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22759  " longitude lines are to be plotted.\n"
22760  "\n"
22761  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22762  " lines are to be plotted.\n"
22763  "\n"
22764  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22765  " side of the plot. The value of minlong must be less than the value\n"
22766  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22767  " equal to 360.\n"
22768  "\n"
22769  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22770  " side of the plot.\n"
22771  "\n"
22772  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22773  " background. One can always use -90.0 as the boundary outside the\n"
22774  " plot window will be automatically eliminated. However, the\n"
22775  " program will be faster if one can reduce the size of the\n"
22776  " background plotted.\n"
22777  "\n"
22778  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22779  " background. One can always use 90.0 as the boundary outside the\n"
22780  " plot window will be automatically eliminated.\n"
22781  "\n"
22782  ""},
22783  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
22784  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22785  "\n"
22786  "DESCRIPTION:\n"
22787  "\n"
22788  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22789  " automatically adjusted to use the maximum and minimum values in idata\n"
22790  " as valuemin and valuemax in a call to plimagefr.\n"
22791  "\n"
22792  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22793  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22794  "\n"
22795  "\n"
22796  " This function is used in example 20.\n"
22797  "\n"
22798  "\n"
22799  "\n"
22800  "SYNOPSIS:\n"
22801  "\n"
22802  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22803  "\n"
22804  "ARGUMENTS:\n"
22805  "\n"
22806  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22807  " to plot. Should have dimensions of\n"
22808  " nx by\n"
22809  " ny.\n"
22810  "\n"
22811  " nx, ny (PLINT, input) : Dimensions of idata\n"
22812  "\n"
22813  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22814  " are linearly transformed to these world coordinate ranges such\n"
22815  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22816  " - 1] corresponds to (xmax, ymax).\n"
22817  "\n"
22818  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22819  " (inclusive) will be plotted.\n"
22820  "\n"
22821  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22822  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22823  " Dymin) to (Dxmax, Dymax).\n"
22824  "\n"
22825  ""},
22826  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
22827  "Plot a 2D matrix using cmap1\n"
22828  "\n"
22829  "DESCRIPTION:\n"
22830  "\n"
22831  " Plot a 2D matrix using cmap1.\n"
22832  "\n"
22833  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22834  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22835  "\n"
22836  "\n"
22837  " This function is used in example 20.\n"
22838  "\n"
22839  "\n"
22840  "\n"
22841  "SYNOPSIS:\n"
22842  "\n"
22843  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22844  "\n"
22845  "ARGUMENTS:\n"
22846  "\n"
22847  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22848  " plot. Should have dimensions of\n"
22849  " nx by\n"
22850  " ny.\n"
22851  "\n"
22852  " nx, ny (PLINT, input) : Dimensions of idata\n"
22853  "\n"
22854  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22855  " pltr below for how these arguments are used (only for the special case\n"
22856  " when the callback function\n"
22857  " pltr is not supplied).\n"
22858  "\n"
22859  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22860  " (inclusive) will be plotted.\n"
22861  "\n"
22862  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22863  " values to use for value to color mappings. A datum equal to or\n"
22864  " less than valuemin will be plotted with color 0.0, while a datum\n"
22865  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22866  " Data between valuemin and valuemax map linearly to colors in the\n"
22867  " range (0.0-1.0).\n"
22868  "\n"
22869  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22870  " defines the transformation between the zero-based indices of the\n"
22871  " matrix idata and world coordinates. If\n"
22872  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22873  " indices of idata are mapped to the range\n"
22874  " xmin through\n"
22875  " xmax and the y indices of idata are mapped to the range\n"
22876  " ymin through\n"
22877  " ymax.For the C case, transformation functions are provided in the\n"
22878  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22879  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22880  " matrices. In addition, C callback routines for the transformation\n"
22881  " can be supplied by the user such as the mypltr function in\n"
22882  " examples/c/x09c.c which provides a general linear transformation\n"
22883  " between index coordinates and world coordinates.For languages\n"
22884  " other than C you should consult the PLplot documentation for the\n"
22885  " details concerning how PLTRANSFORM_callback arguments are\n"
22886  " interfaced. However, in general, a particular pattern of\n"
22887  " callback-associated arguments such as a tr vector with 6 elements;\n"
22888  " xg and yg vectors; or xg and yg matrices are respectively\n"
22889  " interfaced to a linear-transformation routine similar to the above\n"
22890  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22891  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22892  " support native language callbacks for handling index to\n"
22893  " world-coordinate transformations. Examples of these various\n"
22894  " approaches are given in examples/<language>x09*,\n"
22895  " examples/<language>x16*, examples/<language>x20*,\n"
22896  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22897  " supported languages.\n"
22898  "\n"
22899  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22900  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22901  " externally supplied.\n"
22902  "\n"
22903  ""},
22904  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
22905  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
22906  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22907  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
22908  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
22909  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, (char *)"\n"
22910  "Wait for graphics input event and translate to world coordinates.\n"
22911  "\n"
22912  "DESCRIPTION:\n"
22913  "\n"
22914  " Wait for graphics input event and translate to world coordinates.\n"
22915  " Returns 0 if no translation to world coordinates is possible.\n"
22916  "\n"
22917  " This function returns 1 on success and 0 if no translation to world\n"
22918  " coordinates is possible.\n"
22919  "\n"
22920  " Redacted form: plGetCursor(gin)\n"
22921  "\n"
22922  " This function is used in examples 1 and 20.\n"
22923  "\n"
22924  "\n"
22925  "\n"
22926  "SYNOPSIS:\n"
22927  "\n"
22928  "PLINT plGetCursor(gin)\n"
22929  "\n"
22930  "ARGUMENTS:\n"
22931  "\n"
22932  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22933  " which will contain the output. The structure is not allocated by\n"
22934  " the routine and must exist before the function is called.\n"
22935  "\n"
22936  ""},
22937  { NULL, NULL, 0, NULL }
22938 };
22939 
22940 
22941 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22942 
22943 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22944 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22945 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22946 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22947 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22948 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};
22949 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};
22950 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};
22951 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};
22952 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};
22953 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22954 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22955 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22956 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22957 
22962  &_swigt__p_char,
22969  &_swigt__p_int,
22973 };
22974 
22975 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22976 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22977 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22978 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22979 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22985 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22986 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22987 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22988 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22989 
23001  _swigc__p_int,
23005 };
23006 
23007 
23008 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23009 
23011 {0, 0, 0, 0.0, 0, 0}};
23012 
23013 #ifdef __cplusplus
23014 }
23015 #endif
23016 /* -----------------------------------------------------------------------------
23017  * Type initialization:
23018  * This problem is tough by the requirement that no dynamic
23019  * memory is used. Also, since swig_type_info structures store pointers to
23020  * swig_cast_info structures and swig_cast_info structures store pointers back
23021  * to swig_type_info structures, we need some lookup code at initialization.
23022  * The idea is that swig generates all the structures that are needed.
23023  * The runtime then collects these partially filled structures.
23024  * The SWIG_InitializeModule function takes these initial arrays out of
23025  * swig_module, and does all the lookup, filling in the swig_module.types
23026  * array with the correct data and linking the correct swig_cast_info
23027  * structures together.
23028  *
23029  * The generated swig_type_info structures are assigned statically to an initial
23030  * array. We just loop through that array, and handle each type individually.
23031  * First we lookup if this type has been already loaded, and if so, use the
23032  * loaded structure instead of the generated one. Then we have to fill in the
23033  * cast linked list. The cast data is initially stored in something like a
23034  * two-dimensional array. Each row corresponds to a type (there are the same
23035  * number of rows as there are in the swig_type_initial array). Each entry in
23036  * a column is one of the swig_cast_info structures for that type.
23037  * The cast_initial array is actually an array of arrays, because each row has
23038  * a variable number of columns. So to actually build the cast linked list,
23039  * we find the array of casts associated with the type, and loop through it
23040  * adding the casts to the list. The one last trick we need to do is making
23041  * sure the type pointer in the swig_cast_info struct is correct.
23042  *
23043  * First off, we lookup the cast->type name to see if it is already loaded.
23044  * There are three cases to handle:
23045  * 1) If the cast->type has already been loaded AND the type we are adding
23046  * casting info to has not been loaded (it is in this module), THEN we
23047  * replace the cast->type pointer with the type pointer that has already
23048  * been loaded.
23049  * 2) If BOTH types (the one we are adding casting info to, and the
23050  * cast->type) are loaded, THEN the cast info has already been loaded by
23051  * the previous module so we just ignore it.
23052  * 3) Finally, if cast->type has not already been loaded, then we add that
23053  * swig_cast_info to the linked list (because the cast->type) pointer will
23054  * be correct.
23055  * ----------------------------------------------------------------------------- */
23056 
23057 #ifdef __cplusplus
23058 extern "C" {
23059 #if 0
23060 } /* c-mode */
23061 #endif
23062 #endif
23063 
23064 #if 0
23065 #define SWIGRUNTIME_DEBUG
23066 #endif
23067 
23068 
23069 SWIGRUNTIME void
23070 SWIG_InitializeModule(void *clientdata) {
23071  size_t i;
23072  swig_module_info *module_head, *iter;
23073  int init;
23074 
23075  /* check to see if the circular list has been setup, if not, set it up */
23076  if (swig_module.next==0) {
23077  /* Initialize the swig_module */
23081  init = 1;
23082  } else {
23083  init = 0;
23084  }
23085 
23086  /* Try and load any already created modules */
23087  module_head = SWIG_GetModule(clientdata);
23088  if (!module_head) {
23089  /* This is the first module loaded for this interpreter */
23090  /* so set the swig module into the interpreter */
23091  SWIG_SetModule(clientdata, &swig_module);
23092  } else {
23093  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23094  iter=module_head;
23095  do {
23096  if (iter==&swig_module) {
23097  /* Our module is already in the list, so there's nothing more to do. */
23098  return;
23099  }
23100  iter=iter->next;
23101  } while (iter!= module_head);
23102 
23103  /* otherwise we must add our module into the list */
23104  swig_module.next = module_head->next;
23105  module_head->next = &swig_module;
23106  }
23107 
23108  /* When multiple interpreters are used, a module could have already been initialized in
23109  a different interpreter, but not yet have a pointer in this interpreter.
23110  In this case, we do not want to continue adding types... everything should be
23111  set up already */
23112  if (init == 0) return;
23113 
23114  /* Now work on filling in swig_module.types */
23115 #ifdef SWIGRUNTIME_DEBUG
23116  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23117 #endif
23118  for (i = 0; i < swig_module.size; ++i) {
23119  swig_type_info *type = 0;
23120  swig_type_info *ret;
23121  swig_cast_info *cast;
23122 
23123 #ifdef SWIGRUNTIME_DEBUG
23124  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23125 #endif
23126 
23127  /* if there is another module already loaded */
23128  if (swig_module.next != &swig_module) {
23130  }
23131  if (type) {
23132  /* Overwrite clientdata field */
23133 #ifdef SWIGRUNTIME_DEBUG
23134  printf("SWIG_InitializeModule: found type %s\n", type->name);
23135 #endif
23138 #ifdef SWIGRUNTIME_DEBUG
23139  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23140 #endif
23141  }
23142  } else {
23143  type = swig_module.type_initial[i];
23144  }
23145 
23146  /* Insert casting types */
23147  cast = swig_module.cast_initial[i];
23148  while (cast->type) {
23149  /* Don't need to add information already in the list */
23150  ret = 0;
23151 #ifdef SWIGRUNTIME_DEBUG
23152  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23153 #endif
23154  if (swig_module.next != &swig_module) {
23156 #ifdef SWIGRUNTIME_DEBUG
23157  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23158 #endif
23159  }
23160  if (ret) {
23161  if (type == swig_module.type_initial[i]) {
23162 #ifdef SWIGRUNTIME_DEBUG
23163  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23164 #endif
23165  cast->type = ret;
23166  ret = 0;
23167  } else {
23168  /* Check for casting already in the list */
23169  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23170 #ifdef SWIGRUNTIME_DEBUG
23171  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23172 #endif
23173  if (!ocast) ret = 0;
23174  }
23175  }
23176 
23177  if (!ret) {
23178 #ifdef SWIGRUNTIME_DEBUG
23179  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23180 #endif
23181  if (type->cast) {
23182  type->cast->prev = cast;
23183  cast->next = type->cast;
23184  }
23185  type->cast = cast;
23186  }
23187  cast++;
23188  }
23189  /* Set entry in modules->types array equal to the type */
23190  swig_module.types[i] = type;
23191  }
23192  swig_module.types[i] = 0;
23193 
23194 #ifdef SWIGRUNTIME_DEBUG
23195  printf("**** SWIG_InitializeModule: Cast List ******\n");
23196  for (i = 0; i < swig_module.size; ++i) {
23197  int j = 0;
23199  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23200  while (cast->type) {
23201  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23202  cast++;
23203  ++j;
23204  }
23205  printf("---- Total casts: %d\n",j);
23206  }
23207  printf("**** SWIG_InitializeModule: Cast List ******\n");
23208 #endif
23209 }
23210 
23211 /* This function will propagate the clientdata field of type to
23212 * any new swig_type_info structures that have been added into the list
23213 * of equivalent types. It is like calling
23214 * SWIG_TypeClientData(type, clientdata) a second time.
23215 */
23216 SWIGRUNTIME void
23218  size_t i;
23219  swig_cast_info *equiv;
23220  static int init_run = 0;
23221 
23222  if (init_run) return;
23223  init_run = 1;
23224 
23225  for (i = 0; i < swig_module.size; i++) {
23226  if (swig_module.types[i]->clientdata) {
23227  equiv = swig_module.types[i]->cast;
23228  while (equiv) {
23229  if (!equiv->converter) {
23230  if (equiv->type && !equiv->type->clientdata)
23232  }
23233  equiv = equiv->next;
23234  }
23235  }
23236  }
23237 }
23238 
23239 #ifdef __cplusplus
23240 #if 0
23241 {
23242  /* c-mode */
23243 #endif
23244 }
23245 #endif
23246 
23247 
23248 
23249 #ifdef __cplusplus
23250 extern "C" {
23251 #endif
23252 
23253  /* Python-specific SWIG API */
23254 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23255 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23256 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23257 
23258  /* -----------------------------------------------------------------------------
23259  * global variable support code.
23260  * ----------------------------------------------------------------------------- */
23261 
23262  typedef struct swig_globalvar {
23263  char *name; /* Name of global variable */
23264  PyObject *(*get_attr)(void); /* Return the current value */
23265  int (*set_attr)(PyObject *); /* Set the value */
23267  } swig_globalvar;
23268 
23269  typedef struct swig_varlinkobject {
23270  PyObject_HEAD
23273 
23274  SWIGINTERN PyObject *
23276 #if PY_VERSION_HEX >= 0x03000000
23277  return PyUnicode_InternFromString("<Swig global variables>");
23278 #else
23279  return PyString_FromString("<Swig global variables>");
23280 #endif
23281  }
23282 
23283  SWIGINTERN PyObject *
23285 #if PY_VERSION_HEX >= 0x03000000
23286  PyObject *str = PyUnicode_InternFromString("(");
23287  PyObject *tail;
23288  PyObject *joined;
23289  swig_globalvar *var;
23290  for (var = v->vars; var; var=var->next) {
23291  tail = PyUnicode_FromString(var->name);
23292  joined = PyUnicode_Concat(str, tail);
23293  Py_DecRef(str);
23294  Py_DecRef(tail);
23295  str = joined;
23296  if (var->next) {
23297  tail = PyUnicode_InternFromString(", ");
23298  joined = PyUnicode_Concat(str, tail);
23299  Py_DecRef(str);
23300  Py_DecRef(tail);
23301  str = joined;
23302  }
23303  }
23304  tail = PyUnicode_InternFromString(")");
23305  joined = PyUnicode_Concat(str, tail);
23306  Py_DecRef(str);
23307  Py_DecRef(tail);
23308  str = joined;
23309 #else
23310  PyObject *str = PyString_FromString("(");
23311  swig_globalvar *var;
23312  for (var = v->vars; var; var=var->next) {
23313  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23314  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23315  }
23316  PyString_ConcatAndDel(&str,PyString_FromString(")"));
23317 #endif
23318  return str;
23319  }
23320 
23321  SWIGINTERN int
23323  char *tmp;
23324  PyObject *str = swig_varlink_str(v);
23325  fprintf(fp,"Swig global variables ");
23326  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
23328  Py_DECREF(str);
23329  return 0;
23330  }
23331 
23332  SWIGINTERN void
23334  swig_globalvar *var = v->vars;
23335  while (var) {
23336  swig_globalvar *n = var->next;
23337  free(var->name);
23338  free(var);
23339  var = n;
23340  }
23341  }
23342 
23343  SWIGINTERN PyObject *
23345  PyObject *res = NULL;
23346  swig_globalvar *var = v->vars;
23347  while (var) {
23348  if (strcmp(var->name,n) == 0) {
23349  res = (*var->get_attr)();
23350  break;
23351  }
23352  var = var->next;
23353  }
23354  if (res == NULL && !PyErr_Occurred()) {
23355  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23356  }
23357  return res;
23358  }
23359 
23360  SWIGINTERN int
23361  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23362  int res = 1;
23363  swig_globalvar *var = v->vars;
23364  while (var) {
23365  if (strcmp(var->name,n) == 0) {
23366  res = (*var->set_attr)(p);
23367  break;
23368  }
23369  var = var->next;
23370  }
23371  if (res == 1 && !PyErr_Occurred()) {
23372  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23373  }
23374  return res;
23375  }
23376 
23377  SWIGINTERN PyTypeObject*
23379  static char varlink__doc__[] = "Swig var link object";
23380  static PyTypeObject varlink_type;
23381  static int type_init = 0;
23382  if (!type_init) {
23383  const PyTypeObject tmp = {
23384 #if PY_VERSION_HEX >= 0x03000000
23385  PyVarObject_HEAD_INIT(NULL, 0)
23386 #else
23387  PyObject_HEAD_INIT(NULL)
23388  0, /* ob_size */
23389 #endif
23390  (char *)"swigvarlink", /* tp_name */
23391  sizeof(swig_varlinkobject), /* tp_basicsize */
23392  0, /* tp_itemsize */
23393  (destructor) swig_varlink_dealloc, /* tp_dealloc */
23394  (printfunc) swig_varlink_print, /* tp_print */
23395  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
23396  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
23397  0, /* tp_compare */
23398  (reprfunc) swig_varlink_repr, /* tp_repr */
23399  0, /* tp_as_number */
23400  0, /* tp_as_sequence */
23401  0, /* tp_as_mapping */
23402  0, /* tp_hash */
23403  0, /* tp_call */
23404  (reprfunc) swig_varlink_str, /* tp_str */
23405  0, /* tp_getattro */
23406  0, /* tp_setattro */
23407  0, /* tp_as_buffer */
23408  0, /* tp_flags */
23409  varlink__doc__, /* tp_doc */
23410  0, /* tp_traverse */
23411  0, /* tp_clear */
23412  0, /* tp_richcompare */
23413  0, /* tp_weaklistoffset */
23414 #if PY_VERSION_HEX >= 0x02020000
23415  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23416 #endif
23417 #if PY_VERSION_HEX >= 0x02030000
23418  0, /* tp_del */
23419 #endif
23420 #if PY_VERSION_HEX >= 0x02060000
23421  0, /* tp_version_tag */
23422 #endif
23423 #if PY_VERSION_HEX >= 0x03040000
23424  0, /* tp_finalize */
23425 #endif
23426 #ifdef COUNT_ALLOCS
23427  0, /* tp_allocs */
23428  0, /* tp_frees */
23429  0, /* tp_maxalloc */
23430 #if PY_VERSION_HEX >= 0x02050000
23431  0, /* tp_prev */
23432 #endif
23433  0 /* tp_next */
23434 #endif
23435  };
23436  varlink_type = tmp;
23437  type_init = 1;
23438 #if PY_VERSION_HEX < 0x02020000
23439  varlink_type.ob_type = &PyType_Type;
23440 #else
23441  if (PyType_Ready(&varlink_type) < 0)
23442  return NULL;
23443 #endif
23444  }
23445  return &varlink_type;
23446  }
23447 
23448  /* Create a variable linking object for use later */
23449  SWIGINTERN PyObject *
23451  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23452  if (result) {
23453  result->vars = 0;
23454  }
23455  return ((PyObject*) result);
23456  }
23457 
23458  SWIGINTERN void
23459  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23461  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23462  if (gv) {
23463  size_t size = strlen(name)+1;
23464  gv->name = (char *)malloc(size);
23465  if (gv->name) {
23466  strncpy(gv->name,name,size);
23467  gv->get_attr = get_attr;
23468  gv->set_attr = set_attr;
23469  gv->next = v->vars;
23470  }
23471  }
23472  v->vars = gv;
23473  }
23474 
23475  SWIGINTERN PyObject *
23477  static PyObject *_SWIG_globals = 0;
23478  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23479  return _SWIG_globals;
23480  }
23481 
23482  /* -----------------------------------------------------------------------------
23483  * constants/methods manipulation
23484  * ----------------------------------------------------------------------------- */
23485 
23486  /* Install Constants */
23487  SWIGINTERN void
23488  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23489  PyObject *obj = 0;
23490  size_t i;
23491  for (i = 0; constants[i].type; ++i) {
23492  switch(constants[i].type) {
23493  case SWIG_PY_POINTER:
23494  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23495  break;
23496  case SWIG_PY_BINARY:
23497  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23498  break;
23499  default:
23500  obj = 0;
23501  break;
23502  }
23503  if (obj) {
23504  PyDict_SetItemString(d, constants[i].name, obj);
23505  Py_DECREF(obj);
23506  }
23507  }
23508  }
23509 
23510  /* -----------------------------------------------------------------------------*/
23511  /* Fix SwigMethods to carry the callback ptrs when needed */
23512  /* -----------------------------------------------------------------------------*/
23513 
23514  SWIGINTERN void
23515  SWIG_Python_FixMethods(PyMethodDef *methods,
23516  swig_const_info *const_table,
23517  swig_type_info **types,
23518  swig_type_info **types_initial) {
23519  size_t i;
23520  for (i = 0; methods[i].ml_name; ++i) {
23521  const char *c = methods[i].ml_doc;
23522  if (!c) continue;
23523  c = strstr(c, "swig_ptr: ");
23524  if (c) {
23525  int j;
23526  swig_const_info *ci = 0;
23527  const char *name = c + 10;
23528  for (j = 0; const_table[j].type; ++j) {
23529  if (strncmp(const_table[j].name, name,
23530  strlen(const_table[j].name)) == 0) {
23531  ci = &(const_table[j]);
23532  break;
23533  }
23534  }
23535  if (ci) {
23536  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23537  if (ptr) {
23538  size_t shift = (ci->ptype) - types;
23539  swig_type_info *ty = types_initial[shift];
23540  size_t ldoc = (c - methods[i].ml_doc);
23541  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23542  char *ndoc = (char*)malloc(ldoc + lptr + 10);
23543  if (ndoc) {
23544  char *buff = ndoc;
23545  memcpy(buff, methods[i].ml_doc, ldoc);
23546  buff += ldoc;
23547  memcpy(buff, "swig_ptr: ", 10);
23548  buff += 10;
23549  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23550  methods[i].ml_doc = ndoc;
23551  }
23552  }
23553  }
23554  }
23555  }
23556  }
23557 
23558 #ifdef __cplusplus
23559 }
23560 #endif
23561 
23562 /* -----------------------------------------------------------------------------*
23563  * Partial Init method
23564  * -----------------------------------------------------------------------------*/
23565 
23566 #ifdef __cplusplus
23567 extern "C"
23568 #endif
23569 
23570 SWIGEXPORT
23571 #if PY_VERSION_HEX >= 0x03000000
23572 PyObject*
23573 #else
23574 void
23575 #endif
23576 SWIG_init(void) {
23577  PyObject *m, *d, *md;
23578 #if PY_VERSION_HEX >= 0x03000000
23579  static struct PyModuleDef SWIG_module = {
23580 # if PY_VERSION_HEX >= 0x03020000
23581  PyModuleDef_HEAD_INIT,
23582 # else
23583  {
23584  PyObject_HEAD_INIT(NULL)
23585  NULL, /* m_init */
23586  0, /* m_index */
23587  NULL, /* m_copy */
23588  },
23589 # endif
23590  (char *) SWIG_name,
23591  NULL,
23592  -1,
23593  SwigMethods,
23594  NULL,
23595  NULL,
23596  NULL,
23597  NULL
23598  };
23599 #endif
23600 
23601 #if defined(SWIGPYTHON_BUILTIN)
23602  static SwigPyClientData SwigPyObject_clientdata = {
23603  0, 0, 0, 0, 0, 0, 0
23604  };
23605  static PyGetSetDef this_getset_def = {
23606  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23607  };
23608  static SwigPyGetSet thisown_getset_closure = {
23609  (PyCFunction) SwigPyObject_own,
23610  (PyCFunction) SwigPyObject_own
23611  };
23612  static PyGetSetDef thisown_getset_def = {
23613  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23614  };
23615  PyTypeObject *builtin_pytype;
23616  int builtin_base_count;
23617  swig_type_info *builtin_basetype;
23618  PyObject *tuple;
23619  PyGetSetDescrObject *static_getset;
23620  PyTypeObject *metatype;
23621  PyTypeObject *swigpyobject;
23622  SwigPyClientData *cd;
23623  PyObject *public_interface, *public_symbol;
23624  PyObject *this_descr;
23625  PyObject *thisown_descr;
23626  PyObject *self = 0;
23627  int i;
23628 
23629  (void)builtin_pytype;
23630  (void)builtin_base_count;
23631  (void)builtin_basetype;
23632  (void)tuple;
23633  (void)static_getset;
23634  (void)self;
23635 
23636  /* Metaclass is used to implement static member variables */
23637  metatype = SwigPyObjectType();
23638  assert(metatype);
23639 #endif
23640 
23641  /* Fix SwigMethods to carry the callback ptrs when needed */
23643 
23644 #if PY_VERSION_HEX >= 0x03000000
23645  m = PyModule_Create(&SWIG_module);
23646 #else
23647  m = Py_InitModule((char *) SWIG_name, SwigMethods);
23648 #endif
23649 
23650  md = d = PyModule_GetDict(m);
23651  (void)md;
23652 
23654 
23655 #ifdef SWIGPYTHON_BUILTIN
23656  swigpyobject = SwigPyObject_TypeOnce();
23657 
23658  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23659  assert(SwigPyObject_stype);
23660  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23661  if (!cd) {
23662  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23663  SwigPyObject_clientdata.pytype = swigpyobject;
23664  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23665  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23666 # if PY_VERSION_HEX >= 0x03000000
23667  return NULL;
23668 # else
23669  return;
23670 # endif
23671  }
23672 
23673  /* All objects have a 'this' attribute */
23674  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23675  (void)this_descr;
23676 
23677  /* All objects have a 'thisown' attribute */
23678  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23679  (void)thisown_descr;
23680 
23681  public_interface = PyList_New(0);
23682  public_symbol = 0;
23683  (void)public_symbol;
23684 
23685  PyDict_SetItemString(md, "__all__", public_interface);
23686  Py_DECREF(public_interface);
23687  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23688  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23689  for (i = 0; swig_const_table[i].name != 0; ++i)
23690  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23691 #endif
23692 
23694 
23695 
23696  import_array();
23697 
23698  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23699  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23700  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23701  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23702  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23703  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23704  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23705  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23706  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23707  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23708  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23709  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23710  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23711  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23712  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23713  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23714  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23715  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23716  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23717  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23718  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23719  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23720  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23721  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23722  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23723  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23724  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23725  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23726  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23727  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23728  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23729  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23730  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23731  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23732  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23733  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23734  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23735  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23736  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23737  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23738  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23739  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23740  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23741  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23742  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23743  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23744  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23745  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23746  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23747  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23748  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23749  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23750  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23751  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23752  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23753  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23754  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23755  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23756  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23757  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23758  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23759  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23760  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23761  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23762  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23763  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23764  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23765  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23766  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23767  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23768  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23769  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23770  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23771  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23772  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23773  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23774  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23775  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23776  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23777  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23778  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23779  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23780  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23781  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23782  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23783  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23784  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23785  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23786  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23787  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23788  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23789  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23790  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23791  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23792  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23793  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23794  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23795  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23796  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23797  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23798  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23799  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23800  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23801  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23802  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23803  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23804  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23805  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23806  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23807  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23808  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23809  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23810  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23811  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23812  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23813  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23814  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23815  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23816  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23817  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23818  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23819  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23820  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23821  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23822  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23823  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23824  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23825  SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23826  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23827  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23828  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23829  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23830  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23831  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23832  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23833  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23834  SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23835  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23836  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23837  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23838  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23839  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23840  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23841  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23842  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23843  SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23844  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23845  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23846  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23847  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23848  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23849  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23850  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23851  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23852  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23853  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23854  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23855  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23856  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23857  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23858  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23859  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23860  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23861  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23862  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23863  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23864  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23865  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23866  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23867  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23868  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23869  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23870  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23871  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23872  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23873  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23874  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23875 #if PY_VERSION_HEX >= 0x03000000
23876  return m;
23877 #else
23878  return;
23879 #endif
23880 }
23881 
#define MY_BLOCK_THREADS
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
#define SWIG_PYBUFFER_SIZE
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_PYTHON_THREAD_END_BLOCK
#define SWIG_STATIC_POINTER(var)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsfam
Definition: plplot.h:805
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
def plClearOpts
Definition: plplotc.py:8440
#define plw3d
Definition: plplot.h:851
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid1(void)
static const char * name
Definition: tkMain.c:135
#define plpath
Definition: plplot.h:750
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
#define plgxax
Definition: plplot.h:737
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
#define SWIG_MangledTypeQuery(name)
#define plsstrm
Definition: plplot.h:824
#define NPY_PLINT
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj, char *name)
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define plspage
Definition: plplot.h:820
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvpor
Definition: plplot.h:849
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmtex3
Definition: plplot.h:763
#define plerry
Definition: plplot.h:704
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsyax
Definition: plplot.h:841
inquiry lenfunc
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_AttributeError
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
#define plschr
Definition: plplot.h:779
#define plsdev
Definition: plplot.h:795
getwritebufferproc writebufferproc
#define plgdev
Definition: plplot.h:718
static swig_type_info * swig_type_initial[]
#define SWIG_InstallConstants(d, constants)
#define SWIG_init
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllegend
Definition: plplot.h:747
#define SWIG_Python_CallFunctor(functor, obj)
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plshade
Definition: plplot.h:809
#define plscompression
Definition: plplot.h:794
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
#define plarc
Definition: plplot.h:682
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
PLUINT PLUNICODE
Definition: plplot.h:196
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLcGrid2 tmpGrid2
void cleanup_mapform(void)
#define plot3dc
Definition: plplot.h:765
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3dcl
Definition: plplot.h:766
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLcGrid tmpGrid1
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
#define pllsty
Definition: plplot.h:752
#define plsmin
Definition: plplot.h:818
#define plwind
Definition: plplot.h:853
#define plclear
Definition: plplot.h:690
#define plfill
Definition: plplot.h:706
#define plconfigtime
Definition: plplot.h:694
static swig_type_info _swigt__p_p_double
PyObject_HEAD swig_globalvar * vars
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsurf3dl
Definition: plplot.h:837
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_NEW
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v, PyObject *args)
#define plbtime
Definition: plplot.h:688
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
SWIGRUNTIMEINLINE PyObject * _SWIG_This(void)
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pl_setcontlabelparam
Definition: plplot.h:680
static swig_module_info swig_module
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeError
#define plscolbg
Definition: plplot.h:791
#define SWIG_BUFFER_SIZE
swig_dycast_func dcast
struct swig_cast_info * cast
#define plfont
Definition: plplot.h:709
static PyObject * swig_this
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstyl
Definition: plplot.h:835
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpoly3
Definition: plplot.h:771
struct swig_globalvar swig_globalvar
static PLINT Alen
#define plimage
Definition: plplot.h:742
swig_type_info * type
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfontld
Definition: plplot.h:710
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
#define plscolbga
Definition: plplot.h:792
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define Py_NotImplemented
#define plbin
Definition: plplot.h:684
static swig_type_info _swigt__p_int
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
ct_func marshal_ct(PyObject *input)
#define plsdiori
Definition: plplot.h:798
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
#define plparseopts
Definition: plplot.h:767
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
#define SWIG_IOError
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
#define plsym
Definition: plplot.h:842
#define plscmap1
Definition: plplot.h:783
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plinit
Definition: plplot.h:744
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
#define plctime
Definition: plplot.h:697
#define pltimefmt
Definition: plplot.h:845
#define plscmap1n
Definition: plplot.h:787
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_type_info * ty
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
#define plbop
Definition: plplot.h:685
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
static PLINT Ylen
static swig_type_info _swigt__p_f_double_double__int
def pltr0
Definition: plplotc.py:101
PyObject * python_label
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
#define plsdiplt
Definition: plplot.h:799
#define plsvect
Definition: plplot.h:838
#define plscmap1a
Definition: plplot.h:784
#define plssub
Definition: plplot.h:825
#define SWIG_DelNewMask(r)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD void * ptr
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIG_POINTER_OWN
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static swig_cast_info _swigc__p_p_double[]
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyArrayObject * pltr_xg
void * PLPointer
Definition: plplot.h:204
#define plspal1
Definition: plplot.h:822
#define plsetopt
Definition: plplot.h:804
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OLDOBJ
pltr_func marshal_pltr(PyObject *input)
static swig_cast_info _swigc__p_PLcGrid2[]
#define plmeshc
Definition: plplot.h:760
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgcompression
Definition: plplot.h:717
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plszax
Definition: plplot.h:843
#define plvsta
Definition: plplot.h:850
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define SWIG_Python_str_DelForPy3(x)
PyMappingMethods as_mapping
SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v)
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
#define plgpage
Definition: plplot.h:728
#define plaxes
Definition: plplot.h:683
#define SWIG_OK
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
#define SWIG_GetModule(clientdata)
#define plsori
Definition: plplot.h:819
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
#define SWIG_as_voidptrptr(a)
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgdiplt
Definition: plplot.h:721
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0a
Definition: plplot.h:781
#define SWIG_PY_BINARY
static swig_cast_info _swigc__p_double[]
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
PLINT ny
Definition: plplot.h:525
#define SWIG_RuntimeError
struct swig_type_info swig_type_info
#define plfamadv
Definition: plplot.h:705
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
static swig_type_info _swigt__p_p_char
#define SWIG_BUILTIN_TP_INIT
#define PyString_AsStringAndSize(obj, s, len)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plend
Definition: plplot.h:698
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_str_FromFormat
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmem
Definition: plplot.h:816
#define plgfont
Definition: plplot.h:726
def plSetUsage
Definition: plplotc.py:8448
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define plend1
Definition: plplot.h:699
#define SWIG_POINTER_NOSHADOW
int PLINT
Definition: plplot.h:176
#define plenv0
Definition: plplot.h:701
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject * python_f2eval
#define PySequence_Size
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgdiori
Definition: plplot.h:720
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
static PyObject * PyString_FromFormat(const char *fmt,...)
#define plshades
Definition: plplot.h:813
PLINT PLBOOL
Definition: plplot.h:199
getcharbufferproc charbufferproc
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:826
static swig_const_info swig_const_table[]
PLFLT_NC_MATRIX yg
Definition: plplot.h:524
#define pljoin
Definition: plplot.h:745
#define plgzax
Definition: plplot.h:739
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_name
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfam
Definition: plplot.h:723
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_char
intargfunc ssizeargfunc
#define SWIG_AddNewMask(r)
PLINT ny
Definition: plplot.h:513
#define plgdidev
Definition: plplot.h:719
#define SWIG_fail
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstar
Definition: plplot.h:827
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGRUNTIME void SWIG_Python_DestroyModule(void *vptr)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static swig_type_info _swigt__p_PLcGrid
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
#define plcpstrm
Definition: plplot.h:696
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plimagefr
Definition: plplot.h:743
#define plcalc_world
Definition: plplot.h:689
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyNumberMethods as_number
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
#define plsfnam
Definition: plplot.h:807
#define plhist
Definition: plplot.h:740
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SystemError
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
swig_type_info * ty
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * PyBool_FromLong(long ok)
#define plgchr
Definition: plplot.h:711
#define SWIG_OverflowError
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info * next
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdidev
Definition: plplot.h:796
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
#define plspal0
Definition: plplot.h:821
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
#define plfill3
Definition: plplot.h:707
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmema
Definition: plplot.h:817
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
swig_converter_func converter
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_MemoryError
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define plseed
Definition: plplot.h:802
def plOptUsage
Definition: plplotc.py:8452
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:512
#define plstring
Definition: plplot.h:830
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
#define plstransform
Definition: plplot.h:829
#define plvect
Definition: plplot.h:847
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyBufferProcs as_buffer
PyObject * python_ct
int(* set_attr)(PyObject *)
SWIGRUNTIME void SWIG_PropagateClientData(void)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
#define SWIG_exception_fail(code, msg)
intintargfunc ssizessizeargfunc
def plResetOpts
Definition: plplotc.py:8444
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define plscmap1la
Definition: plplot.h:786
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfnam
Definition: plplot.h:725
#define SWIG_TYPE_TABLE_NAME
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcont
Definition: plplot.h:695
#define plsxax
Definition: plplot.h:840
#define plstart
Definition: plplot.h:828
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
#define SWIG_NEWOBJ
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define pleop
Definition: plplot.h:702
#define plmesh
Definition: plplot.h:759
#define plhlsrgb
Definition: plplot.h:741
swig_type_info ** types
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
getsegcountproc segcountproc
#define PyInt_FromSize_t(x)
#define plsmaj
Definition: plplot.h:815
PLINT nx
Definition: plplot.h:525
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
static PyMethodDef swigobject_methods[]
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_double_double__int[]
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol1
Definition: plplot.h:692
#define pllab
Definition: plplot.h:746
#define pllightsource
Definition: plplot.h:748
#define PyObject_DEL
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
#define SWIG_RUNTIME_VERSION
#define plbox
Definition: plplot.h:686
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pltext
Definition: plplot.h:844
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
#define plwidth
Definition: plplot.h:852
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
#define plgver
Definition: plplot.h:734
#define SWIG_POINTER_IMPLICIT_CONV
PyObject * python_pltr
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
#define plscol0a
Definition: plplot.h:790
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define plptex3
Definition: plplot.h:775
#define plsdiplz
Definition: plplot.h:800
void cleanup_PLcGrid2(void)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static char buf[200]
Definition: tclAPI.c:873
#define SWIG_NewClientData(obj)
#define SWIG_ERROR
#define plspause
Definition: plplot.h:823
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
PyObject *(* get_attr)(void)
#define PyOS_snprintf
#define plline3
Definition: plplot.h:751
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
def plsxwin
Definition: plplotc.py:356
#define plstripd
Definition: plplot.h:834
#define plgfci
Definition: plplot.h:724
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
#define plgspa
Definition: plplot.h:732
#define plgcolbg
Definition: plplot.h:715
#define plstripc
Definition: plplot.h:833
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_type_info ** ptype
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
#define plstripa
Definition: plplot.h:832
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstring3
Definition: plplot.h:831
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define plvpas
Definition: plplot.h:848
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyTypeObject * pytype
SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o)
destructor freefunc
#define SWIG_ValueError
PySequenceMethods as_sequence
def plMinMax2dGrid
Definition: plplotc.py:8456
#define plsfont
Definition: plplot.h:808
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
#define PyObject_GenericGetAttr
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static PLINT Xlen
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
#define plpsty
Definition: plplot.h:773
#define MY_UNBLOCK_THREADS
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
struct swig_module_info swig_module_info
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1223
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgvpd
Definition: plplot.h:735
#define plpoin
Definition: plplot.h:769
#define plgriddata
Definition: plplot.h:731
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define plgvpw
Definition: plplot.h:736
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_PLGraphicsIn
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_pltr(void)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyArrayObject * pltr_yg
static swig_type_info * swig_types[15]
#define t_output_helper
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmkstrm
Definition: plplot.h:761
#define PL_UNUSED(x)
Definition: plplot.h:128
intintobjargproc ssizessizeobjargproc
#define SWIG_InternalNewPointerObj(ptr, type, flags)
float PLFLT
Definition: plplot.h:158
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0
Definition: plplot.h:789
def pltr2
Definition: plplotc.py:109
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
#define plxormod
Definition: plplot.h:854
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject_HEAD void * pack
#define Py_TYPE(op)
#define plflush
Definition: plplot.h:708
#define plerrx
Definition: plplot.h:703
void cleanup_ct(void)
#define plgcol0a
Definition: plplot.h:714
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static swig_cast_info * swig_cast_initial[]
SWIGRUNTIME PyObject * SWIG_This(void)
getreadbufferproc readbufferproc
#define plgcolbga
Definition: plplot.h:716
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
#define SWIG_ArgError(r)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgyax
Definition: plplot.h:738
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsesc
Definition: plplot.h:803
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_globalvar * next
#define plenv
Definition: plplot.h:700
int Py_ssize_t
#define SWIG_newvarlink()
#define min(x, y)
Definition: nnpi.c:87
struct swig_cast_info * next
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_DISOWN
#define plgcmap1_range
Definition: plplot.h:712
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define plcol0
Definition: plplot.h:691
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbox3
Definition: plplot.h:687
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_From_double
#define plcolorbar
Definition: plplot.h:693
static swig_cast_info _swigc__p_PLcGrid[]
static long PyNumber_AsSsize_t(PyObject *x, void *SWIGUNUSEDPARM(exc))
intobjargproc ssizeobjargproc
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:727
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:512
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define max(x, y)
Definition: nnpi.c:88
#define plpoin3
Definition: plplot.h:770
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0n
Definition: plplot.h:782
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
#define plscolor
Definition: plplot.h:793
#define plsvpa
Definition: plplot.h:839
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static tclMatrixXtnsnDescr * tail
Definition: tclMatrix.c:461
#define plpat
Definition: plplot.h:768
#define pl_setcontlabelformat
Definition: plplot.h:679
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1_range
Definition: plplot.h:788
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
#define SWIGINTERN
struct swig_cast_info * prev
#define SWIG_IsNewObj(r)
#define plgcol0
Definition: plplot.h:713
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
PyObject * python_mapform
#define plreplot
Definition: plplot.h:777
swig_cast_info ** cast_initial
#define SWIGRUNTIMEINLINE
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptr(a)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
#define SWIGTYPE_p_int
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
#define plscmap1l
Definition: plplot.h:785
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
#define plprec
Definition: plplot.h:772
#define plptex
Definition: plplot.h:774
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline
Definition: plplot.h:749
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
PLFLT_NC_MATRIX xg
Definition: plplot.h:524
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SyntaxError
#define plgradient
Definition: plplot.h:730
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
swig_type_info ** type_initial
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pladv
Definition: plplot.h:681
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvasp
Definition: plplot.h:846
#define plrandd
Definition: plplot.h:776
#define SWIG_PY_POINTER
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_AddCast(r)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define plscmap0
Definition: plplot.h:780
SWIGINTERN PyObject * _wrap_plssub(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:616
#define plgstrm
Definition: plplot.h:733
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_unsigned_int
#define plsfci
Definition: plplot.h:806
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
char string[PL_MAXKEY]
Definition: plplot.h:444
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmtex
Definition: plplot.h:762
static swig_cast_info _swigc__p_int[]
#define plrgbhls
Definition: plplot.h:778
#define plsurf3d
Definition: plplot.h:836
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
mapform_func marshal_mapform(PyObject *input)
def pltr1
Definition: plplotc.py:105
#define plgra
Definition: plplot.h:729
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdimap
Definition: plplot.h:797
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * SWIG_globals(void)
static swig_cast_info _swigc__p_char[]
#define plot3d
Definition: plplot.h:764
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plslabelfunc
Definition: plplot.h:814
PLINT nx
Definition: plplot.h:513
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)