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 *newstr = 0;
783  str = PyUnicode_AsUTF8String(str);
784  if (str) {
785  char *cstr;
786  Py_ssize_t len;
787  PyBytes_AsStringAndSize(str, &cstr, &len);
788  newstr = (char *) malloc(len+1);
789  memcpy(newstr, cstr, len+1);
790  Py_XDECREF(str);
791  }
792  return newstr;
793 #else
794  return PyString_AsString(str);
795 #endif
796 }
797 
798 #if PY_VERSION_HEX >= 0x03000000
799 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
800 #else
801 # define SWIG_Python_str_DelForPy3(x)
802 #endif
803 
804 
805 SWIGINTERN PyObject*
807 {
808 #if PY_VERSION_HEX >= 0x03000000
809  return PyUnicode_FromString(c);
810 #else
811  return PyString_FromString(c);
812 #endif
813 }
814 
815 /* Add PyOS_snprintf for old Pythons */
816 #if PY_VERSION_HEX < 0x02020000
817 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
818 # define PyOS_snprintf _snprintf
819 # else
820 # define PyOS_snprintf snprintf
821 # endif
822 #endif
823 
824 /* A crude PyString_FromFormat implementation for old Pythons */
825 #if PY_VERSION_HEX < 0x02020000
826 
827 #ifndef SWIG_PYBUFFER_SIZE
828 # define SWIG_PYBUFFER_SIZE 1024
829 #endif
830 
831 static PyObject *
832 PyString_FromFormat(const char *fmt, ...) {
833  va_list ap;
834  char buf[SWIG_PYBUFFER_SIZE * 2];
835  int res;
836  va_start(ap, fmt);
837  res = vsnprintf(buf, sizeof(buf), fmt, ap);
838  va_end(ap);
839  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
840 }
841 #endif
842 
843 #ifndef PyObject_DEL
844 # define PyObject_DEL PyObject_Del
845 #endif
846 
847 /* A crude PyExc_StopIteration exception for old Pythons */
848 #if PY_VERSION_HEX < 0x02020000
849 # ifndef PyExc_StopIteration
850 # define PyExc_StopIteration PyExc_RuntimeError
851 # endif
852 # ifndef PyObject_GenericGetAttr
853 # define PyObject_GenericGetAttr 0
854 # endif
855 #endif
856 
857 /* Py_NotImplemented is defined in 2.1 and up. */
858 #if PY_VERSION_HEX < 0x02010000
859 # ifndef Py_NotImplemented
860 # define Py_NotImplemented PyExc_RuntimeError
861 # endif
862 #endif
863 
864 /* A crude PyString_AsStringAndSize implementation for old Pythons */
865 #if PY_VERSION_HEX < 0x02010000
866 # ifndef PyString_AsStringAndSize
867 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
868 # endif
869 #endif
870 
871 /* PySequence_Size for old Pythons */
872 #if PY_VERSION_HEX < 0x02000000
873 # ifndef PySequence_Size
874 # define PySequence_Size PySequence_Length
875 # endif
876 #endif
877 
878 /* PyBool_FromLong for old Pythons */
879 #if PY_VERSION_HEX < 0x02030000
880 static
881 PyObject *PyBool_FromLong(long ok)
882 {
883  PyObject *result = ok ? Py_True : Py_False;
884  Py_INCREF(result);
885  return result;
886 }
887 #endif
888 
889 /* Py_ssize_t for old Pythons */
890 /* This code is as recommended by: */
891 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
892 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
893 typedef int Py_ssize_t;
894 # define PY_SSIZE_T_MAX INT_MAX
895 # define PY_SSIZE_T_MIN INT_MIN
896 typedef inquiry lenfunc;
897 typedef intargfunc ssizeargfunc;
898 typedef intintargfunc ssizessizeargfunc;
899 typedef intobjargproc ssizeobjargproc;
900 typedef intintobjargproc ssizessizeobjargproc;
901 typedef getreadbufferproc readbufferproc;
902 typedef getwritebufferproc writebufferproc;
903 typedef getsegcountproc segcountproc;
904 typedef getcharbufferproc charbufferproc;
905 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
906 {
907  long result = 0;
908  PyObject *i = PyNumber_Int(x);
909  if (i) {
910  result = PyInt_AsLong(i);
911  Py_DECREF(i);
912  }
913  return result;
914 }
915 #endif
916 
917 #if PY_VERSION_HEX < 0x02050000
918 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
919 #endif
920 
921 #if PY_VERSION_HEX < 0x02040000
922 #define Py_VISIT(op) \
923  do { \
924  if (op) { \
925  int vret = visit((op), arg); \
926  if (vret) \
927  return vret; \
928  } \
929  } while (0)
930 #endif
931 
932 #if PY_VERSION_HEX < 0x02030000
933 typedef struct {
934  PyTypeObject type;
935  PyNumberMethods as_number;
936  PyMappingMethods as_mapping;
937  PySequenceMethods as_sequence;
938  PyBufferProcs as_buffer;
939  PyObject *name, *slots;
941 #endif
942 
943 #if PY_VERSION_HEX < 0x02030000
944 typedef destructor freefunc;
945 #endif
946 
947 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
948  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
949  (PY_MAJOR_VERSION > 3))
950 # define SWIGPY_USE_CAPSULE
951 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
952 #endif
953 
954 #if PY_VERSION_HEX < 0x03020000
955 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
956 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
957 #define Py_hash_t long
958 #endif
959 
960 /* -----------------------------------------------------------------------------
961  * error manipulation
962  * ----------------------------------------------------------------------------- */
963 
964 SWIGRUNTIME PyObject*
966  PyObject* type = 0;
967  switch(code) {
968  case SWIG_MemoryError:
969  type = PyExc_MemoryError;
970  break;
971  case SWIG_IOError:
972  type = PyExc_IOError;
973  break;
974  case SWIG_RuntimeError:
975  type = PyExc_RuntimeError;
976  break;
977  case SWIG_IndexError:
978  type = PyExc_IndexError;
979  break;
980  case SWIG_TypeError:
981  type = PyExc_TypeError;
982  break;
983  case SWIG_DivisionByZero:
984  type = PyExc_ZeroDivisionError;
985  break;
986  case SWIG_OverflowError:
987  type = PyExc_OverflowError;
988  break;
989  case SWIG_SyntaxError:
990  type = PyExc_SyntaxError;
991  break;
992  case SWIG_ValueError:
993  type = PyExc_ValueError;
994  break;
995  case SWIG_SystemError:
996  type = PyExc_SystemError;
997  break;
998  case SWIG_AttributeError:
999  type = PyExc_AttributeError;
1000  break;
1001  default:
1002  type = PyExc_RuntimeError;
1003  }
1004  return type;
1005 }
1006 
1007 
1008 SWIGRUNTIME void
1009 SWIG_Python_AddErrorMsg(const char* mesg)
1010 {
1011  PyObject *type = 0;
1012  PyObject *value = 0;
1013  PyObject *traceback = 0;
1014 
1015  if (PyErr_Occurred())
1016  PyErr_Fetch(&type, &value, &traceback);
1017  if (value) {
1018  PyObject *old_str = PyObject_Str(value);
1019  const char *tmp = SWIG_Python_str_AsChar(old_str);
1020  PyErr_Clear();
1021  Py_XINCREF(type);
1022  if (tmp)
1023  PyErr_Format(type, "%s %s", tmp, mesg);
1024  else
1025  PyErr_Format(type, "%s", mesg);
1027  Py_DECREF(old_str);
1028  Py_DECREF(value);
1029  } else {
1030  PyErr_SetString(PyExc_RuntimeError, mesg);
1031  }
1032 }
1033 
1034 #if defined(SWIG_PYTHON_NO_THREADS)
1035 # if defined(SWIG_PYTHON_THREADS)
1036 # undef SWIG_PYTHON_THREADS
1037 # endif
1038 #endif
1039 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1040 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1041 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1042 # define SWIG_PYTHON_USE_GIL
1043 # endif
1044 # endif
1045 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1046 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1047 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1048 # endif
1049 # ifdef __cplusplus /* C++ code */
1050  class SWIG_Python_Thread_Block {
1051  bool status;
1052  PyGILState_STATE state;
1053  public:
1054  void end() { if (status) { PyGILState_Release(state); status = false;} }
1055  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1056  ~SWIG_Python_Thread_Block() { end(); }
1057  };
1058  class SWIG_Python_Thread_Allow {
1059  bool status;
1060  PyThreadState *save;
1061  public:
1062  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1063  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1064  ~SWIG_Python_Thread_Allow() { end(); }
1065  };
1066 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1067 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1068 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1069 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1070 # else /* C code */
1071 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1072 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1073 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1074 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1075 # endif
1076 # else /* Old thread way, not implemented, user must provide it */
1077 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1078 # define SWIG_PYTHON_INITIALIZE_THREADS
1079 # endif
1080 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1081 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1082 # endif
1083 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1084 # define SWIG_PYTHON_THREAD_END_BLOCK
1085 # endif
1086 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1087 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1088 # endif
1089 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1090 # define SWIG_PYTHON_THREAD_END_ALLOW
1091 # endif
1092 # endif
1093 #else /* No thread support */
1094 # define SWIG_PYTHON_INITIALIZE_THREADS
1095 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1096 # define SWIG_PYTHON_THREAD_END_BLOCK
1097 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1098 # define SWIG_PYTHON_THREAD_END_ALLOW
1099 #endif
1100 
1101 /* -----------------------------------------------------------------------------
1102  * Python API portion that goes into the runtime
1103  * ----------------------------------------------------------------------------- */
1104 
1105 #ifdef __cplusplus
1106 extern "C" {
1107 #endif
1108 
1109 /* -----------------------------------------------------------------------------
1110  * Constant declarations
1111  * ----------------------------------------------------------------------------- */
1112 
1113 /* Constant Types */
1114 #define SWIG_PY_POINTER 4
1115 #define SWIG_PY_BINARY 5
1116 
1117 /* Constant information structure */
1118 typedef struct swig_const_info {
1119  int type;
1120  char *name;
1121  long lvalue;
1122  double dvalue;
1123  void *pvalue;
1125 } swig_const_info;
1126 
1127 
1128 /* -----------------------------------------------------------------------------
1129  * Wrapper of PyInstanceMethod_New() used in Python 3
1130  * It is exported to the generated module, used for -fastproxy
1131  * ----------------------------------------------------------------------------- */
1132 #if PY_VERSION_HEX >= 0x03000000
1133 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1134 {
1135  return PyInstanceMethod_New(func);
1136 }
1137 #else
1138 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1139 {
1140  return NULL;
1141 }
1142 #endif
1143 
1144 #ifdef __cplusplus
1145 }
1146 #endif
1147 
1148 
1149 /* -----------------------------------------------------------------------------
1150  * pyrun.swg
1151  *
1152  * This file contains the runtime support for Python modules
1153  * and includes code for managing global variables and pointer
1154  * type checking.
1155  *
1156  * ----------------------------------------------------------------------------- */
1157 
1158 /* Common SWIG API */
1159 
1160 /* for raw pointers */
1161 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1162 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1163 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1164 
1165 #ifdef SWIGPYTHON_BUILTIN
1166 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1167 #else
1168 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1169 #endif
1170 
1171 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1172 
1173 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1174 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1175 #define swig_owntype int
1176 
1177 /* for raw packed data */
1178 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1179 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1180 
1181 /* for class or struct pointers */
1182 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1183 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1184 
1185 /* for C or C++ function pointers */
1186 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1187 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1188 
1189 /* for C++ member pointers, ie, member methods */
1190 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1191 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1192 
1193 
1194 /* Runtime API */
1195 
1196 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1197 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1198 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1199 
1200 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1201 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1202 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1203 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1204 #define SWIG_fail goto fail
1205 
1206 
1207 /* Runtime API implementation */
1208 
1209 /* Error manipulation */
1210 
1211 SWIGINTERN void
1212 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1214  PyErr_SetObject(errtype, obj);
1215  Py_DECREF(obj);
1217 }
1218 
1219 SWIGINTERN void
1220 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1222  PyErr_SetString(errtype, msg);
1224 }
1225 
1226 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1227 
1228 /* Set a constant value */
1229 
1230 #if defined(SWIGPYTHON_BUILTIN)
1231 
1232 SWIGINTERN void
1233 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1234  PyObject *s = PyString_InternFromString(key);
1235  PyList_Append(seq, s);
1236  Py_DECREF(s);
1237 }
1238 
1239 SWIGINTERN void
1240 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1241 #if PY_VERSION_HEX < 0x02030000
1242  PyDict_SetItemString(d, (char *)name, obj);
1243 #else
1244  PyDict_SetItemString(d, name, obj);
1245 #endif
1246  Py_DECREF(obj);
1247  if (public_interface)
1248  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1249 }
1250 
1251 #else
1252 
1253 SWIGINTERN void
1254 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1255 #if PY_VERSION_HEX < 0x02030000
1256  PyDict_SetItemString(d, (char *)name, obj);
1257 #else
1258  PyDict_SetItemString(d, name, obj);
1259 #endif
1260  Py_DECREF(obj);
1261 }
1262 
1263 #endif
1264 
1265 /* Append a value to the result obj */
1266 
1267 SWIGINTERN PyObject*
1268 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1269 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1270  if (!result) {
1271  result = obj;
1272  } else if (result == Py_None) {
1273  Py_DECREF(result);
1274  result = obj;
1275  } else {
1276  if (!PyList_Check(result)) {
1277  PyObject *o2 = result;
1278  result = PyList_New(1);
1279  PyList_SetItem(result, 0, o2);
1280  }
1281  PyList_Append(result,obj);
1282  Py_DECREF(obj);
1283  }
1284  return result;
1285 #else
1286  PyObject* o2;
1287  PyObject* o3;
1288  if (!result) {
1289  result = obj;
1290  } else if (result == Py_None) {
1291  Py_DECREF(result);
1292  result = obj;
1293  } else {
1294  if (!PyTuple_Check(result)) {
1295  o2 = result;
1296  result = PyTuple_New(1);
1297  PyTuple_SET_ITEM(result, 0, o2);
1298  }
1299  o3 = PyTuple_New(1);
1300  PyTuple_SET_ITEM(o3, 0, obj);
1301  o2 = result;
1302  result = PySequence_Concat(o2, o3);
1303  Py_DECREF(o2);
1304  Py_DECREF(o3);
1305  }
1306  return result;
1307 #endif
1308 }
1309 
1310 /* Unpack the argument tuple */
1311 
1313 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1314 {
1315  if (!args) {
1316  if (!min && !max) {
1317  return 1;
1318  } else {
1319  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1320  name, (min == max ? "" : "at least "), (int)min);
1321  return 0;
1322  }
1323  }
1324  if (!PyTuple_Check(args)) {
1325  if (min <= 1 && max >= 1) {
1326  Py_ssize_t i;
1327  objs[0] = args;
1328  for (i = 1; i < max; ++i) {
1329  objs[i] = 0;
1330  }
1331  return 2;
1332  }
1333  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1334  return 0;
1335  } else {
1336  Py_ssize_t l = PyTuple_GET_SIZE(args);
1337  if (l < min) {
1338  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1339  name, (min == max ? "" : "at least "), (int)min, (int)l);
1340  return 0;
1341  } else if (l > max) {
1342  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1343  name, (min == max ? "" : "at most "), (int)max, (int)l);
1344  return 0;
1345  } else {
1346  Py_ssize_t i;
1347  for (i = 0; i < l; ++i) {
1348  objs[i] = PyTuple_GET_ITEM(args, i);
1349  }
1350  for (; l < max; ++l) {
1351  objs[l] = 0;
1352  }
1353  return i + 1;
1354  }
1355  }
1356 }
1357 
1358 /* A functor is a function object with one single object argument */
1359 #if PY_VERSION_HEX >= 0x02020000
1360 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1361 #else
1362 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1363 #endif
1364 
1365 /*
1366  Helper for static pointer initialization for both C and C++ code, for example
1367  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1368 */
1369 #ifdef __cplusplus
1370 #define SWIG_STATIC_POINTER(var) var
1371 #else
1372 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1373 #endif
1374 
1375 /* -----------------------------------------------------------------------------
1376  * Pointer declarations
1377  * ----------------------------------------------------------------------------- */
1378 
1379 /* Flags for new pointer objects */
1380 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1381 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1382 
1383 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1384 
1385 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1386 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1387 
1388 #ifdef __cplusplus
1389 extern "C" {
1390 #endif
1391 
1392 /* How to access Py_None */
1393 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1394 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1395 # ifndef SWIG_PYTHON_BUILD_NONE
1396 # define SWIG_PYTHON_BUILD_NONE
1397 # endif
1398 # endif
1399 #endif
1400 
1401 #ifdef SWIG_PYTHON_BUILD_NONE
1402 # ifdef Py_None
1403 # undef Py_None
1404 # define Py_None SWIG_Py_None()
1405 # endif
1406 SWIGRUNTIMEINLINE PyObject *
1407 _SWIG_Py_None(void)
1408 {
1409  PyObject *none = Py_BuildValue((char*)"");
1410  Py_DECREF(none);
1411  return none;
1412 }
1413 SWIGRUNTIME PyObject *
1414 SWIG_Py_None(void)
1415 {
1416  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1417  return none;
1418 }
1419 #endif
1420 
1421 /* The python void return value */
1422 
1423 SWIGRUNTIMEINLINE PyObject *
1425 {
1426  PyObject *none = Py_None;
1427  Py_INCREF(none);
1428  return none;
1429 }
1430 
1431 /* SwigPyClientData */
1432 
1433 typedef struct {
1434  PyObject *klass;
1435  PyObject *newraw;
1436  PyObject *newargs;
1437  PyObject *destroy;
1438  int delargs;
1440  PyTypeObject *pytype;
1442 
1443 SWIGRUNTIMEINLINE int
1445 {
1447  return data ? data->implicitconv : 0;
1448 }
1449 
1450 SWIGRUNTIMEINLINE PyObject *
1452  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1453  PyObject *klass = data ? data->klass : 0;
1454  return (klass ? klass : PyExc_RuntimeError);
1455 }
1456 
1457 
1459 SwigPyClientData_New(PyObject* obj)
1460 {
1461  if (!obj) {
1462  return 0;
1463  } else {
1464  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1465  /* the klass element */
1466  data->klass = obj;
1467  Py_INCREF(data->klass);
1468  /* the newraw method and newargs arguments used to create a new raw instance */
1469  if (PyClass_Check(obj)) {
1470  data->newraw = 0;
1471  data->newargs = obj;
1472  Py_INCREF(obj);
1473  } else {
1474 #if (PY_VERSION_HEX < 0x02020000)
1475  data->newraw = 0;
1476 #else
1477  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1478 #endif
1479  if (data->newraw) {
1480  Py_INCREF(data->newraw);
1481  data->newargs = PyTuple_New(1);
1482  PyTuple_SetItem(data->newargs, 0, obj);
1483  } else {
1484  data->newargs = obj;
1485  }
1486  Py_INCREF(data->newargs);
1487  }
1488  /* the destroy method, aka as the C++ delete method */
1489  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1490  if (PyErr_Occurred()) {
1491  PyErr_Clear();
1492  data->destroy = 0;
1493  }
1494  if (data->destroy) {
1495  int flags;
1496  Py_INCREF(data->destroy);
1497  flags = PyCFunction_GET_FLAGS(data->destroy);
1498 #ifdef METH_O
1499  data->delargs = !(flags & (METH_O));
1500 #else
1501  data->delargs = 0;
1502 #endif
1503  } else {
1504  data->delargs = 0;
1505  }
1506  data->implicitconv = 0;
1507  data->pytype = 0;
1508  return data;
1509  }
1510 }
1511 
1512 SWIGRUNTIME void
1514  Py_XDECREF(data->newraw);
1515  Py_XDECREF(data->newargs);
1516  Py_XDECREF(data->destroy);
1517 }
1518 
1519 /* =============== SwigPyObject =====================*/
1520 
1521 typedef struct {
1522  PyObject_HEAD
1523  void *ptr;
1525  int own;
1526  PyObject *next;
1527 #ifdef SWIGPYTHON_BUILTIN
1528  PyObject *dict;
1529 #endif
1530 } SwigPyObject;
1531 
1532 
1533 #ifdef SWIGPYTHON_BUILTIN
1534 
1535 SWIGRUNTIME PyObject *
1536 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1537 {
1538  SwigPyObject *sobj = (SwigPyObject *)v;
1539 
1540  if (!sobj->dict)
1541  sobj->dict = PyDict_New();
1542 
1543  Py_INCREF(sobj->dict);
1544  return sobj->dict;
1545 }
1546 
1547 #endif
1548 
1549 SWIGRUNTIME PyObject *
1551 {
1552  return PyLong_FromVoidPtr(v->ptr);
1553 }
1554 
1555 SWIGRUNTIME PyObject *
1556 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1557 {
1558  PyObject *res = NULL;
1559  PyObject *args = PyTuple_New(1);
1560  if (args) {
1561  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1562  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1563  if (ofmt) {
1564 #if PY_VERSION_HEX >= 0x03000000
1565  res = PyUnicode_Format(ofmt,args);
1566 #else
1567  res = PyString_Format(ofmt,args);
1568 #endif
1569  Py_DECREF(ofmt);
1570  }
1571  Py_DECREF(args);
1572  }
1573  }
1574  return res;
1575 }
1576 
1577 SWIGRUNTIME PyObject *
1579 {
1580  return SwigPyObject_format("%o",v);
1581 }
1582 
1583 SWIGRUNTIME PyObject *
1585 {
1586  return SwigPyObject_format("%x",v);
1587 }
1588 
1589 SWIGRUNTIME PyObject *
1590 #ifdef METH_NOARGS
1592 #else
1593 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1594 #endif
1595 {
1596  const char *name = SWIG_TypePrettyName(v->ty);
1597  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1598  if (v->next) {
1599 # ifdef METH_NOARGS
1600  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1601 # else
1602  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1603 # endif
1604 # if PY_VERSION_HEX >= 0x03000000
1605  PyObject *joined = PyUnicode_Concat(repr, nrep);
1606  Py_DecRef(repr);
1607  Py_DecRef(nrep);
1608  repr = joined;
1609 # else
1610  PyString_ConcatAndDel(&repr,nrep);
1611 # endif
1612  }
1613  return repr;
1614 }
1615 
1616 SWIGRUNTIME int
1618 {
1619  void *i = v->ptr;
1620  void *j = w->ptr;
1621  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1622 }
1623 
1624 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1625 SWIGRUNTIME PyObject*
1627 {
1628  PyObject* res;
1629  if( op != Py_EQ && op != Py_NE ) {
1630  Py_INCREF(Py_NotImplemented);
1631  return Py_NotImplemented;
1632  }
1633  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1634  return res;
1635 }
1636 
1637 
1638 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1639 
1640 #ifdef SWIGPYTHON_BUILTIN
1641 static swig_type_info *SwigPyObject_stype = 0;
1642 SWIGRUNTIME PyTypeObject*
1643 SwigPyObject_type(void) {
1644  SwigPyClientData *cd;
1645  assert(SwigPyObject_stype);
1646  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1647  assert(cd);
1648  assert(cd->pytype);
1649  return cd->pytype;
1650 }
1651 #else
1652 SWIGRUNTIME PyTypeObject*
1654  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1655  return type;
1656 }
1657 #endif
1658 
1660 SwigPyObject_Check(PyObject *op) {
1661 #ifdef SWIGPYTHON_BUILTIN
1662  PyTypeObject *target_tp = SwigPyObject_type();
1663  if (PyType_IsSubtype(op->ob_type, target_tp))
1664  return 1;
1665  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1666 #else
1667  return (Py_TYPE(op) == SwigPyObject_type())
1668  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1669 #endif
1670 }
1671 
1672 SWIGRUNTIME PyObject *
1673 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1674 
1675 SWIGRUNTIME void
1677 {
1678  SwigPyObject *sobj = (SwigPyObject *) v;
1679  PyObject *next = sobj->next;
1680  if (sobj->own == SWIG_POINTER_OWN) {
1681  swig_type_info *ty = sobj->ty;
1682  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1683  PyObject *destroy = data ? data->destroy : 0;
1684  if (destroy) {
1685  /* destroy is always a VARARGS method */
1686  PyObject *res;
1687 
1688  /* PyObject_CallFunction() has the potential to silently drop
1689  the active active exception. In cases of unnamed temporary
1690  variable or where we just finished iterating over a generator
1691  StopIteration will be active right now, and this needs to
1692  remain true upon return from SwigPyObject_dealloc. So save
1693  and restore. */
1694 
1695  PyObject *val = NULL, *type = NULL, *tb = NULL;
1696  PyErr_Fetch(&val, &type, &tb);
1697 
1698  if (data->delargs) {
1699  /* we need to create a temporary object to carry the destroy operation */
1700  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1701  res = SWIG_Python_CallFunctor(destroy, tmp);
1702  Py_DECREF(tmp);
1703  } else {
1704  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1705  PyObject *mself = PyCFunction_GET_SELF(destroy);
1706  res = ((*meth)(mself, v));
1707  }
1708  if (!res)
1709  PyErr_WriteUnraisable(destroy);
1710 
1711  PyErr_Restore(val, type, tb);
1712 
1713  Py_XDECREF(res);
1714  }
1715 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1716  else {
1717  const char *name = SWIG_TypePrettyName(ty);
1718  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1719  }
1720 #endif
1721  }
1722  Py_XDECREF(next);
1723  PyObject_DEL(v);
1724 }
1725 
1726 SWIGRUNTIME PyObject*
1727 SwigPyObject_append(PyObject* v, PyObject* next)
1728 {
1729  SwigPyObject *sobj = (SwigPyObject *) v;
1730 #ifndef METH_O
1731  PyObject *tmp = 0;
1732  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1733  next = tmp;
1734 #endif
1735  if (!SwigPyObject_Check(next)) {
1736  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1737  return NULL;
1738  }
1739  sobj->next = next;
1740  Py_INCREF(next);
1741  return SWIG_Py_Void();
1742 }
1743 
1744 SWIGRUNTIME PyObject*
1745 #ifdef METH_NOARGS
1746 SwigPyObject_next(PyObject* v)
1747 #else
1748 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1749 #endif
1750 {
1751  SwigPyObject *sobj = (SwigPyObject *) v;
1752  if (sobj->next) {
1753  Py_INCREF(sobj->next);
1754  return sobj->next;
1755  } else {
1756  return SWIG_Py_Void();
1757  }
1758 }
1759 
1760 SWIGINTERN PyObject*
1761 #ifdef METH_NOARGS
1762 SwigPyObject_disown(PyObject *v)
1763 #else
1764 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1765 #endif
1766 {
1767  SwigPyObject *sobj = (SwigPyObject *)v;
1768  sobj->own = 0;
1769  return SWIG_Py_Void();
1770 }
1771 
1772 SWIGINTERN PyObject*
1773 #ifdef METH_NOARGS
1774 SwigPyObject_acquire(PyObject *v)
1775 #else
1776 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1777 #endif
1778 {
1779  SwigPyObject *sobj = (SwigPyObject *)v;
1780  sobj->own = SWIG_POINTER_OWN;
1781  return SWIG_Py_Void();
1782 }
1783 
1784 SWIGINTERN PyObject*
1785 SwigPyObject_own(PyObject *v, PyObject *args)
1786 {
1787  PyObject *val = 0;
1788 #if (PY_VERSION_HEX < 0x02020000)
1789  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1790 #elif (PY_VERSION_HEX < 0x02050000)
1791  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1792 #else
1793  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1794 #endif
1795  {
1796  return NULL;
1797  }
1798  else
1799  {
1800  SwigPyObject *sobj = (SwigPyObject *)v;
1801  PyObject *obj = PyBool_FromLong(sobj->own);
1802  if (val) {
1803 #ifdef METH_NOARGS
1804  if (PyObject_IsTrue(val)) {
1806  } else {
1808  }
1809 #else
1810  if (PyObject_IsTrue(val)) {
1811  SwigPyObject_acquire(v,args);
1812  } else {
1813  SwigPyObject_disown(v,args);
1814  }
1815 #endif
1816  }
1817  return obj;
1818  }
1819 }
1820 
1821 #ifdef METH_O
1822 static PyMethodDef
1823 swigobject_methods[] = {
1824  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1825  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1826  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1827  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1828  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1829  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1830  {0, 0, 0, 0}
1831 };
1832 #else
1833 static PyMethodDef
1835  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1836  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1837  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1838  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1839  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1840  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1841  {0, 0, 0, 0}
1842 };
1843 #endif
1844 
1845 #if PY_VERSION_HEX < 0x02020000
1846 SWIGINTERN PyObject *
1848 {
1849  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1850 }
1851 #endif
1852 
1853 SWIGRUNTIME PyTypeObject*
1855  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1856 
1857  static PyNumberMethods SwigPyObject_as_number = {
1858  (binaryfunc)0, /*nb_add*/
1859  (binaryfunc)0, /*nb_subtract*/
1860  (binaryfunc)0, /*nb_multiply*/
1861  /* nb_divide removed in Python 3 */
1862 #if PY_VERSION_HEX < 0x03000000
1863  (binaryfunc)0, /*nb_divide*/
1864 #endif
1865  (binaryfunc)0, /*nb_remainder*/
1866  (binaryfunc)0, /*nb_divmod*/
1867  (ternaryfunc)0,/*nb_power*/
1868  (unaryfunc)0, /*nb_negative*/
1869  (unaryfunc)0, /*nb_positive*/
1870  (unaryfunc)0, /*nb_absolute*/
1871  (inquiry)0, /*nb_nonzero*/
1872  0, /*nb_invert*/
1873  0, /*nb_lshift*/
1874  0, /*nb_rshift*/
1875  0, /*nb_and*/
1876  0, /*nb_xor*/
1877  0, /*nb_or*/
1878 #if PY_VERSION_HEX < 0x03000000
1879  0, /*nb_coerce*/
1880 #endif
1881  (unaryfunc)SwigPyObject_long, /*nb_int*/
1882 #if PY_VERSION_HEX < 0x03000000
1883  (unaryfunc)SwigPyObject_long, /*nb_long*/
1884 #else
1885  0, /*nb_reserved*/
1886 #endif
1887  (unaryfunc)0, /*nb_float*/
1888 #if PY_VERSION_HEX < 0x03000000
1889  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1890  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1891 #endif
1892 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1893  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1894 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1895  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1896 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1897  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1898 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1899  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1900 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1901  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1902 #endif
1903  };
1904 
1905  static PyTypeObject swigpyobject_type;
1906  static int type_init = 0;
1907  if (!type_init) {
1908  const PyTypeObject tmp = {
1909 #if PY_VERSION_HEX >= 0x03000000
1910  PyVarObject_HEAD_INIT(NULL, 0)
1911 #else
1912  PyObject_HEAD_INIT(NULL)
1913  0, /* ob_size */
1914 #endif
1915  (char *)"SwigPyObject", /* tp_name */
1916  sizeof(SwigPyObject), /* tp_basicsize */
1917  0, /* tp_itemsize */
1918  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1919  0, /* tp_print */
1920 #if PY_VERSION_HEX < 0x02020000
1921  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1922 #else
1923  (getattrfunc)0, /* tp_getattr */
1924 #endif
1925  (setattrfunc)0, /* tp_setattr */
1926 #if PY_VERSION_HEX >= 0x03000000
1927  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1928 #else
1929  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1930 #endif
1931  (reprfunc)SwigPyObject_repr, /* tp_repr */
1932  &SwigPyObject_as_number, /* tp_as_number */
1933  0, /* tp_as_sequence */
1934  0, /* tp_as_mapping */
1935  (hashfunc)0, /* tp_hash */
1936  (ternaryfunc)0, /* tp_call */
1937  0, /* tp_str */
1938  PyObject_GenericGetAttr, /* tp_getattro */
1939  0, /* tp_setattro */
1940  0, /* tp_as_buffer */
1941  Py_TPFLAGS_DEFAULT, /* tp_flags */
1942  swigobject_doc, /* tp_doc */
1943  0, /* tp_traverse */
1944  0, /* tp_clear */
1945  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1946  0, /* tp_weaklistoffset */
1947 #if PY_VERSION_HEX >= 0x02020000
1948  0, /* tp_iter */
1949  0, /* tp_iternext */
1950  swigobject_methods, /* tp_methods */
1951  0, /* tp_members */
1952  0, /* tp_getset */
1953  0, /* tp_base */
1954  0, /* tp_dict */
1955  0, /* tp_descr_get */
1956  0, /* tp_descr_set */
1957  0, /* tp_dictoffset */
1958  0, /* tp_init */
1959  0, /* tp_alloc */
1960  0, /* tp_new */
1961  0, /* tp_free */
1962  0, /* tp_is_gc */
1963  0, /* tp_bases */
1964  0, /* tp_mro */
1965  0, /* tp_cache */
1966  0, /* tp_subclasses */
1967  0, /* tp_weaklist */
1968 #endif
1969 #if PY_VERSION_HEX >= 0x02030000
1970  0, /* tp_del */
1971 #endif
1972 #if PY_VERSION_HEX >= 0x02060000
1973  0, /* tp_version_tag */
1974 #endif
1975 #if PY_VERSION_HEX >= 0x03040000
1976  0, /* tp_finalize */
1977 #endif
1978 #ifdef COUNT_ALLOCS
1979  0, /* tp_allocs */
1980  0, /* tp_frees */
1981  0, /* tp_maxalloc */
1982 #if PY_VERSION_HEX >= 0x02050000
1983  0, /* tp_prev */
1984 #endif
1985  0 /* tp_next */
1986 #endif
1987  };
1988  swigpyobject_type = tmp;
1989  type_init = 1;
1990 #if PY_VERSION_HEX < 0x02020000
1991  swigpyobject_type.ob_type = &PyType_Type;
1992 #else
1993  if (PyType_Ready(&swigpyobject_type) < 0)
1994  return NULL;
1995 #endif
1996  }
1997  return &swigpyobject_type;
1998 }
1999 
2000 SWIGRUNTIME PyObject *
2001 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2002 {
2003  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2004  if (sobj) {
2005  sobj->ptr = ptr;
2006  sobj->ty = ty;
2007  sobj->own = own;
2008  sobj->next = 0;
2009  }
2010  return (PyObject *)sobj;
2011 }
2012 
2013 /* -----------------------------------------------------------------------------
2014  * Implements a simple Swig Packed type, and use it instead of string
2015  * ----------------------------------------------------------------------------- */
2016 
2017 typedef struct {
2018  PyObject_HEAD
2019  void *pack;
2021  size_t size;
2022 } SwigPyPacked;
2023 
2024 SWIGRUNTIME int
2026 {
2027  char result[SWIG_BUFFER_SIZE];
2028  fputs("<Swig Packed ", fp);
2029  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2030  fputs("at ", fp);
2031  fputs(result, fp);
2032  }
2033  fputs(v->ty->name,fp);
2034  fputs(">", fp);
2035  return 0;
2036 }
2037 
2038 SWIGRUNTIME PyObject *
2040 {
2041  char result[SWIG_BUFFER_SIZE];
2042  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2043  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2044  } else {
2045  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2046  }
2047 }
2048 
2049 SWIGRUNTIME PyObject *
2051 {
2052  char result[SWIG_BUFFER_SIZE];
2053  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2054  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2055  } else {
2056  return SWIG_Python_str_FromChar(v->ty->name);
2057  }
2058 }
2059 
2060 SWIGRUNTIME int
2062 {
2063  size_t i = v->size;
2064  size_t j = w->size;
2065  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2066  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2067 }
2068 
2069 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2070 
2071 SWIGRUNTIME PyTypeObject*
2073  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2074  return type;
2075 }
2076 
2078 SwigPyPacked_Check(PyObject *op) {
2079  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2080  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2081 }
2082 
2083 SWIGRUNTIME void
2085 {
2086  if (SwigPyPacked_Check(v)) {
2087  SwigPyPacked *sobj = (SwigPyPacked *) v;
2088  free(sobj->pack);
2089  }
2090  PyObject_DEL(v);
2091 }
2092 
2093 SWIGRUNTIME PyTypeObject*
2095  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2096  static PyTypeObject swigpypacked_type;
2097  static int type_init = 0;
2098  if (!type_init) {
2099  const PyTypeObject tmp = {
2100 #if PY_VERSION_HEX>=0x03000000
2101  PyVarObject_HEAD_INIT(NULL, 0)
2102 #else
2103  PyObject_HEAD_INIT(NULL)
2104  0, /* ob_size */
2105 #endif
2106  (char *)"SwigPyPacked", /* tp_name */
2107  sizeof(SwigPyPacked), /* tp_basicsize */
2108  0, /* tp_itemsize */
2109  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2110  (printfunc)SwigPyPacked_print, /* tp_print */
2111  (getattrfunc)0, /* tp_getattr */
2112  (setattrfunc)0, /* tp_setattr */
2113 #if PY_VERSION_HEX>=0x03000000
2114  0, /* tp_reserved in 3.0.1 */
2115 #else
2116  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2117 #endif
2118  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2119  0, /* tp_as_number */
2120  0, /* tp_as_sequence */
2121  0, /* tp_as_mapping */
2122  (hashfunc)0, /* tp_hash */
2123  (ternaryfunc)0, /* tp_call */
2124  (reprfunc)SwigPyPacked_str, /* tp_str */
2125  PyObject_GenericGetAttr, /* tp_getattro */
2126  0, /* tp_setattro */
2127  0, /* tp_as_buffer */
2128  Py_TPFLAGS_DEFAULT, /* tp_flags */
2129  swigpacked_doc, /* tp_doc */
2130  0, /* tp_traverse */
2131  0, /* tp_clear */
2132  0, /* tp_richcompare */
2133  0, /* tp_weaklistoffset */
2134 #if PY_VERSION_HEX >= 0x02020000
2135  0, /* tp_iter */
2136  0, /* tp_iternext */
2137  0, /* tp_methods */
2138  0, /* tp_members */
2139  0, /* tp_getset */
2140  0, /* tp_base */
2141  0, /* tp_dict */
2142  0, /* tp_descr_get */
2143  0, /* tp_descr_set */
2144  0, /* tp_dictoffset */
2145  0, /* tp_init */
2146  0, /* tp_alloc */
2147  0, /* tp_new */
2148  0, /* tp_free */
2149  0, /* tp_is_gc */
2150  0, /* tp_bases */
2151  0, /* tp_mro */
2152  0, /* tp_cache */
2153  0, /* tp_subclasses */
2154  0, /* tp_weaklist */
2155 #endif
2156 #if PY_VERSION_HEX >= 0x02030000
2157  0, /* tp_del */
2158 #endif
2159 #if PY_VERSION_HEX >= 0x02060000
2160  0, /* tp_version_tag */
2161 #endif
2162 #if PY_VERSION_HEX >= 0x03040000
2163  0, /* tp_finalize */
2164 #endif
2165 #ifdef COUNT_ALLOCS
2166  0, /* tp_allocs */
2167  0, /* tp_frees */
2168  0, /* tp_maxalloc */
2169 #if PY_VERSION_HEX >= 0x02050000
2170  0, /* tp_prev */
2171 #endif
2172  0 /* tp_next */
2173 #endif
2174  };
2175  swigpypacked_type = tmp;
2176  type_init = 1;
2177 #if PY_VERSION_HEX < 0x02020000
2178  swigpypacked_type.ob_type = &PyType_Type;
2179 #else
2180  if (PyType_Ready(&swigpypacked_type) < 0)
2181  return NULL;
2182 #endif
2183  }
2184  return &swigpypacked_type;
2185 }
2186 
2187 SWIGRUNTIME PyObject *
2188 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2189 {
2190  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2191  if (sobj) {
2192  void *pack = malloc(size);
2193  if (pack) {
2194  memcpy(pack, ptr, size);
2195  sobj->pack = pack;
2196  sobj->ty = ty;
2197  sobj->size = size;
2198  } else {
2199  PyObject_DEL((PyObject *) sobj);
2200  sobj = 0;
2201  }
2202  }
2203  return (PyObject *) sobj;
2204 }
2205 
2207 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2208 {
2209  if (SwigPyPacked_Check(obj)) {
2210  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2211  if (sobj->size != size) return 0;
2212  memcpy(ptr, sobj->pack, size);
2213  return sobj->ty;
2214  } else {
2215  return 0;
2216  }
2217 }
2218 
2219 /* -----------------------------------------------------------------------------
2220  * pointers/data manipulation
2221  * ----------------------------------------------------------------------------- */
2222 
2223 SWIGRUNTIMEINLINE PyObject *
2225 {
2226  return SWIG_Python_str_FromChar("this");
2227 }
2228 
2229 static PyObject *swig_this = NULL;
2230 
2231 SWIGRUNTIME PyObject *
2233 {
2234  if (swig_this == NULL)
2235  swig_this = _SWIG_This();
2236  return swig_this;
2237 }
2238 
2239 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2240 
2241 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2242 #if PY_VERSION_HEX>=0x03000000
2243 #define SWIG_PYTHON_SLOW_GETSET_THIS
2244 #endif
2245 
2247 SWIG_Python_GetSwigThis(PyObject *pyobj)
2248 {
2249  PyObject *obj;
2250 
2251  if (SwigPyObject_Check(pyobj))
2252  return (SwigPyObject *) pyobj;
2253 
2254 #ifdef SWIGPYTHON_BUILTIN
2255  (void)obj;
2256 # ifdef PyWeakref_CheckProxy
2257  if (PyWeakref_CheckProxy(pyobj)) {
2258  pyobj = PyWeakref_GET_OBJECT(pyobj);
2259  if (pyobj && SwigPyObject_Check(pyobj))
2260  return (SwigPyObject*) pyobj;
2261  }
2262 # endif
2263  return NULL;
2264 #else
2265 
2266  obj = 0;
2267 
2268 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2269  if (PyInstance_Check(pyobj)) {
2270  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2271  } else {
2272  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2273  if (dictptr != NULL) {
2274  PyObject *dict = *dictptr;
2275  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2276  } else {
2277 #ifdef PyWeakref_CheckProxy
2278  if (PyWeakref_CheckProxy(pyobj)) {
2279  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2280  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2281  }
2282 #endif
2283  obj = PyObject_GetAttr(pyobj,SWIG_This());
2284  if (obj) {
2285  Py_DECREF(obj);
2286  } else {
2287  if (PyErr_Occurred()) PyErr_Clear();
2288  return 0;
2289  }
2290  }
2291  }
2292 #else
2293  obj = PyObject_GetAttr(pyobj,SWIG_This());
2294  if (obj) {
2295  Py_DECREF(obj);
2296  } else {
2297  if (PyErr_Occurred()) PyErr_Clear();
2298  return 0;
2299  }
2300 #endif
2301  if (obj && !SwigPyObject_Check(obj)) {
2302  /* a PyObject is called 'this', try to get the 'real this'
2303  SwigPyObject from it */
2304  return SWIG_Python_GetSwigThis(obj);
2305  }
2306  return (SwigPyObject *)obj;
2307 #endif
2308 }
2309 
2310 /* Acquire a pointer value */
2311 
2312 SWIGRUNTIME int
2313 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2314  if (own == SWIG_POINTER_OWN) {
2316  if (sobj) {
2317  int oldown = sobj->own;
2318  sobj->own = own;
2319  return oldown;
2320  }
2321  }
2322  return 0;
2323 }
2324 
2325 /* Convert a pointer value */
2326 
2327 SWIGRUNTIME int
2328 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2329  int res;
2330  SwigPyObject *sobj;
2331  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2332 
2333  if (!obj)
2334  return SWIG_ERROR;
2335  if (obj == Py_None && !implicit_conv) {
2336  if (ptr)
2337  *ptr = 0;
2338  return SWIG_OK;
2339  }
2340 
2341  res = SWIG_ERROR;
2342 
2343  sobj = SWIG_Python_GetSwigThis(obj);
2344  if (own)
2345  *own = 0;
2346  while (sobj) {
2347  void *vptr = sobj->ptr;
2348  if (ty) {
2349  swig_type_info *to = sobj->ty;
2350  if (to == ty) {
2351  /* no type cast needed */
2352  if (ptr) *ptr = vptr;
2353  break;
2354  } else {
2355  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2356  if (!tc) {
2357  sobj = (SwigPyObject *)sobj->next;
2358  } else {
2359  if (ptr) {
2360  int newmemory = 0;
2361  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2362  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2363  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2364  if (own)
2365  *own = *own | SWIG_CAST_NEW_MEMORY;
2366  }
2367  }
2368  break;
2369  }
2370  }
2371  } else {
2372  if (ptr) *ptr = vptr;
2373  break;
2374  }
2375  }
2376  if (sobj) {
2377  if (own)
2378  *own = *own | sobj->own;
2379  if (flags & SWIG_POINTER_DISOWN) {
2380  sobj->own = 0;
2381  }
2382  res = SWIG_OK;
2383  } else {
2384  if (implicit_conv) {
2385  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2386  if (data && !data->implicitconv) {
2387  PyObject *klass = data->klass;
2388  if (klass) {
2389  PyObject *impconv;
2390  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2391  impconv = SWIG_Python_CallFunctor(klass, obj);
2392  data->implicitconv = 0;
2393  if (PyErr_Occurred()) {
2394  PyErr_Clear();
2395  impconv = 0;
2396  }
2397  if (impconv) {
2398  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2399  if (iobj) {
2400  void *vptr;
2401  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2402  if (SWIG_IsOK(res)) {
2403  if (ptr) {
2404  *ptr = vptr;
2405  /* transfer the ownership to 'ptr' */
2406  iobj->own = 0;
2407  res = SWIG_AddCast(res);
2408  res = SWIG_AddNewMask(res);
2409  } else {
2410  res = SWIG_AddCast(res);
2411  }
2412  }
2413  }
2414  Py_DECREF(impconv);
2415  }
2416  }
2417  }
2418  }
2419  if (!SWIG_IsOK(res) && obj == Py_None) {
2420  if (ptr)
2421  *ptr = 0;
2422  if (PyErr_Occurred())
2423  PyErr_Clear();
2424  res = SWIG_OK;
2425  }
2426  }
2427  return res;
2428 }
2429 
2430 /* Convert a function ptr value */
2431 
2432 SWIGRUNTIME int
2433 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2434  if (!PyCFunction_Check(obj)) {
2435  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2436  } else {
2437  void *vptr = 0;
2438  swig_cast_info *tc;
2439 
2440  /* here we get the method pointer for callbacks */
2441  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2442  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2443  if (desc)
2444  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2445  if (!desc)
2446  return SWIG_ERROR;
2447  tc = SWIG_TypeCheck(desc,ty);
2448  if (tc) {
2449  int newmemory = 0;
2450  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2451  assert(!newmemory); /* newmemory handling not yet implemented */
2452  } else {
2453  return SWIG_ERROR;
2454  }
2455  return SWIG_OK;
2456  }
2457 }
2458 
2459 /* Convert a packed value value */
2460 
2461 SWIGRUNTIME int
2462 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2463  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2464  if (!to) return SWIG_ERROR;
2465  if (ty) {
2466  if (to != ty) {
2467  /* check type cast? */
2468  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2469  if (!tc) return SWIG_ERROR;
2470  }
2471  }
2472  return SWIG_OK;
2473 }
2474 
2475 /* -----------------------------------------------------------------------------
2476  * Create a new pointer object
2477  * ----------------------------------------------------------------------------- */
2478 
2479 /*
2480  Create a new instance object, without calling __init__, and set the
2481  'this' attribute.
2482 */
2483 
2484 SWIGRUNTIME PyObject*
2486 {
2487 #if (PY_VERSION_HEX >= 0x02020000)
2488  PyObject *inst = 0;
2489  PyObject *newraw = data->newraw;
2490  if (newraw) {
2491  inst = PyObject_Call(newraw, data->newargs, NULL);
2492  if (inst) {
2493 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495  if (dictptr != NULL) {
2496  PyObject *dict = *dictptr;
2497  if (dict == NULL) {
2498  dict = PyDict_New();
2499  *dictptr = dict;
2500  PyDict_SetItem(dict, SWIG_This(), swig_this);
2501  }
2502  }
2503 #else
2504  PyObject *key = SWIG_This();
2505  PyObject_SetAttr(inst, key, swig_this);
2506 #endif
2507  }
2508  } else {
2509 #if PY_VERSION_HEX >= 0x03000000
2510  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2511  if (inst) {
2512  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2513  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2514  }
2515 #else
2516  PyObject *dict = PyDict_New();
2517  if (dict) {
2518  PyDict_SetItem(dict, SWIG_This(), swig_this);
2519  inst = PyInstance_NewRaw(data->newargs, dict);
2520  Py_DECREF(dict);
2521  }
2522 #endif
2523  }
2524  return inst;
2525 #else
2526 #if (PY_VERSION_HEX >= 0x02010000)
2527  PyObject *inst = 0;
2528  PyObject *dict = PyDict_New();
2529  if (dict) {
2530  PyDict_SetItem(dict, SWIG_This(), swig_this);
2531  inst = PyInstance_NewRaw(data->newargs, dict);
2532  Py_DECREF(dict);
2533  }
2534  return (PyObject *) inst;
2535 #else
2536  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2537  if (inst == NULL) {
2538  return NULL;
2539  }
2540  inst->in_class = (PyClassObject *)data->newargs;
2541  Py_INCREF(inst->in_class);
2542  inst->in_dict = PyDict_New();
2543  if (inst->in_dict == NULL) {
2544  Py_DECREF(inst);
2545  return NULL;
2546  }
2547 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2548  inst->in_weakreflist = NULL;
2549 #endif
2550 #ifdef Py_TPFLAGS_GC
2551  PyObject_GC_Init(inst);
2552 #endif
2553  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2554  return (PyObject *) inst;
2555 #endif
2556 #endif
2557 }
2558 
2559 SWIGRUNTIME void
2560 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2561 {
2562  PyObject *dict;
2563 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2564  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2565  if (dictptr != NULL) {
2566  dict = *dictptr;
2567  if (dict == NULL) {
2568  dict = PyDict_New();
2569  *dictptr = dict;
2570  }
2571  PyDict_SetItem(dict, SWIG_This(), swig_this);
2572  return;
2573  }
2574 #endif
2575  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2576  PyDict_SetItem(dict, SWIG_This(), swig_this);
2577  Py_DECREF(dict);
2578 }
2579 
2580 
2581 SWIGINTERN PyObject *
2583  PyObject *obj[2];
2584  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2585  return NULL;
2586  } else {
2587  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2588  if (sthis) {
2589  SwigPyObject_append((PyObject*) sthis, obj[1]);
2590  } else {
2591  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2592  }
2593  return SWIG_Py_Void();
2594  }
2595 }
2596 
2597 /* Create a new pointer object */
2598 
2599 SWIGRUNTIME PyObject *
2600 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2601  SwigPyClientData *clientdata;
2602  PyObject * robj;
2603  int own;
2604 
2605  if (!ptr)
2606  return SWIG_Py_Void();
2607 
2608  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2609  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2610  if (clientdata && clientdata->pytype) {
2611  SwigPyObject *newobj;
2612  if (flags & SWIG_BUILTIN_TP_INIT) {
2613  newobj = (SwigPyObject*) self;
2614  if (newobj->ptr) {
2615  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2616  while (newobj->next)
2617  newobj = (SwigPyObject *) newobj->next;
2618  newobj->next = next_self;
2619  newobj = (SwigPyObject *)next_self;
2620 #ifdef SWIGPYTHON_BUILTIN
2621  newobj->dict = 0;
2622 #endif
2623  }
2624  } else {
2625  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2626 #ifdef SWIGPYTHON_BUILTIN
2627  newobj->dict = 0;
2628 #endif
2629  }
2630  if (newobj) {
2631  newobj->ptr = ptr;
2632  newobj->ty = type;
2633  newobj->own = own;
2634  newobj->next = 0;
2635  return (PyObject*) newobj;
2636  }
2637  return SWIG_Py_Void();
2638  }
2639 
2640  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2641 
2642  robj = SwigPyObject_New(ptr, type, own);
2643  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2644  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2645  Py_DECREF(robj);
2646  robj = inst;
2647  }
2648  return robj;
2649 }
2650 
2651 /* Create a new packed object */
2652 
2653 SWIGRUNTIMEINLINE PyObject *
2654 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2655  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2656 }
2657 
2658 /* -----------------------------------------------------------------------------*
2659  * Get type list
2660  * -----------------------------------------------------------------------------*/
2661 
2662 #ifdef SWIG_LINK_RUNTIME
2663 void *SWIG_ReturnGlobalTypeList(void *);
2664 #endif
2665 
2668  static void *type_pointer = (void *)0;
2669  /* first check if module already created */
2670  if (!type_pointer) {
2671 #ifdef SWIG_LINK_RUNTIME
2672  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2673 #else
2674 # ifdef SWIGPY_USE_CAPSULE
2675  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2676 # else
2677  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2678  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2679 # endif
2680  if (PyErr_Occurred()) {
2681  PyErr_Clear();
2682  type_pointer = (void *)0;
2683  }
2684 #endif
2685  }
2686  return (swig_module_info *) type_pointer;
2687 }
2688 
2689 #if PY_MAJOR_VERSION < 2
2690 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2691  is copied out of Python/modsupport.c in python version 2.3.4 */
2692 SWIGINTERN int
2693 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2694 {
2695  PyObject *dict;
2696  if (!PyModule_Check(m)) {
2697  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2698  return SWIG_ERROR;
2699  }
2700  if (!o) {
2701  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2702  return SWIG_ERROR;
2703  }
2704 
2705  dict = PyModule_GetDict(m);
2706  if (dict == NULL) {
2707  /* Internal error -- modules must have a dict! */
2708  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2709  PyModule_GetName(m));
2710  return SWIG_ERROR;
2711  }
2712  if (PyDict_SetItemString(dict, name, o))
2713  return SWIG_ERROR;
2714  Py_DECREF(o);
2715  return SWIG_OK;
2716 }
2717 #endif
2718 
2719 SWIGRUNTIME void
2720 #ifdef SWIGPY_USE_CAPSULE
2721 SWIG_Python_DestroyModule(PyObject *obj)
2722 #else
2724 #endif
2725 {
2726 #ifdef SWIGPY_USE_CAPSULE
2727  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2728 #else
2730 #endif
2731  swig_type_info **types = swig_module->types;
2732  size_t i;
2733  for (i =0; i < swig_module->size; ++i) {
2734  swig_type_info *ty = types[i];
2735  if (ty->owndata) {
2737  if (data) SwigPyClientData_Del(data);
2738  }
2739  }
2740  Py_DECREF(SWIG_This());
2741  swig_this = NULL;
2742 }
2743 
2744 SWIGRUNTIME void
2746 #if PY_VERSION_HEX >= 0x03000000
2747  /* Add a dummy module object into sys.modules */
2748  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2749 #else
2750  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2751  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2752 #endif
2753 #ifdef SWIGPY_USE_CAPSULE
2754  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2755  if (pointer && module) {
2756  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2757  } else {
2758  Py_XDECREF(pointer);
2759  }
2760 #else
2761  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2762  if (pointer && module) {
2763  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2764  } else {
2765  Py_XDECREF(pointer);
2766  }
2767 #endif
2768 }
2769 
2770 /* The python cached type query */
2771 SWIGRUNTIME PyObject *
2773  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2774  return cache;
2775 }
2776 
2778 SWIG_Python_TypeQuery(const char *type)
2779 {
2780  PyObject *cache = SWIG_Python_TypeCache();
2781  PyObject *key = SWIG_Python_str_FromChar(type);
2782  PyObject *obj = PyDict_GetItem(cache, key);
2783  swig_type_info *descriptor;
2784  if (obj) {
2785 #ifdef SWIGPY_USE_CAPSULE
2786  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2787 #else
2788  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2789 #endif
2790  } else {
2792  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2793  if (descriptor) {
2794 #ifdef SWIGPY_USE_CAPSULE
2795  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2796 #else
2797  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2798 #endif
2799  PyDict_SetItem(cache, key, obj);
2800  Py_DECREF(obj);
2801  }
2802  }
2803  Py_DECREF(key);
2804  return descriptor;
2805 }
2806 
2807 /*
2808  For backward compatibility only
2809 */
2810 #define SWIG_POINTER_EXCEPTION 0
2811 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2812 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2813 
2814 SWIGRUNTIME int
2815 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2816 {
2817  if (PyErr_Occurred()) {
2818  PyObject *type = 0;
2819  PyObject *value = 0;
2820  PyObject *traceback = 0;
2821  PyErr_Fetch(&type, &value, &traceback);
2822  if (value) {
2823  PyObject *old_str = PyObject_Str(value);
2824  const char *tmp = SWIG_Python_str_AsChar(old_str);
2825  if (!tmp)
2826  tmp = "Invalid error message";
2827  Py_XINCREF(type);
2828  PyErr_Clear();
2829  if (infront) {
2830  PyErr_Format(type, "%s %s", mesg, tmp);
2831  } else {
2832  PyErr_Format(type, "%s %s", tmp, mesg);
2833  }
2835  Py_DECREF(old_str);
2836  }
2837  return 1;
2838  } else {
2839  return 0;
2840  }
2841 }
2842 
2843 SWIGRUNTIME int
2845 {
2846  if (PyErr_Occurred()) {
2847  /* add information about failing argument */
2848  char mesg[256];
2849  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2850  return SWIG_Python_AddErrMesg(mesg, 1);
2851  } else {
2852  return 0;
2853  }
2854 }
2855 
2856 SWIGRUNTIMEINLINE const char *
2857 SwigPyObject_GetDesc(PyObject *self)
2858 {
2859  SwigPyObject *v = (SwigPyObject *)self;
2860  swig_type_info *ty = v ? v->ty : 0;
2861  return ty ? ty->str : "";
2862 }
2863 
2864 SWIGRUNTIME void
2865 SWIG_Python_TypeError(const char *type, PyObject *obj)
2866 {
2867  if (type) {
2868 #if defined(SWIG_COBJECT_TYPES)
2869  if (obj && SwigPyObject_Check(obj)) {
2870  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2871  if (otype) {
2872  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2873  type, otype);
2874  return;
2875  }
2876  } else
2877 #endif
2878  {
2879  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2880  if (otype) {
2881  PyObject *str = PyObject_Str(obj);
2882  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2883  if (cstr) {
2884  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2885  type, otype, cstr);
2887  } else {
2888  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2889  type, otype);
2890  }
2891  Py_XDECREF(str);
2892  return;
2893  }
2894  }
2895  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2896  } else {
2897  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2898  }
2899 }
2900 
2901 
2902 /* Convert a pointer value, signal an exception on a type mismatch */
2903 SWIGRUNTIME void *
2904 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2905  void *result;
2906  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2907  PyErr_Clear();
2908 #if SWIG_POINTER_EXCEPTION
2909  if (flags) {
2911  SWIG_Python_ArgFail(argnum);
2912  }
2913 #endif
2914  }
2915  return result;
2916 }
2917 
2918 #ifdef SWIGPYTHON_BUILTIN
2919 SWIGRUNTIME int
2920 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2921  PyTypeObject *tp = obj->ob_type;
2922  PyObject *descr;
2923  PyObject *encoded_name;
2924  descrsetfunc f;
2925  int res = -1;
2926 
2927 # ifdef Py_USING_UNICODE
2928  if (PyString_Check(name)) {
2929  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2930  if (!name)
2931  return -1;
2932  } else if (!PyUnicode_Check(name))
2933 # else
2934  if (!PyString_Check(name))
2935 # endif
2936  {
2937  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2938  return -1;
2939  } else {
2940  Py_INCREF(name);
2941  }
2942 
2943  if (!tp->tp_dict) {
2944  if (PyType_Ready(tp) < 0)
2945  goto done;
2946  }
2947 
2948  descr = _PyType_Lookup(tp, name);
2949  f = NULL;
2950  if (descr != NULL)
2951  f = descr->ob_type->tp_descr_set;
2952  if (!f) {
2953  if (PyString_Check(name)) {
2954  encoded_name = name;
2955  Py_INCREF(name);
2956  } else {
2957  encoded_name = PyUnicode_AsUTF8String(name);
2958  if (!encoded_name)
2959  return -1;
2960  }
2961  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2962  Py_DECREF(encoded_name);
2963  } else {
2964  res = f(descr, obj, value);
2965  }
2966 
2967  done:
2968  Py_DECREF(name);
2969  return res;
2970 }
2971 #endif
2972 
2973 
2974 #ifdef __cplusplus
2975 }
2976 #endif
2977 
2978 
2979 
2980 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2981 
2982 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2983 
2984 
2985 
2986 /* -------- TYPES TABLE (BEGIN) -------- */
2987 
2988 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2989 #define SWIGTYPE_p_PLcGrid swig_types[1]
2990 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2991 #define SWIGTYPE_p_char swig_types[3]
2992 #define SWIGTYPE_p_double swig_types[4]
2993 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2994 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2995 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2996 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2997 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2998 #define SWIGTYPE_p_int swig_types[10]
2999 #define SWIGTYPE_p_p_char swig_types[11]
3000 #define SWIGTYPE_p_p_double swig_types[12]
3001 #define SWIGTYPE_p_unsigned_int swig_types[13]
3003 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3004 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3005 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3006 
3007 /* -------- TYPES TABLE (END) -------- */
3008 
3009 #if (PY_VERSION_HEX <= 0x02000000)
3010 # if !defined(SWIG_PYTHON_CLASSIC)
3011 # error "This python version requires swig to be run with the '-classic' option"
3012 # endif
3013 #endif
3014 
3015 /*-----------------------------------------------
3016  @(target):= _plplotc.so
3017  ------------------------------------------------*/
3018 #if PY_VERSION_HEX >= 0x03000000
3019 # define SWIG_init PyInit__plplotc
3020 
3021 #else
3022 # define SWIG_init init_plplotc
3023 
3024 #endif
3025 #define SWIG_name "_plplotc"
3026 
3027 #define SWIGVERSION 0x030012
3028 #define SWIG_VERSION SWIGVERSION
3029 
3030 
3031 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3032 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3033 
3034 
3035 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3036 #include <arrayobject.h>
3037 #include "plplot.h"
3038 #include "plplotP.h"
3039 
3040 #define NPY_PLINT NPY_INT32
3041 
3042 #ifdef PL_DOUBLE
3043 #define NPY_PLFLT NPY_FLOAT64
3044 #else
3045 #define NPY_PLFLT NPY_FLOAT32
3046 #endif
3047 
3048 // python-1.5 compatibility mode?
3049 #if !defined ( PySequence_Fast_GET_ITEM )
3050  #define PySequence_Fast_GET_ITEM PySequence_GetItem
3051 #endif
3052 #define PySequence_Size PySequence_Length
3053 
3054 
3055  static PLINT Alen = 0;
3056  static PLINT Xlen = 0, Ylen = 0;
3057 
3058 
3059 SWIGINTERN int
3060 SWIG_AsVal_double (PyObject *obj, double *val)
3061 {
3062  int res = SWIG_TypeError;
3063  if (PyFloat_Check(obj)) {
3064  if (val) *val = PyFloat_AsDouble(obj);
3065  return SWIG_OK;
3066 #if PY_VERSION_HEX < 0x03000000
3067  } else if (PyInt_Check(obj)) {
3068  if (val) *val = (double) PyInt_AsLong(obj);
3069  return SWIG_OK;
3070 #endif
3071  } else if (PyLong_Check(obj)) {
3072  double v = PyLong_AsDouble(obj);
3073  if (!PyErr_Occurred()) {
3074  if (val) *val = v;
3075  return SWIG_OK;
3076  } else {
3077  PyErr_Clear();
3078  }
3079  }
3080 #ifdef SWIG_PYTHON_CAST_MODE
3081  {
3082  int dispatch = 0;
3083  double d = PyFloat_AsDouble(obj);
3084  if (!PyErr_Occurred()) {
3085  if (val) *val = d;
3086  return SWIG_AddCast(SWIG_OK);
3087  } else {
3088  PyErr_Clear();
3089  }
3090  if (!dispatch) {
3091  long v = PyLong_AsLong(obj);
3092  if (!PyErr_Occurred()) {
3093  if (val) *val = v;
3095  } else {
3096  PyErr_Clear();
3097  }
3098  }
3099  }
3100 #endif
3101  return res;
3102 }
3103 
3104 
3105  #define SWIG_From_double PyFloat_FromDouble
3106 
3107 
3108  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3109  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3110  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3111  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3112  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3114  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3115 
3116 
3117 SWIGINTERNINLINE PyObject*
3119 {
3120  return PyInt_FromLong((long) value);
3121 }
3122 
3123 
3124 #include <limits.h>
3125 #if !defined(SWIG_NO_LLONG_MAX)
3126 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3127 # define LLONG_MAX __LONG_LONG_MAX__
3128 # define LLONG_MIN (-LLONG_MAX - 1LL)
3129 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3130 # endif
3131 #endif
3132 
3133 
3134 #include <float.h>
3135 
3136 
3137 #include <math.h>
3138 
3139 
3140 SWIGINTERNINLINE int
3141 SWIG_CanCastAsInteger(double *d, double min, double max) {
3142  double x = *d;
3143  if ((min <= x && x <= max)) {
3144  double fx = floor(x);
3145  double cx = ceil(x);
3146  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3147  if ((errno == EDOM) || (errno == ERANGE)) {
3148  errno = 0;
3149  } else {
3150  double summ, reps, diff;
3151  if (rd < x) {
3152  diff = x - rd;
3153  } else if (rd > x) {
3154  diff = rd - x;
3155  } else {
3156  return 1;
3157  }
3158  summ = rd + x;
3159  reps = diff/summ;
3160  if (reps < 8*DBL_EPSILON) {
3161  *d = rd;
3162  return 1;
3163  }
3164  }
3165  }
3166  return 0;
3167 }
3168 
3169 
3170 SWIGINTERN int
3171 SWIG_AsVal_long (PyObject *obj, long* val)
3172 {
3173 #if PY_VERSION_HEX < 0x03000000
3174  if (PyInt_Check(obj)) {
3175  if (val) *val = PyInt_AsLong(obj);
3176  return SWIG_OK;
3177  } else
3178 #endif
3179  if (PyLong_Check(obj)) {
3180  long v = PyLong_AsLong(obj);
3181  if (!PyErr_Occurred()) {
3182  if (val) *val = v;
3183  return SWIG_OK;
3184  } else {
3185  PyErr_Clear();
3186  return SWIG_OverflowError;
3187  }
3188  }
3189 #ifdef SWIG_PYTHON_CAST_MODE
3190  {
3191  int dispatch = 0;
3192  long v = PyInt_AsLong(obj);
3193  if (!PyErr_Occurred()) {
3194  if (val) *val = v;
3195  return SWIG_AddCast(SWIG_OK);
3196  } else {
3197  PyErr_Clear();
3198  }
3199  if (!dispatch) {
3200  double d;
3201  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3202  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3203  if (val) *val = (long)(d);
3204  return res;
3205  }
3206  }
3207  }
3208 #endif
3209  return SWIG_TypeError;
3210 }
3211 
3212 
3213 SWIGINTERN int
3214 SWIG_AsVal_int (PyObject * obj, int *val)
3215 {
3216  long v;
3217  int res = SWIG_AsVal_long (obj, &v);
3218  if (SWIG_IsOK(res)) {
3219  if ((v < INT_MIN || v > INT_MAX)) {
3220  return SWIG_OverflowError;
3221  } else {
3222  if (val) *val = (int)(v);
3223  }
3224  }
3225  return res;
3226 }
3227 
3228 
3229 SWIGINTERN int
3230 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3231 {
3232 #if PY_VERSION_HEX < 0x03000000
3233  if (PyInt_Check(obj)) {
3234  long v = PyInt_AsLong(obj);
3235  if (v >= 0) {
3236  if (val) *val = v;
3237  return SWIG_OK;
3238  } else {
3239  return SWIG_OverflowError;
3240  }
3241  } else
3242 #endif
3243  if (PyLong_Check(obj)) {
3244  unsigned long v = PyLong_AsUnsignedLong(obj);
3245  if (!PyErr_Occurred()) {
3246  if (val) *val = v;
3247  return SWIG_OK;
3248  } else {
3249  PyErr_Clear();
3250  return SWIG_OverflowError;
3251  }
3252  }
3253 #ifdef SWIG_PYTHON_CAST_MODE
3254  {
3255  int dispatch = 0;
3256  unsigned long v = PyLong_AsUnsignedLong(obj);
3257  if (!PyErr_Occurred()) {
3258  if (val) *val = v;
3259  return SWIG_AddCast(SWIG_OK);
3260  } else {
3261  PyErr_Clear();
3262  }
3263  if (!dispatch) {
3264  double d;
3265  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3266  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3267  if (val) *val = (unsigned long)(d);
3268  return res;
3269  }
3270  }
3271  }
3272 #endif
3273  return SWIG_TypeError;
3274 }
3275 
3276 
3277 SWIGINTERN int
3278 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3279 {
3280  unsigned long v;
3281  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3282  if (SWIG_IsOK(res)) {
3283  if ((v > UINT_MAX)) {
3284  return SWIG_OverflowError;
3285  } else {
3286  if (val) *val = (unsigned int)(v);
3287  }
3288  }
3289  return res;
3290 }
3291 
3292 
3293 SWIGINTERNINLINE PyObject*
3295 {
3296  return PyInt_FromSize_t((size_t) value);
3297 }
3298 
3299 
3302 {
3303  static int init = 0;
3304  static swig_type_info* info = 0;
3305  if (!init) {
3306  info = SWIG_TypeQuery("_p_char");
3307  init = 1;
3308  }
3309  return info;
3310 }
3311 
3312 
3313 SWIGINTERN int
3314 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3315 {
3316 #if PY_VERSION_HEX>=0x03000000
3317 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3318  if (PyBytes_Check(obj))
3319 #else
3320  if (PyUnicode_Check(obj))
3321 #endif
3322 #else
3323  if (PyString_Check(obj))
3324 #endif
3325  {
3326  char *cstr; Py_ssize_t len;
3327  int ret = SWIG_OK;
3328 #if PY_VERSION_HEX>=0x03000000
3329 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3330  if (!alloc && cptr) {
3331  /* We can't allow converting without allocation, since the internal
3332  representation of string in Python 3 is UCS-2/UCS-4 but we require
3333  a UTF-8 representation.
3334  TODO(bhy) More detailed explanation */
3335  return SWIG_RuntimeError;
3336  }
3337  obj = PyUnicode_AsUTF8String(obj);
3338  if (!obj)
3339  return SWIG_TypeError;
3340  if (alloc)
3341  *alloc = SWIG_NEWOBJ;
3342 #endif
3343  PyBytes_AsStringAndSize(obj, &cstr, &len);
3344 #else
3345  PyString_AsStringAndSize(obj, &cstr, &len);
3346 #endif
3347  if (cptr) {
3348  if (alloc) {
3349  /*
3350  In python the user should not be able to modify the inner
3351  string representation. To warranty that, if you define
3352  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3353  buffer is always returned.
3354 
3355  The default behavior is just to return the pointer value,
3356  so, be careful.
3357  */
3358 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3359  if (*alloc != SWIG_OLDOBJ)
3360 #else
3361  if (*alloc == SWIG_NEWOBJ)
3362 #endif
3363  {
3364  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3365  *alloc = SWIG_NEWOBJ;
3366  } else {
3367  *cptr = cstr;
3368  *alloc = SWIG_OLDOBJ;
3369  }
3370  } else {
3371 #if PY_VERSION_HEX>=0x03000000
3372 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3373  *cptr = PyBytes_AsString(obj);
3374 #else
3375  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3376 #endif
3377 #else
3378  *cptr = SWIG_Python_str_AsChar(obj);
3379  if (!*cptr)
3380  ret = SWIG_TypeError;
3381 #endif
3382  }
3383  }
3384  if (psize) *psize = len + 1;
3385 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3386  Py_XDECREF(obj);
3387 #endif
3388  return ret;
3389  } else {
3390 #if defined(SWIG_PYTHON_2_UNICODE)
3391 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3392 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3393 #endif
3394 #if PY_VERSION_HEX<0x03000000
3395  if (PyUnicode_Check(obj)) {
3396  char *cstr; Py_ssize_t len;
3397  if (!alloc && cptr) {
3398  return SWIG_RuntimeError;
3399  }
3400  obj = PyUnicode_AsUTF8String(obj);
3401  if (!obj)
3402  return SWIG_TypeError;
3403  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3404  if (cptr) {
3405  if (alloc) *alloc = SWIG_NEWOBJ;
3406  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3407  }
3408  if (psize) *psize = len + 1;
3409 
3410  Py_XDECREF(obj);
3411  return SWIG_OK;
3412  } else {
3413  Py_XDECREF(obj);
3414  }
3415  }
3416 #endif
3417 #endif
3418 
3419  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3420  if (pchar_descriptor) {
3421  void* vptr = 0;
3422  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3423  if (cptr) *cptr = (char *) vptr;
3424  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3425  if (alloc) *alloc = SWIG_OLDOBJ;
3426  return SWIG_OK;
3427  }
3428  }
3429  }
3430  return SWIG_TypeError;
3431 }
3432 
3433 
3434 SWIGINTERN int
3435 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3436 {
3437  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3438  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3439  if (SWIG_IsOK(res)) {
3440  /* special case of single char conversion when we don't need space for NUL */
3441  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3442  if (csize <= size) {
3443  if (val) {
3444  if (csize) memcpy(val, cptr, csize*sizeof(char));
3445  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3446  }
3447  if (alloc == SWIG_NEWOBJ) {
3448  free((char*)cptr);
3449  res = SWIG_DelNewMask(res);
3450  }
3451  return res;
3452  }
3453  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3454  }
3455  return SWIG_TypeError;
3456 }
3457 
3458 
3459 SWIGINTERNINLINE PyObject *
3460 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3461 {
3462  if (carray) {
3463  if (size > INT_MAX) {
3464  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3465  return pchar_descriptor ?
3466  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3467  } else {
3468 #if PY_VERSION_HEX >= 0x03000000
3469 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3470  return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3471 #else
3472 #if PY_VERSION_HEX >= 0x03010000
3473  return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3474 #else
3475  return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3476 #endif
3477 #endif
3478 #else
3479  return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3480 #endif
3481  }
3482  } else {
3483  return SWIG_Py_Void();
3484  }
3485 }
3486 
3487 
3488 SWIGINTERN size_t
3489 SWIG_strnlen(const char* s, size_t maxlen)
3490 {
3491  const char *p;
3492  for (p = s; maxlen-- && *p; p++)
3493  ;
3494  return p - s;
3495 }
3496 
3497 
3498 
3499 
3500 
3501 #define t_output_helper SWIG_Python_AppendOutput
3502 
3503 
3504 SWIGINTERN int
3505 SWIG_AsVal_char (PyObject * obj, char *val)
3506 {
3507  int res = SWIG_AsCharArray(obj, val, 1);
3508  if (!SWIG_IsOK(res)) {
3509  long v;
3510  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3511  if (SWIG_IsOK(res)) {
3512  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3513  if (val) *val = (char)(v);
3514  } else {
3515  res = SWIG_OverflowError;
3516  }
3517  }
3518  }
3519  return res;
3520 }
3521 
3522 #ifdef __cplusplus
3523 extern "C" {
3524 #endif
3525 
3526  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3527 
3528 // some really twisted stuff to allow calling a single precision library from python
3529  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3530  {
3531  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3532  mindims, maxdims );
3533  if ( !tmp )
3534  {
3535  // could be an incoming long array which can't be "safely" converted, do it anyway
3536  if ( PyArray_Check( in ) )
3537  {
3538  PyErr_Clear();
3539  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3540  }
3541  }
3542  return tmp;
3543  }
3544 
3545 
3546 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3547 
3548 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3549  PyObject *resultobj = 0;
3550  PLFLT arg1 ;
3551  PLFLT arg2 ;
3552  PLFLT *arg3 = (PLFLT *) 0 ;
3553  PLFLT *arg4 = (PLFLT *) 0 ;
3554  PLPointer arg5 = (PLPointer) 0 ;
3555  double val1 ;
3556  int ecode1 = 0 ;
3557  double val2 ;
3558  int ecode2 = 0 ;
3559  PLFLT temp3 ;
3560  int res3 = SWIG_TMPOBJ ;
3561  PLFLT temp4 ;
3562  int res4 = SWIG_TMPOBJ ;
3563  PyObject * obj0 = 0 ;
3564  PyObject * obj1 = 0 ;
3565 
3566  arg3 = &temp3;
3567  arg4 = &temp4;
3568  {
3569  arg5 = NULL;
3570  }
3571  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3572  ecode1 = SWIG_AsVal_double(obj0, &val1);
3573  if (!SWIG_IsOK(ecode1)) {
3574  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3575  }
3576  arg1 = (PLFLT)(val1);
3577  ecode2 = SWIG_AsVal_double(obj1, &val2);
3578  if (!SWIG_IsOK(ecode2)) {
3579  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3580  }
3581  arg2 = (PLFLT)(val2);
3582  pltr0(arg1,arg2,arg3,arg4,arg5);
3583  resultobj = SWIG_Py_Void();
3584  if (SWIG_IsTmpObj(res3)) {
3585  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3586  } else {
3587  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3588  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3589  }
3590  if (SWIG_IsTmpObj(res4)) {
3591  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3592  } else {
3593  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3594  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3595  }
3596  return resultobj;
3597 fail:
3598  return NULL;
3599 }
3600 
3601 
3602 
3603  PyArrayObject *pltr_xg, *pltr_yg;
3606 
3607  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3608  void cleanup_PLcGrid1( void );
3609  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3610  void cleanup_PLcGrid2( void );
3611 
3612  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3613  {
3614  // fprintf(stderr, "marshal PLcGrid1\n");
3615  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3616  {
3617  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3618  return NULL;
3619  }
3620  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3621  NPY_PLFLT, 1, 1 );
3622  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3623  NPY_PLFLT, 1, 1 );
3624  if ( pltr_xg == 0 || pltr_yg == 0 )
3625  {
3626  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3627  return NULL;
3628  }
3629  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3630  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3631  if ( isimg == 0 )
3632  {
3633  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3634  {
3635  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3636  return NULL;
3637  }
3638  }
3639  else
3640  {
3641  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3642  {
3643  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3644  return NULL;
3645  }
3646  }
3647  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3648  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3649  return &tmpGrid1;
3650  }
3651 
3652  void cleanup_PLcGrid1( void )
3653  {
3654  // fprintf(stderr, "cleanup PLcGrid1\n");
3655  Py_CLEAR( pltr_xg );
3656  Py_CLEAR( pltr_yg );
3657  }
3658 
3659  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3660  {
3661  int i, size;
3662  // fprintf(stderr, "marshal PLcGrid2\n");
3663  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3664  {
3665  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3666  return NULL;
3667  }
3668  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3669  NPY_PLFLT, 2, 2 );
3670  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3671  NPY_PLFLT, 2, 2 );
3672  if ( pltr_xg == 0 || pltr_yg == 0 )
3673  {
3674  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3675  return NULL;
3676  }
3677  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3678  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3679  {
3680  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3681  return NULL;
3682  }
3683  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3684  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3685  if ( isimg == 0 )
3686  {
3687  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3688  {
3689  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3690  return NULL;
3691  }
3692  }
3693  else
3694  {
3695  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3696  {
3697  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3698  return NULL;
3699  }
3700  }
3701  size = tmpGrid2.ny;
3702  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3703  for ( i = 0; i < tmpGrid2.nx; i++ )
3704  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3705  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3706  for ( i = 0; i < tmpGrid2.nx; i++ )
3707  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3708  return &tmpGrid2;
3709  }
3710 
3711  void cleanup_PLcGrid2( void )
3712  {
3713  // fprintf(stderr, "cleanup PLcGrid2\n");
3714  free( tmpGrid2.xg );
3715  free( tmpGrid2.yg );
3716  Py_CLEAR( pltr_xg );
3717  Py_CLEAR( pltr_yg );
3718  }
3719 
3720 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3721  PyObject *resultobj = 0;
3722  PLFLT arg1 ;
3723  PLFLT arg2 ;
3724  PLFLT *arg3 = (PLFLT *) 0 ;
3725  PLFLT *arg4 = (PLFLT *) 0 ;
3726  PLcGrid *arg5 = (PLcGrid *) 0 ;
3727  double val1 ;
3728  int ecode1 = 0 ;
3729  double val2 ;
3730  int ecode2 = 0 ;
3731  PLFLT temp3 ;
3732  int res3 = SWIG_TMPOBJ ;
3733  PLFLT temp4 ;
3734  int res4 = SWIG_TMPOBJ ;
3735  PyObject * obj0 = 0 ;
3736  PyObject * obj1 = 0 ;
3737  PyObject * obj2 = 0 ;
3738 
3739  arg3 = &temp3;
3740  arg4 = &temp4;
3741  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3742  ecode1 = SWIG_AsVal_double(obj0, &val1);
3743  if (!SWIG_IsOK(ecode1)) {
3744  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3745  }
3746  arg1 = (PLFLT)(val1);
3747  ecode2 = SWIG_AsVal_double(obj1, &val2);
3748  if (!SWIG_IsOK(ecode2)) {
3749  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3750  }
3751  arg2 = (PLFLT)(val2);
3752  {
3753  arg5 = marshal_PLcGrid1( obj2, 0 );
3754  if ( !arg5 )
3755  return NULL;
3756  }
3757  pltr1(arg1,arg2,arg3,arg4,arg5);
3758  resultobj = SWIG_Py_Void();
3759  if (SWIG_IsTmpObj(res3)) {
3760  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3761  } else {
3762  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3763  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3764  }
3765  if (SWIG_IsTmpObj(res4)) {
3766  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3767  } else {
3768  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3769  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3770  }
3771  {
3772  cleanup_PLcGrid1();
3773  }
3774  return resultobj;
3775 fail:
3776  {
3777  cleanup_PLcGrid1();
3778  }
3779  return NULL;
3780 }
3781 
3782 
3783 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3784  PyObject *resultobj = 0;
3785  PLFLT arg1 ;
3786  PLFLT arg2 ;
3787  PLFLT *arg3 = (PLFLT *) 0 ;
3788  PLFLT *arg4 = (PLFLT *) 0 ;
3789  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3790  double val1 ;
3791  int ecode1 = 0 ;
3792  double val2 ;
3793  int ecode2 = 0 ;
3794  PLFLT temp3 ;
3795  int res3 = SWIG_TMPOBJ ;
3796  PLFLT temp4 ;
3797  int res4 = SWIG_TMPOBJ ;
3798  PyObject * obj0 = 0 ;
3799  PyObject * obj1 = 0 ;
3800  PyObject * obj2 = 0 ;
3801 
3802  arg3 = &temp3;
3803  arg4 = &temp4;
3804  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3805  ecode1 = SWIG_AsVal_double(obj0, &val1);
3806  if (!SWIG_IsOK(ecode1)) {
3807  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3808  }
3809  arg1 = (PLFLT)(val1);
3810  ecode2 = SWIG_AsVal_double(obj1, &val2);
3811  if (!SWIG_IsOK(ecode2)) {
3812  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3813  }
3814  arg2 = (PLFLT)(val2);
3815  {
3816  arg5 = marshal_PLcGrid2( obj2, 0 );
3817  if ( !arg5 )
3818  return NULL;
3819  }
3820  pltr2(arg1,arg2,arg3,arg4,arg5);
3821  resultobj = SWIG_Py_Void();
3822  if (SWIG_IsTmpObj(res3)) {
3823  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3824  } else {
3825  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3826  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3827  }
3828  if (SWIG_IsTmpObj(res4)) {
3829  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3830  } else {
3831  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3832  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3833  }
3834  {
3835  cleanup_PLcGrid2();
3836  }
3837  return resultobj;
3838 fail:
3839  {
3840  cleanup_PLcGrid2();
3841  }
3842  return NULL;
3843 }
3844 
3845 
3846 
3847  // helper code for handling the callback
3848 #if 0
3849  static PyInterpreterState *save_interp = NULL;
3850 #endif
3852  PyObject* python_pltr = NULL;
3853  PyObject* python_f2eval = NULL;
3854  PyObject* python_ct = NULL;
3855  PyObject* python_mapform = NULL;
3856  PyObject* python_label = NULL;
3857 
3858 #if 0
3859 #define MY_BLOCK_THREADS { \
3860  PyThreadState *prev_state, *new_state; \
3861  /* need to have started a thread at some stage */ \
3862  /* for the following to work */ \
3863  PyEval_AcquireLock(); \
3864  new_state = PyThreadState_New( save_interp ); \
3865  prev_state = PyThreadState_Swap( new_state );
3866 #define MY_UNBLOCK_THREADS \
3867  new_state = PyThreadState_Swap( prev_state ); \
3868  PyThreadState_Clear( new_state ); \
3869  PyEval_ReleaseLock(); \
3870  PyThreadState_Delete( new_state ); \
3871  }
3872 #else
3873 #define MY_BLOCK_THREADS
3874 #define MY_UNBLOCK_THREADS
3875 #endif
3876 
3877 // Function prototypes
3878  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3880  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3881  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3882  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3883  pltr_func marshal_pltr( PyObject* input );
3884  void cleanup_pltr( void );
3885  ct_func marshal_ct( PyObject* input );
3886  void cleanup_ct( void );
3887  mapform_func marshal_mapform( PyObject* input );
3888  void cleanup_mapform( void );
3889  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3890  void cleanup_PLPointer( void );
3891 
3892 
3893 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3894 
3895  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3896  {
3897  PyObject *pdata, *arglist, *result;
3898  PyArrayObject *tmp;
3899 
3900  // the data argument is acutally a pointer to a python object
3901  pdata = (PyObject *) data;
3902  if ( data == NULL )
3903  {
3904  pdata = Py_None;
3905  }
3906  if ( python_pltr ) // if not something is terribly wrong
3907  { // hold a reference to the data object
3908  Py_XINCREF( pdata );
3909  // grab the Global Interpreter Lock to be sure threads don't mess us up
3911  // build the argument list
3912 #ifdef PL_DOUBLE
3913  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3914 #else
3915  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3916 #endif
3917  if ( arglist == NULL )
3918  {
3919  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3920  *tx = *ty = 0;
3921  return;
3922  }
3923  // call the python function
3924  result = PyEval_CallObject( python_pltr, arglist );
3925  // release the argument list
3926  Py_CLEAR( arglist );
3927  // check and unpack the result
3928  if ( result == NULL )
3929  {
3930  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3931  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3932  *tx = *ty = 0;
3933  }
3934  else
3935  {
3936  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3937  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3938  {
3939  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3940  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3941  *tx = *ty = 0;
3942  }
3943  else
3944  {
3945  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3946  *tx = t[0];
3947  *ty = t[1];
3948  Py_CLEAR( tmp );
3949  }
3950  }
3951  // release the result
3952  Py_CLEAR( result );
3953  // release the global interpreter lock
3955  }
3956  }
3957 
3959  {
3960  PyObject *pdata, *arglist, *result;
3961  PLFLT fresult = 0.0;
3962 
3963  // the data argument is acutally a pointer to a python object
3964  pdata = (PyObject *) data;
3965  if ( python_f2eval ) // if not something is terribly wrong
3966  { // hold a reference to the data object
3967  Py_XINCREF( pdata );
3968  // grab the Global Interpreter Lock to be sure threads don't mess us up
3970  // build the argument list
3971  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3972  // call the python function
3973  result = PyEval_CallObject( python_f2eval, arglist );
3974  // release the argument list
3975  Py_CLEAR( arglist );
3976  // check and unpack the result
3977  if ( !PyFloat_Check( result ) )
3978  {
3979  fprintf( stderr, "f2eval callback must return a float\n" );
3980  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3981  }
3982  else
3983  {
3984  // should I test the type here?
3985  fresult = (PLFLT) PyFloat_AsDouble( result );
3986  }
3987  // release the result
3988  Py_CLEAR( result );
3989  // release the global interpreter lock
3991  }
3992  return fresult;
3993  }
3994 
3995  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3996  {
3997  PyObject *pdata, *arglist, *result, *unicode_string;
3998  char *pystring;
3999 
4000  // the data argument is acutally a pointer to a python object
4001  if ( data )
4002  pdata = (PyObject *) data;
4003  else
4004  pdata = Py_None;
4005  if ( python_label ) // if not something is terribly wrong
4006  { // hold a reference to the data object
4007  Py_XINCREF( pdata );
4008  // grab the Global Interpreter Lock to be sure threads don't mess us up
4010  // build the argument list
4011 #ifdef PL_DOUBLE
4012  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4013 #else
4014  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4015 #endif
4016  // call the python function
4017  result = PyEval_CallObject( python_label, arglist );
4018  // release the argument list
4019  //Py_CLEAR(arglist);
4020  // check and unpack the result
4021  if ( result == NULL )
4022  {
4023  fprintf( stderr, "label callback failed with 3 arguments\n" );
4024  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4025  }
4026  else if ( PyString_Check( result ) )
4027  {
4028  // should I test the type here?
4029  pystring = PyString_AsString( result );
4030  strncpy( string, pystring, len );
4031  }
4032  else if ( PyUnicode_Check( result ) )
4033  {
4034  // unicode_string is never freed? memory leak here?
4035  unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4036  pystring = PyBytes_AS_STRING( unicode_string );
4037  // len may be different then the byte string length w/ unicode?
4038  strncpy( string, pystring, len );
4039  }
4040  else
4041  {
4042  fprintf( stderr, "label callback must return a string\n" );
4043  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4044  }
4045  // release the result
4046  Py_CLEAR( result );
4047  // release the global interpreter lock
4049  }
4050  }
4051 
4052  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4053  {
4054  PyObject *px, *py, *pdata, *arglist, *result;
4055  npy_intp n;
4056  n = 1;
4057 
4058  // the data argument is acutally a pointer to a python object
4059  pdata = (PyObject *) data;
4060  if ( data == NULL )
4061  {
4062  pdata = Py_None;
4063  }
4064  if ( python_ct ) // if not something is terribly wrong
4065  { // hold a reference to the data object
4066  Py_XINCREF( pdata );
4067  // grab the Global Interpreter Lock to be sure threads don't mess us up
4069  // build the argument list
4070  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4071  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4072  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4073  // call the python function
4074  result = PyEval_CallObject( python_ct, arglist );
4075  // release the argument list
4076  Py_CLEAR( arglist );
4077  Py_CLEAR( px );
4078  Py_CLEAR( py );
4079  Py_CLEAR( pdata );
4080  // check and unpack the result
4081  if ( result == NULL )
4082  {
4083  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4084  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4085  }
4086  // release the result
4087  Py_CLEAR( result );
4088  // release the global interpreter lock
4090  }
4091  }
4092 
4094  {
4095  PyObject *px, *py, *arglist, *result;
4096  // PyArrayObject *tmpx, *tmpy;
4097 // PLFLT *xx, *yy;
4098 // PLINT i;
4099  npy_intp nn;
4100  nn = n;
4101 
4102  if ( python_mapform ) // if not something is terribly wrong
4103  { // grab the Global Interpreter Lock to be sure threads don't mess us up
4105  // build the argument list
4106 #ifdef PL_HAVE_PTHREAD
4107  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4108  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4109 #else
4110  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4111  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4112 #endif
4113  arglist = Py_BuildValue( "(iOO)", n, px, py );
4114  // call the python function
4115  result = PyEval_CallObject( python_mapform, arglist );
4116  // release the argument list
4117  Py_CLEAR( arglist );
4118  Py_CLEAR( px );
4119  Py_CLEAR( py );
4120  // check and unpack the result
4121  if ( result == NULL )
4122  {
4123  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4124  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4125  }
4126  // release the result
4127  Py_CLEAR( result );
4128  // release the global interpreter lock
4130  }
4131  }
4132 
4133 // marshal the pltr function pointer argument
4134  pltr_func marshal_pltr( PyObject* input )
4135  {
4136  pltr_func result = do_pltr_callback;
4137  PyObject * rep = PyObject_Repr( input );
4138  if ( rep )
4139  {
4140  // Memory leaks here? str and uni_str are not freed?
4141  char* str;
4142  if ( PyUnicode_Check( rep ) )
4143  {
4144  PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4145  str = PyBytes_AS_STRING( uni_str );
4146  }
4147  else
4148  {
4149  str = PyString_AsString( rep );
4150  }
4151  if ( strstr( str, "function pltr0" ) != 0 )
4152  {
4153  result = pltr0;
4154  pltr_type = CB_0;
4155  python_pltr = NULL;
4156  }
4157  else if ( strstr( str, "function pltr1" ) != 0 )
4158  {
4159  result = pltr1;
4160  pltr_type = CB_1;
4161  python_pltr = NULL;
4162  }
4163  else if ( strstr( str, "function pltr2" ) != 0 )
4164  {
4165  result = pltr2;
4166  pltr_type = CB_2;
4167  python_pltr = NULL;
4168  }
4169  else
4170  {
4171  python_pltr = input;
4172  pltr_type = CB_Python;
4173  Py_XINCREF( input );
4174  }
4175  Py_CLEAR( rep );
4176  }
4177  else
4178  {
4179  python_pltr = input;
4180  pltr_type = CB_Python;
4181  Py_XINCREF( input );
4182  }
4183  return result;
4184  }
4185 
4186  void cleanup_pltr( void )
4187  {
4188  Py_CLEAR( python_pltr );
4189  python_pltr = 0;
4190  }
4191 
4192 // marshal the ct function pointer argument
4193  ct_func marshal_ct( PyObject* input )
4194  {
4195  ct_func result = do_ct_callback;
4196  python_ct = input;
4197  Py_XINCREF( input );
4198  return result;
4199  }
4200 
4201  void cleanup_ct( void )
4202  {
4203  Py_CLEAR( python_ct );
4204  python_ct = 0;
4205  }
4206 
4207 // marshal the mapform function pointer argument
4208  mapform_func marshal_mapform( PyObject* input )
4209  {
4211  python_mapform = input;
4212  Py_XINCREF( input );
4213  return result;
4214  }
4215 
4216  void cleanup_mapform( void )
4217  {
4218  Py_CLEAR( python_mapform );
4219  python_mapform = 0;
4220  }
4221 
4222  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4223  {
4224  PLPointer result = NULL;
4225  switch ( pltr_type )
4226  {
4227  case CB_0:
4228  break;
4229  case CB_1:
4230  if ( input != Py_None )
4231  result = marshal_PLcGrid1( input, isimg );
4232  break;
4233  case CB_2:
4234  if ( input != Py_None )
4235  result = marshal_PLcGrid2( input, isimg );
4236  break;
4237  case CB_Python:
4238  Py_XINCREF( input );
4239  result = (PLPointer *) input;
4240  break;
4241  default:
4242  fprintf( stderr, "pltr_type is invalid\n" );
4243  }
4244  return result;
4245  }
4246 
4247  void cleanup_PLPointer( void )
4248  {
4249  switch ( pltr_type )
4250  {
4251  case CB_0:
4252  break;
4253  case CB_1:
4254  cleanup_PLcGrid1();
4255  break;
4256  case CB_2:
4257  cleanup_PLcGrid2();
4258  break;
4259  case CB_Python:
4260  Py_CLEAR( python_pltr );
4261  break;
4262  default:
4263  fprintf( stderr, "pltr_type is invalid\n" );
4264  }
4265  python_pltr = 0;
4266  pltr_type = CB_0;
4267  }
4268 
4269 
4270 
4271 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4272  PyObject *resultobj = 0;
4273  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4274  int arg2 ;
4275  void *argp1 = 0 ;
4276  int res1 = 0 ;
4277  int val2 ;
4278  int ecode2 = 0 ;
4279  PyObject * obj0 = 0 ;
4280  PyObject * obj1 = 0 ;
4281 
4282  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4283  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4284  if (!SWIG_IsOK(res1)) {
4285  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4286  }
4287  arg1 = (PLGraphicsIn *)(argp1);
4288  ecode2 = SWIG_AsVal_int(obj1, &val2);
4289  if (!SWIG_IsOK(ecode2)) {
4290  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4291  }
4292  arg2 = (int)(val2);
4293  if (arg1) (arg1)->type = arg2;
4294  resultobj = SWIG_Py_Void();
4295  return resultobj;
4296 fail:
4297  return NULL;
4298 }
4299 
4300 
4301 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4302  PyObject *resultobj = 0;
4303  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4304  void *argp1 = 0 ;
4305  int res1 = 0 ;
4306  PyObject * obj0 = 0 ;
4307  int result;
4308 
4309  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4310  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4311  if (!SWIG_IsOK(res1)) {
4312  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4313  }
4314  arg1 = (PLGraphicsIn *)(argp1);
4315  result = (int) ((arg1)->type);
4316  resultobj = SWIG_From_int((int)(result));
4317  return resultobj;
4318 fail:
4319  return NULL;
4320 }
4321 
4322 
4323 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4324  PyObject *resultobj = 0;
4325  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4326  unsigned int arg2 ;
4327  void *argp1 = 0 ;
4328  int res1 = 0 ;
4329  unsigned int val2 ;
4330  int ecode2 = 0 ;
4331  PyObject * obj0 = 0 ;
4332  PyObject * obj1 = 0 ;
4333 
4334  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4335  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4336  if (!SWIG_IsOK(res1)) {
4337  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4338  }
4339  arg1 = (PLGraphicsIn *)(argp1);
4340  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4341  if (!SWIG_IsOK(ecode2)) {
4342  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4343  }
4344  arg2 = (unsigned int)(val2);
4345  if (arg1) (arg1)->state = arg2;
4346  resultobj = SWIG_Py_Void();
4347  return resultobj;
4348 fail:
4349  return NULL;
4350 }
4351 
4352 
4353 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354  PyObject *resultobj = 0;
4355  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4356  void *argp1 = 0 ;
4357  int res1 = 0 ;
4358  PyObject * obj0 = 0 ;
4359  unsigned int result;
4360 
4361  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4362  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4363  if (!SWIG_IsOK(res1)) {
4364  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4365  }
4366  arg1 = (PLGraphicsIn *)(argp1);
4367  result = (unsigned int) ((arg1)->state);
4368  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4369  return resultobj;
4370 fail:
4371  return NULL;
4372 }
4373 
4374 
4375 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4376  PyObject *resultobj = 0;
4377  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4378  unsigned int arg2 ;
4379  void *argp1 = 0 ;
4380  int res1 = 0 ;
4381  unsigned int val2 ;
4382  int ecode2 = 0 ;
4383  PyObject * obj0 = 0 ;
4384  PyObject * obj1 = 0 ;
4385 
4386  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4387  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4388  if (!SWIG_IsOK(res1)) {
4389  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4390  }
4391  arg1 = (PLGraphicsIn *)(argp1);
4392  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4393  if (!SWIG_IsOK(ecode2)) {
4394  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4395  }
4396  arg2 = (unsigned int)(val2);
4397  if (arg1) (arg1)->keysym = arg2;
4398  resultobj = SWIG_Py_Void();
4399  return resultobj;
4400 fail:
4401  return NULL;
4402 }
4403 
4404 
4405 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4406  PyObject *resultobj = 0;
4407  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4408  void *argp1 = 0 ;
4409  int res1 = 0 ;
4410  PyObject * obj0 = 0 ;
4411  unsigned int result;
4412 
4413  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4414  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4415  if (!SWIG_IsOK(res1)) {
4416  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4417  }
4418  arg1 = (PLGraphicsIn *)(argp1);
4419  result = (unsigned int) ((arg1)->keysym);
4420  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4421  return resultobj;
4422 fail:
4423  return NULL;
4424 }
4425 
4426 
4427 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428  PyObject *resultobj = 0;
4429  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4430  unsigned int arg2 ;
4431  void *argp1 = 0 ;
4432  int res1 = 0 ;
4433  unsigned int val2 ;
4434  int ecode2 = 0 ;
4435  PyObject * obj0 = 0 ;
4436  PyObject * obj1 = 0 ;
4437 
4438  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4439  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4440  if (!SWIG_IsOK(res1)) {
4441  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4442  }
4443  arg1 = (PLGraphicsIn *)(argp1);
4444  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4445  if (!SWIG_IsOK(ecode2)) {
4446  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4447  }
4448  arg2 = (unsigned int)(val2);
4449  if (arg1) (arg1)->button = arg2;
4450  resultobj = SWIG_Py_Void();
4451  return resultobj;
4452 fail:
4453  return NULL;
4454 }
4455 
4456 
4457 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458  PyObject *resultobj = 0;
4459  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4460  void *argp1 = 0 ;
4461  int res1 = 0 ;
4462  PyObject * obj0 = 0 ;
4463  unsigned int result;
4464 
4465  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4466  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4467  if (!SWIG_IsOK(res1)) {
4468  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4469  }
4470  arg1 = (PLGraphicsIn *)(argp1);
4471  result = (unsigned int) ((arg1)->button);
4472  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4473  return resultobj;
4474 fail:
4475  return NULL;
4476 }
4477 
4478 
4479 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4480  PyObject *resultobj = 0;
4481  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4482  PLINT arg2 ;
4483  void *argp1 = 0 ;
4484  int res1 = 0 ;
4485  int val2 ;
4486  int ecode2 = 0 ;
4487  PyObject * obj0 = 0 ;
4488  PyObject * obj1 = 0 ;
4489 
4490  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4491  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4492  if (!SWIG_IsOK(res1)) {
4493  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4494  }
4495  arg1 = (PLGraphicsIn *)(argp1);
4496  ecode2 = SWIG_AsVal_int(obj1, &val2);
4497  if (!SWIG_IsOK(ecode2)) {
4498  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4499  }
4500  arg2 = (PLINT)(val2);
4501  if (arg1) (arg1)->subwindow = arg2;
4502  resultobj = SWIG_Py_Void();
4503  return resultobj;
4504 fail:
4505  return NULL;
4506 }
4507 
4508 
4509 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4510  PyObject *resultobj = 0;
4511  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4512  void *argp1 = 0 ;
4513  int res1 = 0 ;
4514  PyObject * obj0 = 0 ;
4515  PLINT result;
4516 
4517  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4518  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4519  if (!SWIG_IsOK(res1)) {
4520  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4521  }
4522  arg1 = (PLGraphicsIn *)(argp1);
4523  result = (PLINT) ((arg1)->subwindow);
4524  resultobj = SWIG_From_int((int)(result));
4525  return resultobj;
4526 fail:
4527  return NULL;
4528 }
4529 
4530 
4531 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4532  PyObject *resultobj = 0;
4533  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4534  char *arg2 ;
4535  void *argp1 = 0 ;
4536  int res1 = 0 ;
4537  char temp2[16] ;
4538  int res2 ;
4539  PyObject * obj0 = 0 ;
4540  PyObject * obj1 = 0 ;
4541 
4542  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4543  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4544  if (!SWIG_IsOK(res1)) {
4545  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4546  }
4547  arg1 = (PLGraphicsIn *)(argp1);
4548  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4549  if (!SWIG_IsOK(res2)) {
4550  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4551  }
4552  arg2 = (char *)(temp2);
4553  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4554  else memset(arg1->string,0,16*sizeof(char));
4555  resultobj = SWIG_Py_Void();
4556  return resultobj;
4557 fail:
4558  return NULL;
4559 }
4560 
4561 
4562 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563  PyObject *resultobj = 0;
4564  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4565  void *argp1 = 0 ;
4566  int res1 = 0 ;
4567  PyObject * obj0 = 0 ;
4568  char *result = 0 ;
4569 
4570  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4571  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4572  if (!SWIG_IsOK(res1)) {
4573  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4574  }
4575  arg1 = (PLGraphicsIn *)(argp1);
4576  result = (char *)(char *) ((arg1)->string);
4577  {
4578  size_t size = SWIG_strnlen(result, 16);
4579 
4580 
4581 
4582  resultobj = SWIG_FromCharPtrAndSize(result, size);
4583  }
4584  return resultobj;
4585 fail:
4586  return NULL;
4587 }
4588 
4589 
4590 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4591  PyObject *resultobj = 0;
4592  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4593  int arg2 ;
4594  void *argp1 = 0 ;
4595  int res1 = 0 ;
4596  int val2 ;
4597  int ecode2 = 0 ;
4598  PyObject * obj0 = 0 ;
4599  PyObject * obj1 = 0 ;
4600 
4601  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4602  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4603  if (!SWIG_IsOK(res1)) {
4604  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4605  }
4606  arg1 = (PLGraphicsIn *)(argp1);
4607  ecode2 = SWIG_AsVal_int(obj1, &val2);
4608  if (!SWIG_IsOK(ecode2)) {
4609  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4610  }
4611  arg2 = (int)(val2);
4612  if (arg1) (arg1)->pX = arg2;
4613  resultobj = SWIG_Py_Void();
4614  return resultobj;
4615 fail:
4616  return NULL;
4617 }
4618 
4619 
4620 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4621  PyObject *resultobj = 0;
4622  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4623  void *argp1 = 0 ;
4624  int res1 = 0 ;
4625  PyObject * obj0 = 0 ;
4626  int result;
4627 
4628  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4629  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4630  if (!SWIG_IsOK(res1)) {
4631  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4632  }
4633  arg1 = (PLGraphicsIn *)(argp1);
4634  result = (int) ((arg1)->pX);
4635  resultobj = SWIG_From_int((int)(result));
4636  return resultobj;
4637 fail:
4638  return NULL;
4639 }
4640 
4641 
4642 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4643  PyObject *resultobj = 0;
4644  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4645  int arg2 ;
4646  void *argp1 = 0 ;
4647  int res1 = 0 ;
4648  int val2 ;
4649  int ecode2 = 0 ;
4650  PyObject * obj0 = 0 ;
4651  PyObject * obj1 = 0 ;
4652 
4653  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4654  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4655  if (!SWIG_IsOK(res1)) {
4656  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4657  }
4658  arg1 = (PLGraphicsIn *)(argp1);
4659  ecode2 = SWIG_AsVal_int(obj1, &val2);
4660  if (!SWIG_IsOK(ecode2)) {
4661  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4662  }
4663  arg2 = (int)(val2);
4664  if (arg1) (arg1)->pY = arg2;
4665  resultobj = SWIG_Py_Void();
4666  return resultobj;
4667 fail:
4668  return NULL;
4669 }
4670 
4671 
4672 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673  PyObject *resultobj = 0;
4674  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4675  void *argp1 = 0 ;
4676  int res1 = 0 ;
4677  PyObject * obj0 = 0 ;
4678  int result;
4679 
4680  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4681  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4682  if (!SWIG_IsOK(res1)) {
4683  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4684  }
4685  arg1 = (PLGraphicsIn *)(argp1);
4686  result = (int) ((arg1)->pY);
4687  resultobj = SWIG_From_int((int)(result));
4688  return resultobj;
4689 fail:
4690  return NULL;
4691 }
4692 
4693 
4694 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4695  PyObject *resultobj = 0;
4696  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4697  PLFLT arg2 ;
4698  void *argp1 = 0 ;
4699  int res1 = 0 ;
4700  double val2 ;
4701  int ecode2 = 0 ;
4702  PyObject * obj0 = 0 ;
4703  PyObject * obj1 = 0 ;
4704 
4705  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4706  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4707  if (!SWIG_IsOK(res1)) {
4708  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4709  }
4710  arg1 = (PLGraphicsIn *)(argp1);
4711  ecode2 = SWIG_AsVal_double(obj1, &val2);
4712  if (!SWIG_IsOK(ecode2)) {
4713  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4714  }
4715  arg2 = (PLFLT)(val2);
4716  if (arg1) (arg1)->dX = arg2;
4717  resultobj = SWIG_Py_Void();
4718  return resultobj;
4719 fail:
4720  return NULL;
4721 }
4722 
4723 
4724 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4725  PyObject *resultobj = 0;
4726  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4727  void *argp1 = 0 ;
4728  int res1 = 0 ;
4729  PyObject * obj0 = 0 ;
4730  PLFLT result;
4731 
4732  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4733  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4734  if (!SWIG_IsOK(res1)) {
4735  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4736  }
4737  arg1 = (PLGraphicsIn *)(argp1);
4738  result = (PLFLT) ((arg1)->dX);
4739  resultobj = SWIG_From_double((double)(result));
4740  return resultobj;
4741 fail:
4742  return NULL;
4743 }
4744 
4745 
4746 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4747  PyObject *resultobj = 0;
4748  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4749  PLFLT arg2 ;
4750  void *argp1 = 0 ;
4751  int res1 = 0 ;
4752  double val2 ;
4753  int ecode2 = 0 ;
4754  PyObject * obj0 = 0 ;
4755  PyObject * obj1 = 0 ;
4756 
4757  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4758  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4759  if (!SWIG_IsOK(res1)) {
4760  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4761  }
4762  arg1 = (PLGraphicsIn *)(argp1);
4763  ecode2 = SWIG_AsVal_double(obj1, &val2);
4764  if (!SWIG_IsOK(ecode2)) {
4765  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4766  }
4767  arg2 = (PLFLT)(val2);
4768  if (arg1) (arg1)->dY = arg2;
4769  resultobj = SWIG_Py_Void();
4770  return resultobj;
4771 fail:
4772  return NULL;
4773 }
4774 
4775 
4776 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4777  PyObject *resultobj = 0;
4778  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4779  void *argp1 = 0 ;
4780  int res1 = 0 ;
4781  PyObject * obj0 = 0 ;
4782  PLFLT result;
4783 
4784  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4785  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4786  if (!SWIG_IsOK(res1)) {
4787  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4788  }
4789  arg1 = (PLGraphicsIn *)(argp1);
4790  result = (PLFLT) ((arg1)->dY);
4791  resultobj = SWIG_From_double((double)(result));
4792  return resultobj;
4793 fail:
4794  return NULL;
4795 }
4796 
4797 
4798 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4799  PyObject *resultobj = 0;
4800  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4801  PLFLT arg2 ;
4802  void *argp1 = 0 ;
4803  int res1 = 0 ;
4804  double val2 ;
4805  int ecode2 = 0 ;
4806  PyObject * obj0 = 0 ;
4807  PyObject * obj1 = 0 ;
4808 
4809  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4810  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4811  if (!SWIG_IsOK(res1)) {
4812  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4813  }
4814  arg1 = (PLGraphicsIn *)(argp1);
4815  ecode2 = SWIG_AsVal_double(obj1, &val2);
4816  if (!SWIG_IsOK(ecode2)) {
4817  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4818  }
4819  arg2 = (PLFLT)(val2);
4820  if (arg1) (arg1)->wX = arg2;
4821  resultobj = SWIG_Py_Void();
4822  return resultobj;
4823 fail:
4824  return NULL;
4825 }
4826 
4827 
4828 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4829  PyObject *resultobj = 0;
4830  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4831  void *argp1 = 0 ;
4832  int res1 = 0 ;
4833  PyObject * obj0 = 0 ;
4834  PLFLT result;
4835 
4836  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4837  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4838  if (!SWIG_IsOK(res1)) {
4839  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4840  }
4841  arg1 = (PLGraphicsIn *)(argp1);
4842  result = (PLFLT) ((arg1)->wX);
4843  resultobj = SWIG_From_double((double)(result));
4844  return resultobj;
4845 fail:
4846  return NULL;
4847 }
4848 
4849 
4850 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4851  PyObject *resultobj = 0;
4852  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4853  PLFLT arg2 ;
4854  void *argp1 = 0 ;
4855  int res1 = 0 ;
4856  double val2 ;
4857  int ecode2 = 0 ;
4858  PyObject * obj0 = 0 ;
4859  PyObject * obj1 = 0 ;
4860 
4861  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4862  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4863  if (!SWIG_IsOK(res1)) {
4864  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4865  }
4866  arg1 = (PLGraphicsIn *)(argp1);
4867  ecode2 = SWIG_AsVal_double(obj1, &val2);
4868  if (!SWIG_IsOK(ecode2)) {
4869  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4870  }
4871  arg2 = (PLFLT)(val2);
4872  if (arg1) (arg1)->wY = arg2;
4873  resultobj = SWIG_Py_Void();
4874  return resultobj;
4875 fail:
4876  return NULL;
4877 }
4878 
4879 
4880 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4881  PyObject *resultobj = 0;
4882  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4883  void *argp1 = 0 ;
4884  int res1 = 0 ;
4885  PyObject * obj0 = 0 ;
4886  PLFLT result;
4887 
4888  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4889  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4890  if (!SWIG_IsOK(res1)) {
4891  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4892  }
4893  arg1 = (PLGraphicsIn *)(argp1);
4894  result = (PLFLT) ((arg1)->wY);
4895  resultobj = SWIG_From_double((double)(result));
4896  return resultobj;
4897 fail:
4898  return NULL;
4899 }
4900 
4901 
4902 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4903  PyObject *resultobj = 0;
4904  PLGraphicsIn *result = 0 ;
4905 
4906  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4907  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4909  return resultobj;
4910 fail:
4911  return NULL;
4912 }
4913 
4914 
4915 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4916  PyObject *resultobj = 0;
4917  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4918  void *argp1 = 0 ;
4919  int res1 = 0 ;
4920  PyObject * obj0 = 0 ;
4921 
4922  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4923  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4924  if (!SWIG_IsOK(res1)) {
4925  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4926  }
4927  arg1 = (PLGraphicsIn *)(argp1);
4928  free((char *) arg1);
4929  resultobj = SWIG_Py_Void();
4930  return resultobj;
4931 fail:
4932  return NULL;
4933 }
4934 
4935 
4936 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4937  PyObject *obj;
4938  if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
4940  return SWIG_Py_Void();
4941 }
4942 
4943 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4944  PyObject *resultobj = 0;
4945  PLINT arg1 ;
4946  int val1 ;
4947  int ecode1 = 0 ;
4948  PyObject * obj0 = 0 ;
4949 
4950  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4951  ecode1 = SWIG_AsVal_int(obj0, &val1);
4952  if (!SWIG_IsOK(ecode1)) {
4953  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4954  }
4955  arg1 = (PLINT)(val1);
4956  plsxwin(arg1);
4957  resultobj = SWIG_Py_Void();
4958  return resultobj;
4959 fail:
4960  return NULL;
4961 }
4962 
4963 
4964 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4965  PyObject *resultobj = 0;
4966  PLINT arg1 ;
4967  PLINT arg2 ;
4968  int val1 ;
4969  int ecode1 = 0 ;
4970  int val2 ;
4971  int ecode2 = 0 ;
4972  PyObject * obj0 = 0 ;
4973  PyObject * obj1 = 0 ;
4974 
4975  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4976  ecode1 = SWIG_AsVal_int(obj0, &val1);
4977  if (!SWIG_IsOK(ecode1)) {
4978  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4979  }
4980  arg1 = (PLINT)(val1);
4981  ecode2 = SWIG_AsVal_int(obj1, &val2);
4982  if (!SWIG_IsOK(ecode2)) {
4983  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4984  }
4985  arg2 = (PLINT)(val2);
4986  pl_setcontlabelformat(arg1,arg2);
4987  resultobj = SWIG_Py_Void();
4988  return resultobj;
4989 fail:
4990  return NULL;
4991 }
4992 
4993 
4994 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4995  PyObject *resultobj = 0;
4996  PLFLT arg1 ;
4997  PLFLT arg2 ;
4998  PLFLT arg3 ;
4999  PLINT arg4 ;
5000  double val1 ;
5001  int ecode1 = 0 ;
5002  double val2 ;
5003  int ecode2 = 0 ;
5004  double val3 ;
5005  int ecode3 = 0 ;
5006  int val4 ;
5007  int ecode4 = 0 ;
5008  PyObject * obj0 = 0 ;
5009  PyObject * obj1 = 0 ;
5010  PyObject * obj2 = 0 ;
5011  PyObject * obj3 = 0 ;
5012 
5013  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5014  ecode1 = SWIG_AsVal_double(obj0, &val1);
5015  if (!SWIG_IsOK(ecode1)) {
5016  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5017  }
5018  arg1 = (PLFLT)(val1);
5019  ecode2 = SWIG_AsVal_double(obj1, &val2);
5020  if (!SWIG_IsOK(ecode2)) {
5021  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5022  }
5023  arg2 = (PLFLT)(val2);
5024  ecode3 = SWIG_AsVal_double(obj2, &val3);
5025  if (!SWIG_IsOK(ecode3)) {
5026  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5027  }
5028  arg3 = (PLFLT)(val3);
5029  ecode4 = SWIG_AsVal_int(obj3, &val4);
5030  if (!SWIG_IsOK(ecode4)) {
5031  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5032  }
5033  arg4 = (PLINT)(val4);
5034  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5035  resultobj = SWIG_Py_Void();
5036  return resultobj;
5037 fail:
5038  return NULL;
5039 }
5040 
5041 
5042 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5043  PyObject *resultobj = 0;
5044  PLINT arg1 ;
5045  int val1 ;
5046  int ecode1 = 0 ;
5047  PyObject * obj0 = 0 ;
5048 
5049  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
5050  ecode1 = SWIG_AsVal_int(obj0, &val1);
5051  if (!SWIG_IsOK(ecode1)) {
5052  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5053  }
5054  arg1 = (PLINT)(val1);
5055  pladv(arg1);
5056  resultobj = SWIG_Py_Void();
5057  return resultobj;
5058 fail:
5059  return NULL;
5060 }
5061 
5062 
5063 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5064  PyObject *resultobj = 0;
5065  PLFLT arg1 ;
5066  PLFLT arg2 ;
5067  PLFLT arg3 ;
5068  PLFLT arg4 ;
5069  PLFLT arg5 ;
5070  PLFLT arg6 ;
5071  PLFLT arg7 ;
5072  PLBOOL arg8 ;
5073  double val1 ;
5074  int ecode1 = 0 ;
5075  double val2 ;
5076  int ecode2 = 0 ;
5077  double val3 ;
5078  int ecode3 = 0 ;
5079  double val4 ;
5080  int ecode4 = 0 ;
5081  double val5 ;
5082  int ecode5 = 0 ;
5083  double val6 ;
5084  int ecode6 = 0 ;
5085  double val7 ;
5086  int ecode7 = 0 ;
5087  int val8 ;
5088  int ecode8 = 0 ;
5089  PyObject * obj0 = 0 ;
5090  PyObject * obj1 = 0 ;
5091  PyObject * obj2 = 0 ;
5092  PyObject * obj3 = 0 ;
5093  PyObject * obj4 = 0 ;
5094  PyObject * obj5 = 0 ;
5095  PyObject * obj6 = 0 ;
5096  PyObject * obj7 = 0 ;
5097 
5098  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5099  ecode1 = SWIG_AsVal_double(obj0, &val1);
5100  if (!SWIG_IsOK(ecode1)) {
5101  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5102  }
5103  arg1 = (PLFLT)(val1);
5104  ecode2 = SWIG_AsVal_double(obj1, &val2);
5105  if (!SWIG_IsOK(ecode2)) {
5106  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5107  }
5108  arg2 = (PLFLT)(val2);
5109  ecode3 = SWIG_AsVal_double(obj2, &val3);
5110  if (!SWIG_IsOK(ecode3)) {
5111  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5112  }
5113  arg3 = (PLFLT)(val3);
5114  ecode4 = SWIG_AsVal_double(obj3, &val4);
5115  if (!SWIG_IsOK(ecode4)) {
5116  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5117  }
5118  arg4 = (PLFLT)(val4);
5119  ecode5 = SWIG_AsVal_double(obj4, &val5);
5120  if (!SWIG_IsOK(ecode5)) {
5121  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5122  }
5123  arg5 = (PLFLT)(val5);
5124  ecode6 = SWIG_AsVal_double(obj5, &val6);
5125  if (!SWIG_IsOK(ecode6)) {
5126  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5127  }
5128  arg6 = (PLFLT)(val6);
5129  ecode7 = SWIG_AsVal_double(obj6, &val7);
5130  if (!SWIG_IsOK(ecode7)) {
5131  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5132  }
5133  arg7 = (PLFLT)(val7);
5134  ecode8 = SWIG_AsVal_int(obj7, &val8);
5135  if (!SWIG_IsOK(ecode8)) {
5136  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5137  }
5138  arg8 = (PLBOOL)(val8);
5139  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5140  resultobj = SWIG_Py_Void();
5141  return resultobj;
5142 fail:
5143  return NULL;
5144 }
5145 
5146 
5147 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5148  PyObject *resultobj = 0;
5149  PLFLT arg1 ;
5150  PLFLT arg2 ;
5151  char *arg3 = (char *) 0 ;
5152  PLFLT arg4 ;
5153  PLINT arg5 ;
5154  char *arg6 = (char *) 0 ;
5155  PLFLT arg7 ;
5156  PLINT arg8 ;
5157  double val1 ;
5158  int ecode1 = 0 ;
5159  double val2 ;
5160  int ecode2 = 0 ;
5161  int res3 ;
5162  char *buf3 = 0 ;
5163  int alloc3 = 0 ;
5164  double val4 ;
5165  int ecode4 = 0 ;
5166  int val5 ;
5167  int ecode5 = 0 ;
5168  int res6 ;
5169  char *buf6 = 0 ;
5170  int alloc6 = 0 ;
5171  double val7 ;
5172  int ecode7 = 0 ;
5173  int val8 ;
5174  int ecode8 = 0 ;
5175  PyObject * obj0 = 0 ;
5176  PyObject * obj1 = 0 ;
5177  PyObject * obj2 = 0 ;
5178  PyObject * obj3 = 0 ;
5179  PyObject * obj4 = 0 ;
5180  PyObject * obj5 = 0 ;
5181  PyObject * obj6 = 0 ;
5182  PyObject * obj7 = 0 ;
5183 
5184  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5185  ecode1 = SWIG_AsVal_double(obj0, &val1);
5186  if (!SWIG_IsOK(ecode1)) {
5187  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5188  }
5189  arg1 = (PLFLT)(val1);
5190  ecode2 = SWIG_AsVal_double(obj1, &val2);
5191  if (!SWIG_IsOK(ecode2)) {
5192  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5193  }
5194  arg2 = (PLFLT)(val2);
5195  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5196  if (!SWIG_IsOK(res3)) {
5197  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5198  }
5199  arg3 = (char *)(buf3);
5200  ecode4 = SWIG_AsVal_double(obj3, &val4);
5201  if (!SWIG_IsOK(ecode4)) {
5202  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5203  }
5204  arg4 = (PLFLT)(val4);
5205  ecode5 = SWIG_AsVal_int(obj4, &val5);
5206  if (!SWIG_IsOK(ecode5)) {
5207  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5208  }
5209  arg5 = (PLINT)(val5);
5210  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5211  if (!SWIG_IsOK(res6)) {
5212  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5213  }
5214  arg6 = (char *)(buf6);
5215  ecode7 = SWIG_AsVal_double(obj6, &val7);
5216  if (!SWIG_IsOK(ecode7)) {
5217  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5218  }
5219  arg7 = (PLFLT)(val7);
5220  ecode8 = SWIG_AsVal_int(obj7, &val8);
5221  if (!SWIG_IsOK(ecode8)) {
5222  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5223  }
5224  arg8 = (PLINT)(val8);
5225  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5226  resultobj = SWIG_Py_Void();
5227  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5228  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5229  return resultobj;
5230 fail:
5231  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5232  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5233  return NULL;
5234 }
5235 
5236 
5237 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5238  PyObject *resultobj = 0;
5239  PLINT arg1 ;
5240  PLFLT *arg2 = (PLFLT *) 0 ;
5241  PLFLT *arg3 = (PLFLT *) 0 ;
5242  PLINT arg4 ;
5243  PyArrayObject *tmp1 = NULL ;
5244  PyArrayObject *tmp3 = NULL ;
5245  int val4 ;
5246  int ecode4 = 0 ;
5247  PyObject * obj0 = 0 ;
5248  PyObject * obj1 = 0 ;
5249  PyObject * obj2 = 0 ;
5250 
5251  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5252  {
5253  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5254  if ( tmp1 == NULL )
5255  return NULL;
5256  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5257  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5258  }
5259  {
5260  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5261  if ( tmp3 == NULL )
5262  return NULL;
5263  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5264  {
5265  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5266  return NULL;
5267  }
5268  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5269  }
5270  ecode4 = SWIG_AsVal_int(obj2, &val4);
5271  if (!SWIG_IsOK(ecode4)) {
5272  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5273  }
5274  arg4 = (PLINT)(val4);
5275  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5276  resultobj = SWIG_Py_Void();
5277  {
5278  Py_CLEAR( tmp1 );
5279  }
5280  {
5281  Py_CLEAR( tmp3 );
5282  }
5283  return resultobj;
5284 fail:
5285  {
5286  Py_CLEAR( tmp1 );
5287  }
5288  {
5289  Py_CLEAR( tmp3 );
5290  }
5291  return NULL;
5292 }
5293 
5294 
5295 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296  PyObject *resultobj = 0;
5297  PLINT *arg1 = (PLINT *) 0 ;
5298  PLINT *arg2 = (PLINT *) 0 ;
5299  PLINT *arg3 = (PLINT *) 0 ;
5300  PLINT *arg4 = (PLINT *) 0 ;
5301  PLINT *arg5 = (PLINT *) 0 ;
5302  PLFLT *arg6 = (PLFLT *) 0 ;
5303  PLFLT arg7 ;
5304  PLINT temp1 ;
5305  int res1 = SWIG_TMPOBJ ;
5306  PLINT temp2 ;
5307  int res2 = SWIG_TMPOBJ ;
5308  PLINT temp3 ;
5309  int res3 = SWIG_TMPOBJ ;
5310  PLINT temp4 ;
5311  int res4 = SWIG_TMPOBJ ;
5312  PLINT temp5 ;
5313  int res5 = SWIG_TMPOBJ ;
5314  PLFLT temp6 ;
5315  int res6 = SWIG_TMPOBJ ;
5316  double val7 ;
5317  int ecode7 = 0 ;
5318  PyObject * obj0 = 0 ;
5319 
5320  arg1 = &temp1;
5321  arg2 = &temp2;
5322  arg3 = &temp3;
5323  arg4 = &temp4;
5324  arg5 = &temp5;
5325  arg6 = &temp6;
5326  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5327  ecode7 = SWIG_AsVal_double(obj0, &val7);
5328  if (!SWIG_IsOK(ecode7)) {
5329  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5330  }
5331  arg7 = (PLFLT)(val7);
5332  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5333  resultobj = SWIG_Py_Void();
5334  if (SWIG_IsTmpObj(res1)) {
5335  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5336  } else {
5337  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5338  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5339  }
5340  if (SWIG_IsTmpObj(res2)) {
5341  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5342  } else {
5343  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5344  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5345  }
5346  if (SWIG_IsTmpObj(res3)) {
5347  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5348  } else {
5349  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5350  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5351  }
5352  if (SWIG_IsTmpObj(res4)) {
5353  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5354  } else {
5355  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5356  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5357  }
5358  if (SWIG_IsTmpObj(res5)) {
5359  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5360  } else {
5361  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5362  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5363  }
5364  if (SWIG_IsTmpObj(res6)) {
5365  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5366  } else {
5367  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5368  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5369  }
5370  return resultobj;
5371 fail:
5372  return NULL;
5373 }
5374 
5375 
5376 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5377  PyObject *resultobj = 0;
5378 
5379  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5380  plbop();
5381  resultobj = SWIG_Py_Void();
5382  return resultobj;
5383 fail:
5384  return NULL;
5385 }
5386 
5387 
5388 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5389  PyObject *resultobj = 0;
5390  char *arg1 = (char *) 0 ;
5391  PLFLT arg2 ;
5392  PLINT arg3 ;
5393  char *arg4 = (char *) 0 ;
5394  PLFLT arg5 ;
5395  PLINT arg6 ;
5396  int res1 ;
5397  char *buf1 = 0 ;
5398  int alloc1 = 0 ;
5399  double val2 ;
5400  int ecode2 = 0 ;
5401  int val3 ;
5402  int ecode3 = 0 ;
5403  int res4 ;
5404  char *buf4 = 0 ;
5405  int alloc4 = 0 ;
5406  double val5 ;
5407  int ecode5 = 0 ;
5408  int val6 ;
5409  int ecode6 = 0 ;
5410  PyObject * obj0 = 0 ;
5411  PyObject * obj1 = 0 ;
5412  PyObject * obj2 = 0 ;
5413  PyObject * obj3 = 0 ;
5414  PyObject * obj4 = 0 ;
5415  PyObject * obj5 = 0 ;
5416 
5417  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5418  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5419  if (!SWIG_IsOK(res1)) {
5420  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5421  }
5422  arg1 = (char *)(buf1);
5423  ecode2 = SWIG_AsVal_double(obj1, &val2);
5424  if (!SWIG_IsOK(ecode2)) {
5425  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5426  }
5427  arg2 = (PLFLT)(val2);
5428  ecode3 = SWIG_AsVal_int(obj2, &val3);
5429  if (!SWIG_IsOK(ecode3)) {
5430  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5431  }
5432  arg3 = (PLINT)(val3);
5433  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5434  if (!SWIG_IsOK(res4)) {
5435  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5436  }
5437  arg4 = (char *)(buf4);
5438  ecode5 = SWIG_AsVal_double(obj4, &val5);
5439  if (!SWIG_IsOK(ecode5)) {
5440  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5441  }
5442  arg5 = (PLFLT)(val5);
5443  ecode6 = SWIG_AsVal_int(obj5, &val6);
5444  if (!SWIG_IsOK(ecode6)) {
5445  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5446  }
5447  arg6 = (PLINT)(val6);
5448  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5449  resultobj = SWIG_Py_Void();
5450  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5451  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5452  return resultobj;
5453 fail:
5454  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5455  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5456  return NULL;
5457 }
5458 
5459 
5460 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461  PyObject *resultobj = 0;
5462  char *arg1 = (char *) 0 ;
5463  char *arg2 = (char *) 0 ;
5464  PLFLT arg3 ;
5465  PLINT arg4 ;
5466  char *arg5 = (char *) 0 ;
5467  char *arg6 = (char *) 0 ;
5468  PLFLT arg7 ;
5469  PLINT arg8 ;
5470  char *arg9 = (char *) 0 ;
5471  char *arg10 = (char *) 0 ;
5472  PLFLT arg11 ;
5473  PLINT arg12 ;
5474  int res1 ;
5475  char *buf1 = 0 ;
5476  int alloc1 = 0 ;
5477  int res2 ;
5478  char *buf2 = 0 ;
5479  int alloc2 = 0 ;
5480  double val3 ;
5481  int ecode3 = 0 ;
5482  int val4 ;
5483  int ecode4 = 0 ;
5484  int res5 ;
5485  char *buf5 = 0 ;
5486  int alloc5 = 0 ;
5487  int res6 ;
5488  char *buf6 = 0 ;
5489  int alloc6 = 0 ;
5490  double val7 ;
5491  int ecode7 = 0 ;
5492  int val8 ;
5493  int ecode8 = 0 ;
5494  int res9 ;
5495  char *buf9 = 0 ;
5496  int alloc9 = 0 ;
5497  int res10 ;
5498  char *buf10 = 0 ;
5499  int alloc10 = 0 ;
5500  double val11 ;
5501  int ecode11 = 0 ;
5502  int val12 ;
5503  int ecode12 = 0 ;
5504  PyObject * obj0 = 0 ;
5505  PyObject * obj1 = 0 ;
5506  PyObject * obj2 = 0 ;
5507  PyObject * obj3 = 0 ;
5508  PyObject * obj4 = 0 ;
5509  PyObject * obj5 = 0 ;
5510  PyObject * obj6 = 0 ;
5511  PyObject * obj7 = 0 ;
5512  PyObject * obj8 = 0 ;
5513  PyObject * obj9 = 0 ;
5514  PyObject * obj10 = 0 ;
5515  PyObject * obj11 = 0 ;
5516 
5517  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5518  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5519  if (!SWIG_IsOK(res1)) {
5520  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5521  }
5522  arg1 = (char *)(buf1);
5523  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5524  if (!SWIG_IsOK(res2)) {
5525  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5526  }
5527  arg2 = (char *)(buf2);
5528  ecode3 = SWIG_AsVal_double(obj2, &val3);
5529  if (!SWIG_IsOK(ecode3)) {
5530  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5531  }
5532  arg3 = (PLFLT)(val3);
5533  ecode4 = SWIG_AsVal_int(obj3, &val4);
5534  if (!SWIG_IsOK(ecode4)) {
5535  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5536  }
5537  arg4 = (PLINT)(val4);
5538  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5539  if (!SWIG_IsOK(res5)) {
5540  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5541  }
5542  arg5 = (char *)(buf5);
5543  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5544  if (!SWIG_IsOK(res6)) {
5545  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5546  }
5547  arg6 = (char *)(buf6);
5548  ecode7 = SWIG_AsVal_double(obj6, &val7);
5549  if (!SWIG_IsOK(ecode7)) {
5550  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5551  }
5552  arg7 = (PLFLT)(val7);
5553  ecode8 = SWIG_AsVal_int(obj7, &val8);
5554  if (!SWIG_IsOK(ecode8)) {
5555  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5556  }
5557  arg8 = (PLINT)(val8);
5558  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5559  if (!SWIG_IsOK(res9)) {
5560  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5561  }
5562  arg9 = (char *)(buf9);
5563  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5564  if (!SWIG_IsOK(res10)) {
5565  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5566  }
5567  arg10 = (char *)(buf10);
5568  ecode11 = SWIG_AsVal_double(obj10, &val11);
5569  if (!SWIG_IsOK(ecode11)) {
5570  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5571  }
5572  arg11 = (PLFLT)(val11);
5573  ecode12 = SWIG_AsVal_int(obj11, &val12);
5574  if (!SWIG_IsOK(ecode12)) {
5575  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5576  }
5577  arg12 = (PLINT)(val12);
5578  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);
5579  resultobj = SWIG_Py_Void();
5580  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5581  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5582  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5583  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5584  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5585  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5586  return resultobj;
5587 fail:
5588  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5589  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5590  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5591  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5592  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5593  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5594  return NULL;
5595 }
5596 
5597 
5598 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5599  PyObject *resultobj = 0;
5600  PLFLT arg1 ;
5601  PLFLT arg2 ;
5602  PLFLT *arg3 = (PLFLT *) 0 ;
5603  PLFLT *arg4 = (PLFLT *) 0 ;
5604  PLINT *arg5 = (PLINT *) 0 ;
5605  double val1 ;
5606  int ecode1 = 0 ;
5607  double val2 ;
5608  int ecode2 = 0 ;
5609  PLFLT temp3 ;
5610  int res3 = SWIG_TMPOBJ ;
5611  PLFLT temp4 ;
5612  int res4 = SWIG_TMPOBJ ;
5613  PLINT temp5 ;
5614  int res5 = SWIG_TMPOBJ ;
5615  PyObject * obj0 = 0 ;
5616  PyObject * obj1 = 0 ;
5617 
5618  arg3 = &temp3;
5619  arg4 = &temp4;
5620  arg5 = &temp5;
5621  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5622  ecode1 = SWIG_AsVal_double(obj0, &val1);
5623  if (!SWIG_IsOK(ecode1)) {
5624  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5625  }
5626  arg1 = (PLFLT)(val1);
5627  ecode2 = SWIG_AsVal_double(obj1, &val2);
5628  if (!SWIG_IsOK(ecode2)) {
5629  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5630  }
5631  arg2 = (PLFLT)(val2);
5632  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5633  resultobj = SWIG_Py_Void();
5634  if (SWIG_IsTmpObj(res3)) {
5635  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5636  } else {
5637  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5638  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5639  }
5640  if (SWIG_IsTmpObj(res4)) {
5641  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5642  } else {
5643  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5644  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5645  }
5646  if (SWIG_IsTmpObj(res5)) {
5647  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5648  } else {
5649  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5650  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5651  }
5652  return resultobj;
5653 fail:
5654  return NULL;
5655 }
5656 
5657 
5658 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5659  PyObject *resultobj = 0;
5660 
5661  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5662  plclear();
5663  resultobj = SWIG_Py_Void();
5664  return resultobj;
5665 fail:
5666  return NULL;
5667 }
5668 
5669 
5670 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5671  PyObject *resultobj = 0;
5672  PLINT arg1 ;
5673  int val1 ;
5674  int ecode1 = 0 ;
5675  PyObject * obj0 = 0 ;
5676 
5677  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5678  ecode1 = SWIG_AsVal_int(obj0, &val1);
5679  if (!SWIG_IsOK(ecode1)) {
5680  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5681  }
5682  arg1 = (PLINT)(val1);
5683  plcol0(arg1);
5684  resultobj = SWIG_Py_Void();
5685  return resultobj;
5686 fail:
5687  return NULL;
5688 }
5689 
5690 
5691 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5692  PyObject *resultobj = 0;
5693  PLFLT arg1 ;
5694  double val1 ;
5695  int ecode1 = 0 ;
5696  PyObject * obj0 = 0 ;
5697 
5698  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5699  ecode1 = SWIG_AsVal_double(obj0, &val1);
5700  if (!SWIG_IsOK(ecode1)) {
5701  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5702  }
5703  arg1 = (PLFLT)(val1);
5704  plcol1(arg1);
5705  resultobj = SWIG_Py_Void();
5706  return resultobj;
5707 fail:
5708  return NULL;
5709 }
5710 
5711 
5712 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5713  PyObject *resultobj = 0;
5714  PLFLT arg1 ;
5715  PLFLT arg2 ;
5716  PLFLT arg3 ;
5717  PLINT arg4 ;
5718  PLBOOL arg5 ;
5719  PLINT arg6 ;
5720  PLINT arg7 ;
5721  PLINT arg8 ;
5722  PLINT arg9 ;
5723  PLINT arg10 ;
5724  PLFLT arg11 ;
5725  double val1 ;
5726  int ecode1 = 0 ;
5727  double val2 ;
5728  int ecode2 = 0 ;
5729  double val3 ;
5730  int ecode3 = 0 ;
5731  int val4 ;
5732  int ecode4 = 0 ;
5733  int val5 ;
5734  int ecode5 = 0 ;
5735  int val6 ;
5736  int ecode6 = 0 ;
5737  int val7 ;
5738  int ecode7 = 0 ;
5739  int val8 ;
5740  int ecode8 = 0 ;
5741  int val9 ;
5742  int ecode9 = 0 ;
5743  int val10 ;
5744  int ecode10 = 0 ;
5745  double val11 ;
5746  int ecode11 = 0 ;
5747  PyObject * obj0 = 0 ;
5748  PyObject * obj1 = 0 ;
5749  PyObject * obj2 = 0 ;
5750  PyObject * obj3 = 0 ;
5751  PyObject * obj4 = 0 ;
5752  PyObject * obj5 = 0 ;
5753  PyObject * obj6 = 0 ;
5754  PyObject * obj7 = 0 ;
5755  PyObject * obj8 = 0 ;
5756  PyObject * obj9 = 0 ;
5757  PyObject * obj10 = 0 ;
5758 
5759  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5760  ecode1 = SWIG_AsVal_double(obj0, &val1);
5761  if (!SWIG_IsOK(ecode1)) {
5762  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5763  }
5764  arg1 = (PLFLT)(val1);
5765  ecode2 = SWIG_AsVal_double(obj1, &val2);
5766  if (!SWIG_IsOK(ecode2)) {
5767  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5768  }
5769  arg2 = (PLFLT)(val2);
5770  ecode3 = SWIG_AsVal_double(obj2, &val3);
5771  if (!SWIG_IsOK(ecode3)) {
5772  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5773  }
5774  arg3 = (PLFLT)(val3);
5775  ecode4 = SWIG_AsVal_int(obj3, &val4);
5776  if (!SWIG_IsOK(ecode4)) {
5777  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5778  }
5779  arg4 = (PLINT)(val4);
5780  ecode5 = SWIG_AsVal_int(obj4, &val5);
5781  if (!SWIG_IsOK(ecode5)) {
5782  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5783  }
5784  arg5 = (PLBOOL)(val5);
5785  ecode6 = SWIG_AsVal_int(obj5, &val6);
5786  if (!SWIG_IsOK(ecode6)) {
5787  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5788  }
5789  arg6 = (PLINT)(val6);
5790  ecode7 = SWIG_AsVal_int(obj6, &val7);
5791  if (!SWIG_IsOK(ecode7)) {
5792  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5793  }
5794  arg7 = (PLINT)(val7);
5795  ecode8 = SWIG_AsVal_int(obj7, &val8);
5796  if (!SWIG_IsOK(ecode8)) {
5797  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5798  }
5799  arg8 = (PLINT)(val8);
5800  ecode9 = SWIG_AsVal_int(obj8, &val9);
5801  if (!SWIG_IsOK(ecode9)) {
5802  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5803  }
5804  arg9 = (PLINT)(val9);
5805  ecode10 = SWIG_AsVal_int(obj9, &val10);
5806  if (!SWIG_IsOK(ecode10)) {
5807  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5808  }
5809  arg10 = (PLINT)(val10);
5810  ecode11 = SWIG_AsVal_double(obj10, &val11);
5811  if (!SWIG_IsOK(ecode11)) {
5812  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5813  }
5814  arg11 = (PLFLT)(val11);
5815  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5816  resultobj = SWIG_Py_Void();
5817  return resultobj;
5818 fail:
5819  return NULL;
5820 }
5821 
5822 
5823 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824  PyObject *resultobj = 0;
5825  PLFLT **arg1 = (PLFLT **) 0 ;
5826  PLINT arg2 ;
5827  PLINT arg3 ;
5828  PLINT arg4 ;
5829  PLINT arg5 ;
5830  PLINT arg6 ;
5831  PLINT arg7 ;
5832  PLFLT *arg8 = (PLFLT *) 0 ;
5833  PLINT arg9 ;
5834  pltr_func arg10 = (pltr_func) 0 ;
5835  PLPointer arg11 = (PLPointer) 0 ;
5836  PyArrayObject *tmp1 = NULL ;
5837  int val4 ;
5838  int ecode4 = 0 ;
5839  int val5 ;
5840  int ecode5 = 0 ;
5841  int val6 ;
5842  int ecode6 = 0 ;
5843  int val7 ;
5844  int ecode7 = 0 ;
5845  PyArrayObject *tmp8 = NULL ;
5846  PyObject * obj0 = 0 ;
5847  PyObject * obj1 = 0 ;
5848  PyObject * obj2 = 0 ;
5849  PyObject * obj3 = 0 ;
5850  PyObject * obj4 = 0 ;
5851  PyObject * obj5 = 0 ;
5852  PyObject * obj6 = 0 ;
5853  PyObject * obj7 = 0 ;
5854 
5855  {
5856  python_pltr = 0;
5857  arg10 = NULL;
5858  }
5859  {
5860  arg11 = NULL;
5861  }
5862  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5863  {
5864  int i, size;
5865  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5866  if ( tmp1 == NULL )
5867  return NULL;
5868  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5869  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5870  size = arg3;
5871  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5872  for ( i = 0; i < arg2; i++ )
5873  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5874  }
5875  ecode4 = SWIG_AsVal_int(obj1, &val4);
5876  if (!SWIG_IsOK(ecode4)) {
5877  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5878  }
5879  arg4 = (PLINT)(val4);
5880  ecode5 = SWIG_AsVal_int(obj2, &val5);
5881  if (!SWIG_IsOK(ecode5)) {
5882  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5883  }
5884  arg5 = (PLINT)(val5);
5885  ecode6 = SWIG_AsVal_int(obj3, &val6);
5886  if (!SWIG_IsOK(ecode6)) {
5887  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5888  }
5889  arg6 = (PLINT)(val6);
5890  ecode7 = SWIG_AsVal_int(obj4, &val7);
5891  if (!SWIG_IsOK(ecode7)) {
5892  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5893  }
5894  arg7 = (PLINT)(val7);
5895  {
5896  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5897  if ( tmp8 == NULL )
5898  return NULL;
5899  arg9 = PyArray_DIMS( tmp8 )[0];
5900  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5901  }
5902  if (obj6) {
5903  {
5904  // it must be a callable or None
5905  if ( obj6 == Py_None )
5906  {
5907  arg10 = NULL;
5908  }
5909  else
5910  {
5911  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5912  {
5913  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5914  return NULL;
5915  }
5916  arg10 = marshal_pltr( obj6 );
5917  }
5918  }
5919  }
5920  if (obj7) {
5921  {
5922  if ( obj7 == Py_None )
5923  arg11 = NULL;
5924  else
5925  {
5926  arg11 = marshal_PLPointer( obj7, 0 );
5927  }
5928  }
5929  }
5930  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5931  resultobj = SWIG_Py_Void();
5932  {
5933  Py_CLEAR( tmp1 );
5934  free( arg1 );
5935  }
5936  {
5937  Py_CLEAR( tmp8 );
5938  }
5939  {
5940  cleanup_pltr();
5941  }
5942  {
5944  }
5945  return resultobj;
5946 fail:
5947  {
5948  Py_CLEAR( tmp1 );
5949  free( arg1 );
5950  }
5951  {
5952  Py_CLEAR( tmp8 );
5953  }
5954  {
5955  cleanup_pltr();
5956  }
5957  {
5959  }
5960  return NULL;
5961 }
5962 
5963 
5964 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5965  PyObject *resultobj = 0;
5966  PLINT arg1 ;
5967  PLINT arg2 ;
5968  PLINT arg3 ;
5969  PLINT arg4 ;
5970  PLINT arg5 ;
5971  PLFLT arg6 ;
5972  PLFLT *arg7 = (PLFLT *) 0 ;
5973  int val1 ;
5974  int ecode1 = 0 ;
5975  int val2 ;
5976  int ecode2 = 0 ;
5977  int val3 ;
5978  int ecode3 = 0 ;
5979  int val4 ;
5980  int ecode4 = 0 ;
5981  int val5 ;
5982  int ecode5 = 0 ;
5983  double val6 ;
5984  int ecode6 = 0 ;
5985  PLFLT temp7 ;
5986  int res7 = SWIG_TMPOBJ ;
5987  PyObject * obj0 = 0 ;
5988  PyObject * obj1 = 0 ;
5989  PyObject * obj2 = 0 ;
5990  PyObject * obj3 = 0 ;
5991  PyObject * obj4 = 0 ;
5992  PyObject * obj5 = 0 ;
5993 
5994  arg7 = &temp7;
5995  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5996  ecode1 = SWIG_AsVal_int(obj0, &val1);
5997  if (!SWIG_IsOK(ecode1)) {
5998  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5999  }
6000  arg1 = (PLINT)(val1);
6001  ecode2 = SWIG_AsVal_int(obj1, &val2);
6002  if (!SWIG_IsOK(ecode2)) {
6003  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6004  }
6005  arg2 = (PLINT)(val2);
6006  ecode3 = SWIG_AsVal_int(obj2, &val3);
6007  if (!SWIG_IsOK(ecode3)) {
6008  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6009  }
6010  arg3 = (PLINT)(val3);
6011  ecode4 = SWIG_AsVal_int(obj3, &val4);
6012  if (!SWIG_IsOK(ecode4)) {
6013  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6014  }
6015  arg4 = (PLINT)(val4);
6016  ecode5 = SWIG_AsVal_int(obj4, &val5);
6017  if (!SWIG_IsOK(ecode5)) {
6018  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6019  }
6020  arg5 = (PLINT)(val5);
6021  ecode6 = SWIG_AsVal_double(obj5, &val6);
6022  if (!SWIG_IsOK(ecode6)) {
6023  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6024  }
6025  arg6 = (PLFLT)(val6);
6026  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6027  resultobj = SWIG_Py_Void();
6028  if (SWIG_IsTmpObj(res7)) {
6029  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6030  } else {
6031  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6032  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6033  }
6034  return resultobj;
6035 fail:
6036  return NULL;
6037 }
6038 
6039 
6040 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6041  PyObject *resultobj = 0;
6042  PLINT arg1 ;
6043  PLBOOL arg2 ;
6044  int val1 ;
6045  int ecode1 = 0 ;
6046  int val2 ;
6047  int ecode2 = 0 ;
6048  PyObject * obj0 = 0 ;
6049  PyObject * obj1 = 0 ;
6050 
6051  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
6052  ecode1 = SWIG_AsVal_int(obj0, &val1);
6053  if (!SWIG_IsOK(ecode1)) {
6054  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6055  }
6056  arg1 = (PLINT)(val1);
6057  ecode2 = SWIG_AsVal_int(obj1, &val2);
6058  if (!SWIG_IsOK(ecode2)) {
6059  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6060  }
6061  arg2 = (PLBOOL)(val2);
6062  plcpstrm(arg1,arg2);
6063  resultobj = SWIG_Py_Void();
6064  return resultobj;
6065 fail:
6066  return NULL;
6067 }
6068 
6069 
6070 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6071  PyObject *resultobj = 0;
6072 
6073  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
6074  plend();
6075  resultobj = SWIG_Py_Void();
6076  return resultobj;
6077 fail:
6078  return NULL;
6079 }
6080 
6081 
6082 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083  PyObject *resultobj = 0;
6084 
6085  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
6086  plend1();
6087  resultobj = SWIG_Py_Void();
6088  return resultobj;
6089 fail:
6090  return NULL;
6091 }
6092 
6093 
6094 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6095  PyObject *resultobj = 0;
6096  PLFLT arg1 ;
6097  PLFLT arg2 ;
6098  PLFLT arg3 ;
6099  PLFLT arg4 ;
6100  PLINT arg5 ;
6101  PLINT arg6 ;
6102  double val1 ;
6103  int ecode1 = 0 ;
6104  double val2 ;
6105  int ecode2 = 0 ;
6106  double val3 ;
6107  int ecode3 = 0 ;
6108  double val4 ;
6109  int ecode4 = 0 ;
6110  int val5 ;
6111  int ecode5 = 0 ;
6112  int val6 ;
6113  int ecode6 = 0 ;
6114  PyObject * obj0 = 0 ;
6115  PyObject * obj1 = 0 ;
6116  PyObject * obj2 = 0 ;
6117  PyObject * obj3 = 0 ;
6118  PyObject * obj4 = 0 ;
6119  PyObject * obj5 = 0 ;
6120 
6121  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6122  ecode1 = SWIG_AsVal_double(obj0, &val1);
6123  if (!SWIG_IsOK(ecode1)) {
6124  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6125  }
6126  arg1 = (PLFLT)(val1);
6127  ecode2 = SWIG_AsVal_double(obj1, &val2);
6128  if (!SWIG_IsOK(ecode2)) {
6129  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6130  }
6131  arg2 = (PLFLT)(val2);
6132  ecode3 = SWIG_AsVal_double(obj2, &val3);
6133  if (!SWIG_IsOK(ecode3)) {
6134  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6135  }
6136  arg3 = (PLFLT)(val3);
6137  ecode4 = SWIG_AsVal_double(obj3, &val4);
6138  if (!SWIG_IsOK(ecode4)) {
6139  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6140  }
6141  arg4 = (PLFLT)(val4);
6142  ecode5 = SWIG_AsVal_int(obj4, &val5);
6143  if (!SWIG_IsOK(ecode5)) {
6144  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6145  }
6146  arg5 = (PLINT)(val5);
6147  ecode6 = SWIG_AsVal_int(obj5, &val6);
6148  if (!SWIG_IsOK(ecode6)) {
6149  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6150  }
6151  arg6 = (PLINT)(val6);
6152  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6153  resultobj = SWIG_Py_Void();
6154  return resultobj;
6155 fail:
6156  return NULL;
6157 }
6158 
6159 
6160 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6161  PyObject *resultobj = 0;
6162  PLFLT arg1 ;
6163  PLFLT arg2 ;
6164  PLFLT arg3 ;
6165  PLFLT arg4 ;
6166  PLINT arg5 ;
6167  PLINT arg6 ;
6168  double val1 ;
6169  int ecode1 = 0 ;
6170  double val2 ;
6171  int ecode2 = 0 ;
6172  double val3 ;
6173  int ecode3 = 0 ;
6174  double val4 ;
6175  int ecode4 = 0 ;
6176  int val5 ;
6177  int ecode5 = 0 ;
6178  int val6 ;
6179  int ecode6 = 0 ;
6180  PyObject * obj0 = 0 ;
6181  PyObject * obj1 = 0 ;
6182  PyObject * obj2 = 0 ;
6183  PyObject * obj3 = 0 ;
6184  PyObject * obj4 = 0 ;
6185  PyObject * obj5 = 0 ;
6186 
6187  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6188  ecode1 = SWIG_AsVal_double(obj0, &val1);
6189  if (!SWIG_IsOK(ecode1)) {
6190  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6191  }
6192  arg1 = (PLFLT)(val1);
6193  ecode2 = SWIG_AsVal_double(obj1, &val2);
6194  if (!SWIG_IsOK(ecode2)) {
6195  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6196  }
6197  arg2 = (PLFLT)(val2);
6198  ecode3 = SWIG_AsVal_double(obj2, &val3);
6199  if (!SWIG_IsOK(ecode3)) {
6200  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6201  }
6202  arg3 = (PLFLT)(val3);
6203  ecode4 = SWIG_AsVal_double(obj3, &val4);
6204  if (!SWIG_IsOK(ecode4)) {
6205  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6206  }
6207  arg4 = (PLFLT)(val4);
6208  ecode5 = SWIG_AsVal_int(obj4, &val5);
6209  if (!SWIG_IsOK(ecode5)) {
6210  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6211  }
6212  arg5 = (PLINT)(val5);
6213  ecode6 = SWIG_AsVal_int(obj5, &val6);
6214  if (!SWIG_IsOK(ecode6)) {
6215  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6216  }
6217  arg6 = (PLINT)(val6);
6218  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6219  resultobj = SWIG_Py_Void();
6220  return resultobj;
6221 fail:
6222  return NULL;
6223 }
6224 
6225 
6226 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6227  PyObject *resultobj = 0;
6228 
6229  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6230  pleop();
6231  resultobj = SWIG_Py_Void();
6232  return resultobj;
6233 fail:
6234  return NULL;
6235 }
6236 
6237 
6238 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6239  PyObject *resultobj = 0;
6240  PLINT arg1 ;
6241  PLFLT *arg2 = (PLFLT *) 0 ;
6242  PLFLT *arg3 = (PLFLT *) 0 ;
6243  PLFLT *arg4 = (PLFLT *) 0 ;
6244  PyArrayObject *tmp1 = NULL ;
6245  PyArrayObject *tmp3 = NULL ;
6246  PyArrayObject *tmp4 = NULL ;
6247  PyObject * obj0 = 0 ;
6248  PyObject * obj1 = 0 ;
6249  PyObject * obj2 = 0 ;
6250 
6251  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6252  {
6253  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6254  if ( tmp1 == NULL )
6255  return NULL;
6256  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6257  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6258  }
6259  {
6260  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6261  if ( tmp3 == NULL )
6262  return NULL;
6263  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6264  {
6265  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6266  return NULL;
6267  }
6268  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6269  }
6270  {
6271  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6272  if ( tmp4 == NULL )
6273  return NULL;
6274  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6275  {
6276  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6277  return NULL;
6278  }
6279  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6280  }
6281  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6282  resultobj = SWIG_Py_Void();
6283  {
6284  Py_CLEAR( tmp1 );
6285  }
6286  {
6287  Py_CLEAR( tmp3 );
6288  }
6289  {
6290  Py_CLEAR( tmp4 );
6291  }
6292  return resultobj;
6293 fail:
6294  {
6295  Py_CLEAR( tmp1 );
6296  }
6297  {
6298  Py_CLEAR( tmp3 );
6299  }
6300  {
6301  Py_CLEAR( tmp4 );
6302  }
6303  return NULL;
6304 }
6305 
6306 
6307 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6308  PyObject *resultobj = 0;
6309  PLINT arg1 ;
6310  PLFLT *arg2 = (PLFLT *) 0 ;
6311  PLFLT *arg3 = (PLFLT *) 0 ;
6312  PLFLT *arg4 = (PLFLT *) 0 ;
6313  PyArrayObject *tmp1 = NULL ;
6314  PyArrayObject *tmp3 = NULL ;
6315  PyArrayObject *tmp4 = NULL ;
6316  PyObject * obj0 = 0 ;
6317  PyObject * obj1 = 0 ;
6318  PyObject * obj2 = 0 ;
6319 
6320  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6321  {
6322  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6323  if ( tmp1 == NULL )
6324  return NULL;
6325  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6326  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6327  }
6328  {
6329  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6330  if ( tmp3 == NULL )
6331  return NULL;
6332  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6333  {
6334  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6335  return NULL;
6336  }
6337  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6338  }
6339  {
6340  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6341  if ( tmp4 == NULL )
6342  return NULL;
6343  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6344  {
6345  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6346  return NULL;
6347  }
6348  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6349  }
6350  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6351  resultobj = SWIG_Py_Void();
6352  {
6353  Py_CLEAR( tmp1 );
6354  }
6355  {
6356  Py_CLEAR( tmp3 );
6357  }
6358  {
6359  Py_CLEAR( tmp4 );
6360  }
6361  return resultobj;
6362 fail:
6363  {
6364  Py_CLEAR( tmp1 );
6365  }
6366  {
6367  Py_CLEAR( tmp3 );
6368  }
6369  {
6370  Py_CLEAR( tmp4 );
6371  }
6372  return NULL;
6373 }
6374 
6375 
6376 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6377  PyObject *resultobj = 0;
6378 
6379  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6380  plfamadv();
6381  resultobj = SWIG_Py_Void();
6382  return resultobj;
6383 fail:
6384  return NULL;
6385 }
6386 
6387 
6388 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6389  PyObject *resultobj = 0;
6390  PLINT arg1 ;
6391  PLFLT *arg2 = (PLFLT *) 0 ;
6392  PLFLT *arg3 = (PLFLT *) 0 ;
6393  PyArrayObject *tmp1 = NULL ;
6394  PyArrayObject *tmp3 = NULL ;
6395  PyObject * obj0 = 0 ;
6396  PyObject * obj1 = 0 ;
6397 
6398  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6399  {
6400  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6401  if ( tmp1 == NULL )
6402  return NULL;
6403  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6404  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6405  }
6406  {
6407  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6408  if ( tmp3 == NULL )
6409  return NULL;
6410  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6411  {
6412  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6413  return NULL;
6414  }
6415  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6416  }
6417  plfill(arg1,(double const *)arg2,(double const *)arg3);
6418  resultobj = SWIG_Py_Void();
6419  {
6420  Py_CLEAR( tmp1 );
6421  }
6422  {
6423  Py_CLEAR( tmp3 );
6424  }
6425  return resultobj;
6426 fail:
6427  {
6428  Py_CLEAR( tmp1 );
6429  }
6430  {
6431  Py_CLEAR( tmp3 );
6432  }
6433  return NULL;
6434 }
6435 
6436 
6437 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438  PyObject *resultobj = 0;
6439  PLINT arg1 ;
6440  PLFLT *arg2 = (PLFLT *) 0 ;
6441  PLFLT *arg3 = (PLFLT *) 0 ;
6442  PLFLT *arg4 = (PLFLT *) 0 ;
6443  PyArrayObject *tmp1 = NULL ;
6444  PyArrayObject *tmp3 = NULL ;
6445  PyArrayObject *tmp4 = NULL ;
6446  PyObject * obj0 = 0 ;
6447  PyObject * obj1 = 0 ;
6448  PyObject * obj2 = 0 ;
6449 
6450  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6451  {
6452  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6453  if ( tmp1 == NULL )
6454  return NULL;
6455  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6456  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6457  }
6458  {
6459  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6460  if ( tmp3 == NULL )
6461  return NULL;
6462  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6463  {
6464  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6465  return NULL;
6466  }
6467  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6468  }
6469  {
6470  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6471  if ( tmp4 == NULL )
6472  return NULL;
6473  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6474  {
6475  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6476  return NULL;
6477  }
6478  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6479  }
6480  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6481  resultobj = SWIG_Py_Void();
6482  {
6483  Py_CLEAR( tmp1 );
6484  }
6485  {
6486  Py_CLEAR( tmp3 );
6487  }
6488  {
6489  Py_CLEAR( tmp4 );
6490  }
6491  return resultobj;
6492 fail:
6493  {
6494  Py_CLEAR( tmp1 );
6495  }
6496  {
6497  Py_CLEAR( tmp3 );
6498  }
6499  {
6500  Py_CLEAR( tmp4 );
6501  }
6502  return NULL;
6503 }
6504 
6505 
6506 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6507  PyObject *resultobj = 0;
6508  PLINT arg1 ;
6509  PLFLT *arg2 = (PLFLT *) 0 ;
6510  PLFLT *arg3 = (PLFLT *) 0 ;
6511  PLFLT arg4 ;
6512  PyArrayObject *tmp1 = NULL ;
6513  PyArrayObject *tmp3 = NULL ;
6514  double val4 ;
6515  int ecode4 = 0 ;
6516  PyObject * obj0 = 0 ;
6517  PyObject * obj1 = 0 ;
6518  PyObject * obj2 = 0 ;
6519 
6520  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6521  {
6522  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6523  if ( tmp1 == NULL )
6524  return NULL;
6525  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6526  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6527  }
6528  {
6529  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6530  if ( tmp3 == NULL )
6531  return NULL;
6532  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6533  {
6534  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6535  return NULL;
6536  }
6537  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6538  }
6539  ecode4 = SWIG_AsVal_double(obj2, &val4);
6540  if (!SWIG_IsOK(ecode4)) {
6541  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6542  }
6543  arg4 = (PLFLT)(val4);
6544  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6545  resultobj = SWIG_Py_Void();
6546  {
6547  Py_CLEAR( tmp1 );
6548  }
6549  {
6550  Py_CLEAR( tmp3 );
6551  }
6552  return resultobj;
6553 fail:
6554  {
6555  Py_CLEAR( tmp1 );
6556  }
6557  {
6558  Py_CLEAR( tmp3 );
6559  }
6560  return NULL;
6561 }
6562 
6563 
6564 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6565  PyObject *resultobj = 0;
6566 
6567  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6568  plflush();
6569  resultobj = SWIG_Py_Void();
6570  return resultobj;
6571 fail:
6572  return NULL;
6573 }
6574 
6575 
6576 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6577  PyObject *resultobj = 0;
6578  PLINT arg1 ;
6579  int val1 ;
6580  int ecode1 = 0 ;
6581  PyObject * obj0 = 0 ;
6582 
6583  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6584  ecode1 = SWIG_AsVal_int(obj0, &val1);
6585  if (!SWIG_IsOK(ecode1)) {
6586  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6587  }
6588  arg1 = (PLINT)(val1);
6589  plfont(arg1);
6590  resultobj = SWIG_Py_Void();
6591  return resultobj;
6592 fail:
6593  return NULL;
6594 }
6595 
6596 
6597 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6598  PyObject *resultobj = 0;
6599  PLINT arg1 ;
6600  int val1 ;
6601  int ecode1 = 0 ;
6602  PyObject * obj0 = 0 ;
6603 
6604  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6605  ecode1 = SWIG_AsVal_int(obj0, &val1);
6606  if (!SWIG_IsOK(ecode1)) {
6607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6608  }
6609  arg1 = (PLINT)(val1);
6610  plfontld(arg1);
6611  resultobj = SWIG_Py_Void();
6612  return resultobj;
6613 fail:
6614  return NULL;
6615 }
6616 
6617 
6618 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6619  PyObject *resultobj = 0;
6620  PLFLT *arg1 = (PLFLT *) 0 ;
6621  PLFLT *arg2 = (PLFLT *) 0 ;
6622  PLFLT temp1 ;
6623  int res1 = SWIG_TMPOBJ ;
6624  PLFLT temp2 ;
6625  int res2 = SWIG_TMPOBJ ;
6626 
6627  arg1 = &temp1;
6628  arg2 = &temp2;
6629  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6630  plgchr(arg1,arg2);
6631  resultobj = SWIG_Py_Void();
6632  if (SWIG_IsTmpObj(res1)) {
6633  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6634  } else {
6635  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6636  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6637  }
6638  if (SWIG_IsTmpObj(res2)) {
6639  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6640  } else {
6641  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6642  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6643  }
6644  return resultobj;
6645 fail:
6646  return NULL;
6647 }
6648 
6649 
6650 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6651  PyObject *resultobj = 0;
6652  PLINT arg1 ;
6653  PLINT *arg2 = (PLINT *) 0 ;
6654  PLINT *arg3 = (PLINT *) 0 ;
6655  PLINT *arg4 = (PLINT *) 0 ;
6656  int val1 ;
6657  int ecode1 = 0 ;
6658  PLINT temp2 ;
6659  int res2 = SWIG_TMPOBJ ;
6660  PLINT temp3 ;
6661  int res3 = SWIG_TMPOBJ ;
6662  PLINT temp4 ;
6663  int res4 = SWIG_TMPOBJ ;
6664  PyObject * obj0 = 0 ;
6665 
6666  arg2 = &temp2;
6667  arg3 = &temp3;
6668  arg4 = &temp4;
6669  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6670  ecode1 = SWIG_AsVal_int(obj0, &val1);
6671  if (!SWIG_IsOK(ecode1)) {
6672  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6673  }
6674  arg1 = (PLINT)(val1);
6675  plgcol0(arg1,arg2,arg3,arg4);
6676  resultobj = SWIG_Py_Void();
6677  if (SWIG_IsTmpObj(res2)) {
6678  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6679  } else {
6680  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6681  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6682  }
6683  if (SWIG_IsTmpObj(res3)) {
6684  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6685  } else {
6686  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6687  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6688  }
6689  if (SWIG_IsTmpObj(res4)) {
6690  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6691  } else {
6692  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6693  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6694  }
6695  return resultobj;
6696 fail:
6697  return NULL;
6698 }
6699 
6700 
6701 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702  PyObject *resultobj = 0;
6703  PLINT arg1 ;
6704  PLINT *arg2 = (PLINT *) 0 ;
6705  PLINT *arg3 = (PLINT *) 0 ;
6706  PLINT *arg4 = (PLINT *) 0 ;
6707  PLFLT *arg5 = (PLFLT *) 0 ;
6708  int val1 ;
6709  int ecode1 = 0 ;
6710  PLINT temp2 ;
6711  int res2 = SWIG_TMPOBJ ;
6712  PLINT temp3 ;
6713  int res3 = SWIG_TMPOBJ ;
6714  PLINT temp4 ;
6715  int res4 = SWIG_TMPOBJ ;
6716  PLFLT temp5 ;
6717  int res5 = SWIG_TMPOBJ ;
6718  PyObject * obj0 = 0 ;
6719 
6720  arg2 = &temp2;
6721  arg3 = &temp3;
6722  arg4 = &temp4;
6723  arg5 = &temp5;
6724  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6725  ecode1 = SWIG_AsVal_int(obj0, &val1);
6726  if (!SWIG_IsOK(ecode1)) {
6727  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6728  }
6729  arg1 = (PLINT)(val1);
6730  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6731  resultobj = SWIG_Py_Void();
6732  if (SWIG_IsTmpObj(res2)) {
6733  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6734  } else {
6735  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6736  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6737  }
6738  if (SWIG_IsTmpObj(res3)) {
6739  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6740  } else {
6741  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6742  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6743  }
6744  if (SWIG_IsTmpObj(res4)) {
6745  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6746  } else {
6747  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6748  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6749  }
6750  if (SWIG_IsTmpObj(res5)) {
6751  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6752  } else {
6753  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6754  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6755  }
6756  return resultobj;
6757 fail:
6758  return NULL;
6759 }
6760 
6761 
6762 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763  PyObject *resultobj = 0;
6764  PLINT *arg1 = (PLINT *) 0 ;
6765  PLINT *arg2 = (PLINT *) 0 ;
6766  PLINT *arg3 = (PLINT *) 0 ;
6767  PLINT temp1 ;
6768  int res1 = SWIG_TMPOBJ ;
6769  PLINT temp2 ;
6770  int res2 = SWIG_TMPOBJ ;
6771  PLINT temp3 ;
6772  int res3 = SWIG_TMPOBJ ;
6773 
6774  arg1 = &temp1;
6775  arg2 = &temp2;
6776  arg3 = &temp3;
6777  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6778  plgcolbg(arg1,arg2,arg3);
6779  resultobj = SWIG_Py_Void();
6780  if (SWIG_IsTmpObj(res1)) {
6781  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6782  } else {
6783  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6784  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6785  }
6786  if (SWIG_IsTmpObj(res2)) {
6787  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6788  } else {
6789  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6790  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6791  }
6792  if (SWIG_IsTmpObj(res3)) {
6793  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6794  } else {
6795  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6796  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6797  }
6798  return resultobj;
6799 fail:
6800  return NULL;
6801 }
6802 
6803 
6804 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805  PyObject *resultobj = 0;
6806  PLINT *arg1 = (PLINT *) 0 ;
6807  PLINT *arg2 = (PLINT *) 0 ;
6808  PLINT *arg3 = (PLINT *) 0 ;
6809  PLFLT *arg4 = (PLFLT *) 0 ;
6810  PLINT temp1 ;
6811  int res1 = SWIG_TMPOBJ ;
6812  PLINT temp2 ;
6813  int res2 = SWIG_TMPOBJ ;
6814  PLINT temp3 ;
6815  int res3 = SWIG_TMPOBJ ;
6816  PLFLT temp4 ;
6817  int res4 = SWIG_TMPOBJ ;
6818 
6819  arg1 = &temp1;
6820  arg2 = &temp2;
6821  arg3 = &temp3;
6822  arg4 = &temp4;
6823  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6824  plgcolbga(arg1,arg2,arg3,arg4);
6825  resultobj = SWIG_Py_Void();
6826  if (SWIG_IsTmpObj(res1)) {
6827  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6828  } else {
6829  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6830  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6831  }
6832  if (SWIG_IsTmpObj(res2)) {
6833  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6834  } else {
6835  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6836  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6837  }
6838  if (SWIG_IsTmpObj(res3)) {
6839  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6840  } else {
6841  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6842  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6843  }
6844  if (SWIG_IsTmpObj(res4)) {
6845  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6846  } else {
6847  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6848  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6849  }
6850  return resultobj;
6851 fail:
6852  return NULL;
6853 }
6854 
6855 
6856 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857  PyObject *resultobj = 0;
6858  PLINT *arg1 = (PLINT *) 0 ;
6859  PLINT temp1 ;
6860  int res1 = SWIG_TMPOBJ ;
6861 
6862  arg1 = &temp1;
6863  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6864  plgcompression(arg1);
6865  resultobj = SWIG_Py_Void();
6866  if (SWIG_IsTmpObj(res1)) {
6867  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6868  } else {
6869  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6870  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6871  }
6872  return resultobj;
6873 fail:
6874  return NULL;
6875 }
6876 
6877 
6878 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6879  PyObject *resultobj = 0;
6880  char *arg1 = (char *) 0 ;
6881  char buff1[1000] ;
6882 
6883  {
6884  arg1 = buff1;
6885  }
6886  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6887  plgdev(arg1);
6888  resultobj = SWIG_Py_Void();
6889  {
6890  PyObject *o = PyString_FromString( arg1 );
6891  resultobj = t_output_helper( resultobj, o );
6892  }
6893  return resultobj;
6894 fail:
6895  return NULL;
6896 }
6897 
6898 
6899 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6900  PyObject *resultobj = 0;
6901  PLFLT *arg1 = (PLFLT *) 0 ;
6902  PLFLT *arg2 = (PLFLT *) 0 ;
6903  PLFLT *arg3 = (PLFLT *) 0 ;
6904  PLFLT *arg4 = (PLFLT *) 0 ;
6905  PLFLT temp1 ;
6906  int res1 = SWIG_TMPOBJ ;
6907  PLFLT temp2 ;
6908  int res2 = SWIG_TMPOBJ ;
6909  PLFLT temp3 ;
6910  int res3 = SWIG_TMPOBJ ;
6911  PLFLT temp4 ;
6912  int res4 = SWIG_TMPOBJ ;
6913 
6914  arg1 = &temp1;
6915  arg2 = &temp2;
6916  arg3 = &temp3;
6917  arg4 = &temp4;
6918  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6919  plgdidev(arg1,arg2,arg3,arg4);
6920  resultobj = SWIG_Py_Void();
6921  if (SWIG_IsTmpObj(res1)) {
6922  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6923  } else {
6924  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6925  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6926  }
6927  if (SWIG_IsTmpObj(res2)) {
6928  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6929  } else {
6930  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6931  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6932  }
6933  if (SWIG_IsTmpObj(res3)) {
6934  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6935  } else {
6936  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6937  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6938  }
6939  if (SWIG_IsTmpObj(res4)) {
6940  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6941  } else {
6942  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6943  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6944  }
6945  return resultobj;
6946 fail:
6947  return NULL;
6948 }
6949 
6950 
6951 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6952  PyObject *resultobj = 0;
6953  PLFLT *arg1 = (PLFLT *) 0 ;
6954  PLFLT temp1 ;
6955  int res1 = SWIG_TMPOBJ ;
6956 
6957  arg1 = &temp1;
6958  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6959  plgdiori(arg1);
6960  resultobj = SWIG_Py_Void();
6961  if (SWIG_IsTmpObj(res1)) {
6962  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6963  } else {
6964  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6965  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6966  }
6967  return resultobj;
6968 fail:
6969  return NULL;
6970 }
6971 
6972 
6973 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6974  PyObject *resultobj = 0;
6975  PLFLT *arg1 = (PLFLT *) 0 ;
6976  PLFLT *arg2 = (PLFLT *) 0 ;
6977  PLFLT *arg3 = (PLFLT *) 0 ;
6978  PLFLT *arg4 = (PLFLT *) 0 ;
6979  PLFLT temp1 ;
6980  int res1 = SWIG_TMPOBJ ;
6981  PLFLT temp2 ;
6982  int res2 = SWIG_TMPOBJ ;
6983  PLFLT temp3 ;
6984  int res3 = SWIG_TMPOBJ ;
6985  PLFLT temp4 ;
6986  int res4 = SWIG_TMPOBJ ;
6987 
6988  arg1 = &temp1;
6989  arg2 = &temp2;
6990  arg3 = &temp3;
6991  arg4 = &temp4;
6992  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6993  plgdiplt(arg1,arg2,arg3,arg4);
6994  resultobj = SWIG_Py_Void();
6995  if (SWIG_IsTmpObj(res1)) {
6996  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6997  } else {
6998  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6999  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7000  }
7001  if (SWIG_IsTmpObj(res2)) {
7002  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7003  } else {
7004  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7005  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7006  }
7007  if (SWIG_IsTmpObj(res3)) {
7008  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7009  } else {
7010  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7011  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7012  }
7013  if (SWIG_IsTmpObj(res4)) {
7014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7015  } else {
7016  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7017  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7018  }
7019  return resultobj;
7020 fail:
7021  return NULL;
7022 }
7023 
7024 
7025 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7026  PyObject *resultobj = 0;
7027  PLINT *arg1 = (PLINT *) 0 ;
7028  PLINT *arg2 = (PLINT *) 0 ;
7029  PLINT *arg3 = (PLINT *) 0 ;
7030  PLINT temp1 ;
7031  int res1 = SWIG_TMPOBJ ;
7032  PLINT temp2 ;
7033  int res2 = SWIG_TMPOBJ ;
7034  PLINT temp3 ;
7035  int res3 = SWIG_TMPOBJ ;
7036 
7037  arg1 = &temp1;
7038  arg2 = &temp2;
7039  arg3 = &temp3;
7040  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
7041  plgfam(arg1,arg2,arg3);
7042  resultobj = SWIG_Py_Void();
7043  if (SWIG_IsTmpObj(res1)) {
7044  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7045  } else {
7046  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7047  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7048  }
7049  if (SWIG_IsTmpObj(res2)) {
7050  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7051  } else {
7052  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7053  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7054  }
7055  if (SWIG_IsTmpObj(res3)) {
7056  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7057  } else {
7058  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7059  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7060  }
7061  return resultobj;
7062 fail:
7063  return NULL;
7064 }
7065 
7066 
7067 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7068  PyObject *resultobj = 0;
7069  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7070  PLUNICODE temp1 ;
7071  int res1 = SWIG_TMPOBJ ;
7072 
7073  arg1 = &temp1;
7074  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
7075  plgfci(arg1);
7076  resultobj = SWIG_Py_Void();
7077  if (SWIG_IsTmpObj(res1)) {
7078  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7079  } else {
7080  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7081  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7082  }
7083  return resultobj;
7084 fail:
7085  return NULL;
7086 }
7087 
7088 
7089 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7090  PyObject *resultobj = 0;
7091  char *arg1 = (char *) 0 ;
7092  char buff1[1000] ;
7093 
7094  {
7095  arg1 = buff1;
7096  }
7097  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
7098  plgfnam(arg1);
7099  resultobj = SWIG_Py_Void();
7100  {
7101  PyObject *o = PyString_FromString( arg1 );
7102  resultobj = t_output_helper( resultobj, o );
7103  }
7104  return resultobj;
7105 fail:
7106  return NULL;
7107 }
7108 
7109 
7110 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7111  PyObject *resultobj = 0;
7112  PLINT *arg1 = (PLINT *) 0 ;
7113  PLINT *arg2 = (PLINT *) 0 ;
7114  PLINT *arg3 = (PLINT *) 0 ;
7115  PLINT temp1 ;
7116  int res1 = SWIG_TMPOBJ ;
7117  PLINT temp2 ;
7118  int res2 = SWIG_TMPOBJ ;
7119  PLINT temp3 ;
7120  int res3 = SWIG_TMPOBJ ;
7121 
7122  arg1 = &temp1;
7123  arg2 = &temp2;
7124  arg3 = &temp3;
7125  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
7126  plgfont(arg1,arg2,arg3);
7127  resultobj = SWIG_Py_Void();
7128  if (SWIG_IsTmpObj(res1)) {
7129  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7130  } else {
7131  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7132  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7133  }
7134  if (SWIG_IsTmpObj(res2)) {
7135  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7136  } else {
7137  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7138  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7139  }
7140  if (SWIG_IsTmpObj(res3)) {
7141  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7142  } else {
7143  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7144  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7145  }
7146  return resultobj;
7147 fail:
7148  return NULL;
7149 }
7150 
7151 
7152 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7153  PyObject *resultobj = 0;
7154  PLINT *arg1 = (PLINT *) 0 ;
7155  PLINT temp1 ;
7156  int res1 = SWIG_TMPOBJ ;
7157 
7158  arg1 = &temp1;
7159  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7160  plglevel(arg1);
7161  resultobj = SWIG_Py_Void();
7162  if (SWIG_IsTmpObj(res1)) {
7163  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7164  } else {
7165  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7166  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7167  }
7168  return resultobj;
7169 fail:
7170  return NULL;
7171 }
7172 
7173 
7174 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7175  PyObject *resultobj = 0;
7176  PLFLT *arg1 = (PLFLT *) 0 ;
7177  PLFLT *arg2 = (PLFLT *) 0 ;
7178  PLINT *arg3 = (PLINT *) 0 ;
7179  PLINT *arg4 = (PLINT *) 0 ;
7180  PLINT *arg5 = (PLINT *) 0 ;
7181  PLINT *arg6 = (PLINT *) 0 ;
7182  PLFLT temp1 ;
7183  int res1 = SWIG_TMPOBJ ;
7184  PLFLT temp2 ;
7185  int res2 = SWIG_TMPOBJ ;
7186  PLINT temp3 ;
7187  int res3 = SWIG_TMPOBJ ;
7188  PLINT temp4 ;
7189  int res4 = SWIG_TMPOBJ ;
7190  PLINT temp5 ;
7191  int res5 = SWIG_TMPOBJ ;
7192  PLINT temp6 ;
7193  int res6 = SWIG_TMPOBJ ;
7194 
7195  arg1 = &temp1;
7196  arg2 = &temp2;
7197  arg3 = &temp3;
7198  arg4 = &temp4;
7199  arg5 = &temp5;
7200  arg6 = &temp6;
7201  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7202  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7203  resultobj = SWIG_Py_Void();
7204  if (SWIG_IsTmpObj(res1)) {
7205  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7206  } else {
7207  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7208  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7209  }
7210  if (SWIG_IsTmpObj(res2)) {
7211  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7212  } else {
7213  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7214  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7215  }
7216  if (SWIG_IsTmpObj(res3)) {
7217  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7218  } else {
7219  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7220  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7221  }
7222  if (SWIG_IsTmpObj(res4)) {
7223  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7224  } else {
7225  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7226  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7227  }
7228  if (SWIG_IsTmpObj(res5)) {
7229  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7230  } else {
7231  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7232  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7233  }
7234  if (SWIG_IsTmpObj(res6)) {
7235  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7236  } else {
7237  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7238  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7239  }
7240  return resultobj;
7241 fail:
7242  return NULL;
7243 }
7244 
7245 
7246 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7247  PyObject *resultobj = 0;
7248 
7249  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7250  plgra();
7251  resultobj = SWIG_Py_Void();
7252  return resultobj;
7253 fail:
7254  return NULL;
7255 }
7256 
7257 
7258 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7259  PyObject *resultobj = 0;
7260  PLFLT *arg1 = (PLFLT *) 0 ;
7261  PLFLT *arg2 = (PLFLT *) 0 ;
7262  PLFLT *arg3 = (PLFLT *) 0 ;
7263  PLINT arg4 ;
7264  PLFLT *arg5 = (PLFLT *) 0 ;
7265  PLINT arg6 ;
7266  PLFLT *arg7 = (PLFLT *) 0 ;
7267  PLINT arg8 ;
7268  PLFLT **arg9 = (PLFLT **) 0 ;
7269  PLINT arg10 ;
7270  PLFLT arg11 ;
7271  PyArrayObject *tmp1 = NULL ;
7272  PyArrayObject *tmp2 = NULL ;
7273  PyArrayObject *tmp3 = NULL ;
7274  PyArrayObject *tmp5 = NULL ;
7275  PyArrayObject *tmp7 = NULL ;
7276  PyObject *array7 = NULL ;
7277  int val10 ;
7278  int ecode10 = 0 ;
7279  double val11 ;
7280  int ecode11 = 0 ;
7281  PyObject * obj0 = 0 ;
7282  PyObject * obj1 = 0 ;
7283  PyObject * obj2 = 0 ;
7284  PyObject * obj3 = 0 ;
7285  PyObject * obj4 = 0 ;
7286  PyObject * obj5 = 0 ;
7287  PyObject * obj6 = 0 ;
7288 
7289  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7290  {
7291  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7292  if ( tmp1 == NULL )
7293  return NULL;
7294  Alen = PyArray_DIMS( tmp1 )[0];
7295  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7296  }
7297  {
7298  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7299  if ( tmp2 == NULL )
7300  return NULL;
7301  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7302  {
7303  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7304  return NULL;
7305  }
7306  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7307  }
7308  {
7309  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7310  if ( tmp3 == NULL )
7311  return NULL;
7312  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7313  {
7314  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7315  return NULL;
7316  }
7317  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7318  arg4 = PyArray_DIMS( tmp3 )[0];
7319  }
7320  {
7321  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7322  if ( tmp5 == NULL )
7323  return NULL;
7324  Xlen = PyArray_DIMS( tmp5 )[0];
7325  arg6 = Xlen;
7326  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7327  }
7328  {
7329  int i, size;
7330  npy_intp dims[2];
7331  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7332  if ( tmp7 == NULL )
7333  return NULL;
7334  Ylen = PyArray_DIMS( tmp7 )[0];
7335  arg8 = Ylen;
7336  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7337  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7338  // list and this ArrayY.
7339  dims[0] = Xlen;
7340  dims[1] = Ylen;
7341  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7342  if ( !array7 )
7343  return NULL;
7344  size = Ylen;
7345  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7346  for ( i = 0; i < Xlen; i++ )
7347  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7348  }
7349  ecode10 = SWIG_AsVal_int(obj5, &val10);
7350  if (!SWIG_IsOK(ecode10)) {
7351  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7352  }
7353  arg10 = (PLINT)(val10);
7354  ecode11 = SWIG_AsVal_double(obj6, &val11);
7355  if (!SWIG_IsOK(ecode11)) {
7356  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7357  }
7358  arg11 = (PLFLT)(val11);
7359  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7360  resultobj = SWIG_Py_Void();
7361  {
7362  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7363  }
7364  {
7365  Py_CLEAR( tmp1 );
7366  }
7367  {
7368  Py_CLEAR( tmp2 );
7369  }
7370  {
7371  Py_CLEAR( tmp3 );
7372  }
7373  {
7374  Py_CLEAR( tmp5 );
7375  }
7376  {
7377  Py_CLEAR( tmp7 );
7378  free( arg9 );
7379  }
7380  return resultobj;
7381 fail:
7382  {
7383  Py_CLEAR( tmp1 );
7384  }
7385  {
7386  Py_CLEAR( tmp2 );
7387  }
7388  {
7389  Py_CLEAR( tmp3 );
7390  }
7391  {
7392  Py_CLEAR( tmp5 );
7393  }
7394  {
7395  Py_CLEAR( tmp7 );
7396  free( arg9 );
7397  }
7398  return NULL;
7399 }
7400 
7401 
7402 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7403  PyObject *resultobj = 0;
7404  PLFLT *arg1 = (PLFLT *) 0 ;
7405  PLFLT *arg2 = (PLFLT *) 0 ;
7406  PLFLT *arg3 = (PLFLT *) 0 ;
7407  PLFLT *arg4 = (PLFLT *) 0 ;
7408  PLFLT temp1 ;
7409  int res1 = SWIG_TMPOBJ ;
7410  PLFLT temp2 ;
7411  int res2 = SWIG_TMPOBJ ;
7412  PLFLT temp3 ;
7413  int res3 = SWIG_TMPOBJ ;
7414  PLFLT temp4 ;
7415  int res4 = SWIG_TMPOBJ ;
7416 
7417  arg1 = &temp1;
7418  arg2 = &temp2;
7419  arg3 = &temp3;
7420  arg4 = &temp4;
7421  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7422  plgspa(arg1,arg2,arg3,arg4);
7423  resultobj = SWIG_Py_Void();
7424  if (SWIG_IsTmpObj(res1)) {
7425  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7426  } else {
7427  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7428  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7429  }
7430  if (SWIG_IsTmpObj(res2)) {
7431  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7432  } else {
7433  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7434  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7435  }
7436  if (SWIG_IsTmpObj(res3)) {
7437  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7438  } else {
7439  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7440  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7441  }
7442  if (SWIG_IsTmpObj(res4)) {
7443  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7444  } else {
7445  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7446  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7447  }
7448  return resultobj;
7449 fail:
7450  return NULL;
7451 }
7452 
7453 
7454 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7455  PyObject *resultobj = 0;
7456  PLINT *arg1 = (PLINT *) 0 ;
7457  PLINT temp1 ;
7458  int res1 = SWIG_TMPOBJ ;
7459 
7460  arg1 = &temp1;
7461  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7462  plgstrm(arg1);
7463  resultobj = SWIG_Py_Void();
7464  if (SWIG_IsTmpObj(res1)) {
7465  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7466  } else {
7467  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7468  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7469  }
7470  return resultobj;
7471 fail:
7472  return NULL;
7473 }
7474 
7475 
7476 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7477  PyObject *resultobj = 0;
7478  char *arg1 = (char *) 0 ;
7479  char buff1[1000] ;
7480 
7481  {
7482  arg1 = buff1;
7483  }
7484  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7485  plgver(arg1);
7486  resultobj = SWIG_Py_Void();
7487  {
7488  PyObject *o = PyString_FromString( arg1 );
7489  resultobj = t_output_helper( resultobj, o );
7490  }
7491  return resultobj;
7492 fail:
7493  return NULL;
7494 }
7495 
7496 
7497 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7498  PyObject *resultobj = 0;
7499  PLFLT *arg1 = (PLFLT *) 0 ;
7500  PLFLT *arg2 = (PLFLT *) 0 ;
7501  PLFLT *arg3 = (PLFLT *) 0 ;
7502  PLFLT *arg4 = (PLFLT *) 0 ;
7503  PLFLT temp1 ;
7504  int res1 = SWIG_TMPOBJ ;
7505  PLFLT temp2 ;
7506  int res2 = SWIG_TMPOBJ ;
7507  PLFLT temp3 ;
7508  int res3 = SWIG_TMPOBJ ;
7509  PLFLT temp4 ;
7510  int res4 = SWIG_TMPOBJ ;
7511 
7512  arg1 = &temp1;
7513  arg2 = &temp2;
7514  arg3 = &temp3;
7515  arg4 = &temp4;
7516  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7517  plgvpd(arg1,arg2,arg3,arg4);
7518  resultobj = SWIG_Py_Void();
7519  if (SWIG_IsTmpObj(res1)) {
7520  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7521  } else {
7522  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7523  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7524  }
7525  if (SWIG_IsTmpObj(res2)) {
7526  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7527  } else {
7528  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7529  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7530  }
7531  if (SWIG_IsTmpObj(res3)) {
7532  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7533  } else {
7534  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7535  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7536  }
7537  if (SWIG_IsTmpObj(res4)) {
7538  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7539  } else {
7540  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7541  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7542  }
7543  return resultobj;
7544 fail:
7545  return NULL;
7546 }
7547 
7548 
7549 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7550  PyObject *resultobj = 0;
7551  PLFLT *arg1 = (PLFLT *) 0 ;
7552  PLFLT *arg2 = (PLFLT *) 0 ;
7553  PLFLT *arg3 = (PLFLT *) 0 ;
7554  PLFLT *arg4 = (PLFLT *) 0 ;
7555  PLFLT temp1 ;
7556  int res1 = SWIG_TMPOBJ ;
7557  PLFLT temp2 ;
7558  int res2 = SWIG_TMPOBJ ;
7559  PLFLT temp3 ;
7560  int res3 = SWIG_TMPOBJ ;
7561  PLFLT temp4 ;
7562  int res4 = SWIG_TMPOBJ ;
7563 
7564  arg1 = &temp1;
7565  arg2 = &temp2;
7566  arg3 = &temp3;
7567  arg4 = &temp4;
7568  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7569  plgvpw(arg1,arg2,arg3,arg4);
7570  resultobj = SWIG_Py_Void();
7571  if (SWIG_IsTmpObj(res1)) {
7572  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7573  } else {
7574  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7575  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7576  }
7577  if (SWIG_IsTmpObj(res2)) {
7578  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7579  } else {
7580  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7581  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7582  }
7583  if (SWIG_IsTmpObj(res3)) {
7584  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7585  } else {
7586  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7587  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7588  }
7589  if (SWIG_IsTmpObj(res4)) {
7590  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7591  } else {
7592  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7593  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7594  }
7595  return resultobj;
7596 fail:
7597  return NULL;
7598 }
7599 
7600 
7601 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7602  PyObject *resultobj = 0;
7603  PLINT *arg1 = (PLINT *) 0 ;
7604  PLINT *arg2 = (PLINT *) 0 ;
7605  PLINT temp1 ;
7606  int res1 = SWIG_TMPOBJ ;
7607  PLINT temp2 ;
7608  int res2 = SWIG_TMPOBJ ;
7609 
7610  arg1 = &temp1;
7611  arg2 = &temp2;
7612  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7613  plgxax(arg1,arg2);
7614  resultobj = SWIG_Py_Void();
7615  if (SWIG_IsTmpObj(res1)) {
7616  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7617  } else {
7618  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7619  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7620  }
7621  if (SWIG_IsTmpObj(res2)) {
7622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7623  } else {
7624  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7625  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7626  }
7627  return resultobj;
7628 fail:
7629  return NULL;
7630 }
7631 
7632 
7633 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7634  PyObject *resultobj = 0;
7635  PLINT *arg1 = (PLINT *) 0 ;
7636  PLINT *arg2 = (PLINT *) 0 ;
7637  PLINT temp1 ;
7638  int res1 = SWIG_TMPOBJ ;
7639  PLINT temp2 ;
7640  int res2 = SWIG_TMPOBJ ;
7641 
7642  arg1 = &temp1;
7643  arg2 = &temp2;
7644  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7645  plgyax(arg1,arg2);
7646  resultobj = SWIG_Py_Void();
7647  if (SWIG_IsTmpObj(res1)) {
7648  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7649  } else {
7650  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7651  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7652  }
7653  if (SWIG_IsTmpObj(res2)) {
7654  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7655  } else {
7656  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7657  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7658  }
7659  return resultobj;
7660 fail:
7661  return NULL;
7662 }
7663 
7664 
7665 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7666  PyObject *resultobj = 0;
7667  PLINT *arg1 = (PLINT *) 0 ;
7668  PLINT *arg2 = (PLINT *) 0 ;
7669  PLINT temp1 ;
7670  int res1 = SWIG_TMPOBJ ;
7671  PLINT temp2 ;
7672  int res2 = SWIG_TMPOBJ ;
7673 
7674  arg1 = &temp1;
7675  arg2 = &temp2;
7676  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7677  plgzax(arg1,arg2);
7678  resultobj = SWIG_Py_Void();
7679  if (SWIG_IsTmpObj(res1)) {
7680  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7681  } else {
7682  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7683  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7684  }
7685  if (SWIG_IsTmpObj(res2)) {
7686  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7687  } else {
7688  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7689  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7690  }
7691  return resultobj;
7692 fail:
7693  return NULL;
7694 }
7695 
7696 
7697 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7698  PyObject *resultobj = 0;
7699  PLINT arg1 ;
7700  PLFLT *arg2 = (PLFLT *) 0 ;
7701  PLFLT arg3 ;
7702  PLFLT arg4 ;
7703  PLINT arg5 ;
7704  PLINT arg6 ;
7705  PyArrayObject *tmp1 = NULL ;
7706  double val3 ;
7707  int ecode3 = 0 ;
7708  double val4 ;
7709  int ecode4 = 0 ;
7710  int val5 ;
7711  int ecode5 = 0 ;
7712  int val6 ;
7713  int ecode6 = 0 ;
7714  PyObject * obj0 = 0 ;
7715  PyObject * obj1 = 0 ;
7716  PyObject * obj2 = 0 ;
7717  PyObject * obj3 = 0 ;
7718  PyObject * obj4 = 0 ;
7719 
7720  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7721  {
7722  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7723  if ( tmp1 == NULL )
7724  return NULL;
7725  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7726  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7727  }
7728  ecode3 = SWIG_AsVal_double(obj1, &val3);
7729  if (!SWIG_IsOK(ecode3)) {
7730  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7731  }
7732  arg3 = (PLFLT)(val3);
7733  ecode4 = SWIG_AsVal_double(obj2, &val4);
7734  if (!SWIG_IsOK(ecode4)) {
7735  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7736  }
7737  arg4 = (PLFLT)(val4);
7738  ecode5 = SWIG_AsVal_int(obj3, &val5);
7739  if (!SWIG_IsOK(ecode5)) {
7740  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7741  }
7742  arg5 = (PLINT)(val5);
7743  ecode6 = SWIG_AsVal_int(obj4, &val6);
7744  if (!SWIG_IsOK(ecode6)) {
7745  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7746  }
7747  arg6 = (PLINT)(val6);
7748  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7749  resultobj = SWIG_Py_Void();
7750  {
7751  Py_CLEAR( tmp1 );
7752  }
7753  return resultobj;
7754 fail:
7755  {
7756  Py_CLEAR( tmp1 );
7757  }
7758  return NULL;
7759 }
7760 
7761 
7762 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763  PyObject *resultobj = 0;
7764  PLFLT arg1 ;
7765  PLFLT arg2 ;
7766  PLFLT arg3 ;
7767  PLFLT *arg4 = (PLFLT *) 0 ;
7768  PLFLT *arg5 = (PLFLT *) 0 ;
7769  PLFLT *arg6 = (PLFLT *) 0 ;
7770  double val1 ;
7771  int ecode1 = 0 ;
7772  double val2 ;
7773  int ecode2 = 0 ;
7774  double val3 ;
7775  int ecode3 = 0 ;
7776  PLFLT temp4 ;
7777  int res4 = SWIG_TMPOBJ ;
7778  PLFLT temp5 ;
7779  int res5 = SWIG_TMPOBJ ;
7780  PLFLT temp6 ;
7781  int res6 = SWIG_TMPOBJ ;
7782  PyObject * obj0 = 0 ;
7783  PyObject * obj1 = 0 ;
7784  PyObject * obj2 = 0 ;
7785 
7786  arg4 = &temp4;
7787  arg5 = &temp5;
7788  arg6 = &temp6;
7789  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7790  ecode1 = SWIG_AsVal_double(obj0, &val1);
7791  if (!SWIG_IsOK(ecode1)) {
7792  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7793  }
7794  arg1 = (PLFLT)(val1);
7795  ecode2 = SWIG_AsVal_double(obj1, &val2);
7796  if (!SWIG_IsOK(ecode2)) {
7797  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7798  }
7799  arg2 = (PLFLT)(val2);
7800  ecode3 = SWIG_AsVal_double(obj2, &val3);
7801  if (!SWIG_IsOK(ecode3)) {
7802  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7803  }
7804  arg3 = (PLFLT)(val3);
7805  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7806  resultobj = SWIG_Py_Void();
7807  if (SWIG_IsTmpObj(res4)) {
7808  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7809  } else {
7810  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7811  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7812  }
7813  if (SWIG_IsTmpObj(res5)) {
7814  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7815  } else {
7816  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7817  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7818  }
7819  if (SWIG_IsTmpObj(res6)) {
7820  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7821  } else {
7822  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7823  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7824  }
7825  return resultobj;
7826 fail:
7827  return NULL;
7828 }
7829 
7830 
7831 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832  PyObject *resultobj = 0;
7833 
7834  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7835  plinit();
7836  resultobj = SWIG_Py_Void();
7837  return resultobj;
7838 fail:
7839  return NULL;
7840 }
7841 
7842 
7843 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7844  PyObject *resultobj = 0;
7845  PLFLT arg1 ;
7846  PLFLT arg2 ;
7847  PLFLT arg3 ;
7848  PLFLT arg4 ;
7849  double val1 ;
7850  int ecode1 = 0 ;
7851  double val2 ;
7852  int ecode2 = 0 ;
7853  double val3 ;
7854  int ecode3 = 0 ;
7855  double val4 ;
7856  int ecode4 = 0 ;
7857  PyObject * obj0 = 0 ;
7858  PyObject * obj1 = 0 ;
7859  PyObject * obj2 = 0 ;
7860  PyObject * obj3 = 0 ;
7861 
7862  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7863  ecode1 = SWIG_AsVal_double(obj0, &val1);
7864  if (!SWIG_IsOK(ecode1)) {
7865  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7866  }
7867  arg1 = (PLFLT)(val1);
7868  ecode2 = SWIG_AsVal_double(obj1, &val2);
7869  if (!SWIG_IsOK(ecode2)) {
7870  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7871  }
7872  arg2 = (PLFLT)(val2);
7873  ecode3 = SWIG_AsVal_double(obj2, &val3);
7874  if (!SWIG_IsOK(ecode3)) {
7875  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7876  }
7877  arg3 = (PLFLT)(val3);
7878  ecode4 = SWIG_AsVal_double(obj3, &val4);
7879  if (!SWIG_IsOK(ecode4)) {
7880  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7881  }
7882  arg4 = (PLFLT)(val4);
7883  pljoin(arg1,arg2,arg3,arg4);
7884  resultobj = SWIG_Py_Void();
7885  return resultobj;
7886 fail:
7887  return NULL;
7888 }
7889 
7890 
7891 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7892  PyObject *resultobj = 0;
7893  char *arg1 = (char *) 0 ;
7894  char *arg2 = (char *) 0 ;
7895  char *arg3 = (char *) 0 ;
7896  int res1 ;
7897  char *buf1 = 0 ;
7898  int alloc1 = 0 ;
7899  int res2 ;
7900  char *buf2 = 0 ;
7901  int alloc2 = 0 ;
7902  int res3 ;
7903  char *buf3 = 0 ;
7904  int alloc3 = 0 ;
7905  PyObject * obj0 = 0 ;
7906  PyObject * obj1 = 0 ;
7907  PyObject * obj2 = 0 ;
7908 
7909  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7910  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7911  if (!SWIG_IsOK(res1)) {
7912  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7913  }
7914  arg1 = (char *)(buf1);
7915  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7916  if (!SWIG_IsOK(res2)) {
7917  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7918  }
7919  arg2 = (char *)(buf2);
7920  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7921  if (!SWIG_IsOK(res3)) {
7922  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7923  }
7924  arg3 = (char *)(buf3);
7925  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7926  resultobj = SWIG_Py_Void();
7927  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7928  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7929  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7930  return resultobj;
7931 fail:
7932  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7933  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7934  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7935  return NULL;
7936 }
7937 
7938 
7939 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7940  PyObject *resultobj = 0;
7941  PLFLT *arg1 = (PLFLT *) 0 ;
7942  PLFLT *arg2 = (PLFLT *) 0 ;
7943  PLINT arg3 ;
7944  PLINT arg4 ;
7945  PLFLT arg5 ;
7946  PLFLT arg6 ;
7947  PLFLT arg7 ;
7948  PLINT arg8 ;
7949  PLINT arg9 ;
7950  PLINT arg10 ;
7951  PLINT arg11 ;
7952  PLINT arg12 ;
7953  PLINT arg13 ;
7954  PLINT *arg14 = (PLINT *) 0 ;
7955  PLFLT arg15 ;
7956  PLFLT arg16 ;
7957  PLFLT arg17 ;
7958  PLFLT arg18 ;
7959  PLINT *arg19 = (PLINT *) 0 ;
7960  char **arg20 = (char **) 0 ;
7961  PLINT *arg21 = (PLINT *) 0 ;
7962  PLINT *arg22 = (PLINT *) 0 ;
7963  PLFLT *arg23 = (PLFLT *) 0 ;
7964  PLFLT *arg24 = (PLFLT *) 0 ;
7965  PLINT *arg25 = (PLINT *) 0 ;
7966  PLINT *arg26 = (PLINT *) 0 ;
7967  PLFLT *arg27 = (PLFLT *) 0 ;
7968  PLINT *arg28 = (PLINT *) 0 ;
7969  PLFLT *arg29 = (PLFLT *) 0 ;
7970  PLINT *arg30 = (PLINT *) 0 ;
7971  char **arg31 = (char **) 0 ;
7972  PLFLT temp1 ;
7973  int res1 = SWIG_TMPOBJ ;
7974  PLFLT temp2 ;
7975  int res2 = SWIG_TMPOBJ ;
7976  int val3 ;
7977  int ecode3 = 0 ;
7978  int val4 ;
7979  int ecode4 = 0 ;
7980  double val5 ;
7981  int ecode5 = 0 ;
7982  double val6 ;
7983  int ecode6 = 0 ;
7984  double val7 ;
7985  int ecode7 = 0 ;
7986  int val8 ;
7987  int ecode8 = 0 ;
7988  int val9 ;
7989  int ecode9 = 0 ;
7990  int val10 ;
7991  int ecode10 = 0 ;
7992  int val11 ;
7993  int ecode11 = 0 ;
7994  int val12 ;
7995  int ecode12 = 0 ;
7996  PyArrayObject *tmp13 = NULL ;
7997  double val15 ;
7998  int ecode15 = 0 ;
7999  double val16 ;
8000  int ecode16 = 0 ;
8001  double val17 ;
8002  int ecode17 = 0 ;
8003  double val18 ;
8004  int ecode18 = 0 ;
8005  PyArrayObject *tmp19 = NULL ;
8006  PyArrayObject *tmp20 = NULL ;
8007  PyArrayObject *tmp21 = NULL ;
8008  PyArrayObject *tmp22 = NULL ;
8009  PyArrayObject *tmp23 = NULL ;
8010  PyArrayObject *tmp24 = NULL ;
8011  PyArrayObject *tmp25 = NULL ;
8012  PyArrayObject *tmp26 = NULL ;
8013  PyArrayObject *tmp27 = NULL ;
8014  PyArrayObject *tmp28 = NULL ;
8015  PyArrayObject *tmp29 = NULL ;
8016  PyArrayObject *tmp30 = NULL ;
8017  PyArrayObject *tmp31 = NULL ;
8018  PyObject * obj0 = 0 ;
8019  PyObject * obj1 = 0 ;
8020  PyObject * obj2 = 0 ;
8021  PyObject * obj3 = 0 ;
8022  PyObject * obj4 = 0 ;
8023  PyObject * obj5 = 0 ;
8024  PyObject * obj6 = 0 ;
8025  PyObject * obj7 = 0 ;
8026  PyObject * obj8 = 0 ;
8027  PyObject * obj9 = 0 ;
8028  PyObject * obj10 = 0 ;
8029  PyObject * obj11 = 0 ;
8030  PyObject * obj12 = 0 ;
8031  PyObject * obj13 = 0 ;
8032  PyObject * obj14 = 0 ;
8033  PyObject * obj15 = 0 ;
8034  PyObject * obj16 = 0 ;
8035  PyObject * obj17 = 0 ;
8036  PyObject * obj18 = 0 ;
8037  PyObject * obj19 = 0 ;
8038  PyObject * obj20 = 0 ;
8039  PyObject * obj21 = 0 ;
8040  PyObject * obj22 = 0 ;
8041  PyObject * obj23 = 0 ;
8042  PyObject * obj24 = 0 ;
8043  PyObject * obj25 = 0 ;
8044  PyObject * obj26 = 0 ;
8045  PyObject * obj27 = 0 ;
8046 
8047  arg1 = &temp1;
8048  arg2 = &temp2;
8049  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;
8050  ecode3 = SWIG_AsVal_int(obj0, &val3);
8051  if (!SWIG_IsOK(ecode3)) {
8052  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8053  }
8054  arg3 = (PLINT)(val3);
8055  ecode4 = SWIG_AsVal_int(obj1, &val4);
8056  if (!SWIG_IsOK(ecode4)) {
8057  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8058  }
8059  arg4 = (PLINT)(val4);
8060  ecode5 = SWIG_AsVal_double(obj2, &val5);
8061  if (!SWIG_IsOK(ecode5)) {
8062  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8063  }
8064  arg5 = (PLFLT)(val5);
8065  ecode6 = SWIG_AsVal_double(obj3, &val6);
8066  if (!SWIG_IsOK(ecode6)) {
8067  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8068  }
8069  arg6 = (PLFLT)(val6);
8070  ecode7 = SWIG_AsVal_double(obj4, &val7);
8071  if (!SWIG_IsOK(ecode7)) {
8072  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8073  }
8074  arg7 = (PLFLT)(val7);
8075  ecode8 = SWIG_AsVal_int(obj5, &val8);
8076  if (!SWIG_IsOK(ecode8)) {
8077  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8078  }
8079  arg8 = (PLINT)(val8);
8080  ecode9 = SWIG_AsVal_int(obj6, &val9);
8081  if (!SWIG_IsOK(ecode9)) {
8082  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8083  }
8084  arg9 = (PLINT)(val9);
8085  ecode10 = SWIG_AsVal_int(obj7, &val10);
8086  if (!SWIG_IsOK(ecode10)) {
8087  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8088  }
8089  arg10 = (PLINT)(val10);
8090  ecode11 = SWIG_AsVal_int(obj8, &val11);
8091  if (!SWIG_IsOK(ecode11)) {
8092  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8093  }
8094  arg11 = (PLINT)(val11);
8095  ecode12 = SWIG_AsVal_int(obj9, &val12);
8096  if (!SWIG_IsOK(ecode12)) {
8097  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8098  }
8099  arg12 = (PLINT)(val12);
8100  {
8101  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
8102  if ( tmp13 == NULL )
8103  return NULL;
8104  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8105  arg14 = (PLINT *) PyArray_DATA( tmp13 );
8106  }
8107  ecode15 = SWIG_AsVal_double(obj11, &val15);
8108  if (!SWIG_IsOK(ecode15)) {
8109  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8110  }
8111  arg15 = (PLFLT)(val15);
8112  ecode16 = SWIG_AsVal_double(obj12, &val16);
8113  if (!SWIG_IsOK(ecode16)) {
8114  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8115  }
8116  arg16 = (PLFLT)(val16);
8117  ecode17 = SWIG_AsVal_double(obj13, &val17);
8118  if (!SWIG_IsOK(ecode17)) {
8119  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8120  }
8121  arg17 = (PLFLT)(val17);
8122  ecode18 = SWIG_AsVal_double(obj14, &val18);
8123  if (!SWIG_IsOK(ecode18)) {
8124  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8125  }
8126  arg18 = (PLFLT)(val18);
8127  {
8128  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
8129  if ( tmp19 == NULL )
8130  return NULL;
8131  if ( PyArray_DIMS( tmp19 )[0] != Alen )
8132  {
8133  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8134  return NULL;
8135  }
8136  arg19 = (PLINT *) PyArray_DATA( tmp19 );
8137  }
8138  {
8139  int i;
8140  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
8141  if ( tmp20 == NULL )
8142  return NULL;
8143  if ( PyArray_DIMS( tmp20 )[0] != Alen )
8144  {
8145  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8146  return NULL;
8147  }
8148  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8149  for ( i = 0; i < Alen; i++ )
8150  {
8151  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8152  if ( arg20[i] == NULL )
8153  {
8154  free( arg20 );
8155  return NULL;
8156  }
8157  }
8158  }
8159  {
8160  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8161  if ( tmp21 == NULL )
8162  return NULL;
8163  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8164  {
8165  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8166  return NULL;
8167  }
8168  arg21 = (PLINT *) PyArray_DATA( tmp21 );
8169  }
8170  {
8171  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8172  if ( tmp22 == NULL )
8173  return NULL;
8174  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8175  {
8176  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8177  return NULL;
8178  }
8179  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8180  }
8181  {
8182  if ( obj19 != Py_None )
8183  {
8184  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8185  if ( tmp23 == NULL )
8186  return NULL;
8187  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8188  {
8189  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8190  return NULL;
8191  }
8192  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8193  }
8194  else
8195  {
8196  arg23 = NULL;
8197  }
8198  }
8199  {
8200  if ( obj20 != Py_None )
8201  {
8202  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8203  if ( tmp24 == NULL )
8204  return NULL;
8205  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8206  {
8207  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8208  return NULL;
8209  }
8210  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8211  }
8212  else
8213  {
8214  arg24 = NULL;
8215  }
8216  }
8217  {
8218  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8219  if ( tmp25 == NULL )
8220  return NULL;
8221  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8222  {
8223  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8224  return NULL;
8225  }
8226  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8227  }
8228  {
8229  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8230  if ( tmp26 == NULL )
8231  return NULL;
8232  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8233  {
8234  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8235  return NULL;
8236  }
8237  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8238  }
8239  {
8240  if ( obj23 != Py_None )
8241  {
8242  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8243  if ( tmp27 == NULL )
8244  return NULL;
8245  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8246  {
8247  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8248  return NULL;
8249  }
8250  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8251  }
8252  else
8253  {
8254  arg27 = NULL;
8255  }
8256  }
8257  {
8258  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8259  if ( tmp28 == NULL )
8260  return NULL;
8261  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8262  {
8263  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8264  return NULL;
8265  }
8266  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8267  }
8268  {
8269  if ( obj25 != Py_None )
8270  {
8271  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8272  if ( tmp29 == NULL )
8273  return NULL;
8274  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8275  {
8276  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8277  return NULL;
8278  }
8279  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8280  }
8281  else
8282  {
8283  arg29 = NULL;
8284  }
8285  }
8286  {
8287  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8288  if ( tmp30 == NULL )
8289  return NULL;
8290  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8291  {
8292  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8293  return NULL;
8294  }
8295  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8296  }
8297  {
8298  int i;
8299  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8300  if ( tmp31 == NULL )
8301  return NULL;
8302  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8303  {
8304  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8305  return NULL;
8306  }
8307  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8308  for ( i = 0; i < Alen; i++ )
8309  {
8310  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8311  if ( arg31[i] == NULL )
8312  {
8313  free( arg31 );
8314  return NULL;
8315  }
8316  }
8317  }
8318  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);
8319  resultobj = SWIG_Py_Void();
8320  if (SWIG_IsTmpObj(res1)) {
8321  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8322  } else {
8323  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8324  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8325  }
8326  if (SWIG_IsTmpObj(res2)) {
8327  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8328  } else {
8329  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8330  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8331  }
8332  {
8333  Py_CLEAR( tmp13 );
8334  }
8335  {
8336  Py_CLEAR( tmp19 );
8337  }
8338  {
8339  Py_CLEAR( tmp20 ); free( arg20 );
8340  }
8341  {
8342  Py_CLEAR( tmp21 );
8343  }
8344  {
8345  Py_CLEAR( tmp22 );
8346  }
8347  {
8348  Py_CLEAR( tmp23 );
8349  }
8350  {
8351  Py_CLEAR( tmp24 );
8352  }
8353  {
8354  Py_CLEAR( tmp25 );
8355  }
8356  {
8357  Py_CLEAR( tmp26 );
8358  }
8359  {
8360  Py_CLEAR( tmp27 );
8361  }
8362  {
8363  Py_CLEAR( tmp28 );
8364  }
8365  {
8366  Py_CLEAR( tmp29 );
8367  }
8368  {
8369  Py_CLEAR( tmp30 );
8370  }
8371  {
8372  Py_CLEAR( tmp31 ); free( arg31 );
8373  }
8374  return resultobj;
8375 fail:
8376  {
8377  Py_CLEAR( tmp13 );
8378  }
8379  {
8380  Py_CLEAR( tmp19 );
8381  }
8382  {
8383  Py_CLEAR( tmp20 ); free( arg20 );
8384  }
8385  {
8386  Py_CLEAR( tmp21 );
8387  }
8388  {
8389  Py_CLEAR( tmp22 );
8390  }
8391  {
8392  Py_CLEAR( tmp23 );
8393  }
8394  {
8395  Py_CLEAR( tmp24 );
8396  }
8397  {
8398  Py_CLEAR( tmp25 );
8399  }
8400  {
8401  Py_CLEAR( tmp26 );
8402  }
8403  {
8404  Py_CLEAR( tmp27 );
8405  }
8406  {
8407  Py_CLEAR( tmp28 );
8408  }
8409  {
8410  Py_CLEAR( tmp29 );
8411  }
8412  {
8413  Py_CLEAR( tmp30 );
8414  }
8415  {
8416  Py_CLEAR( tmp31 ); free( arg31 );
8417  }
8418  return NULL;
8419 }
8420 
8421 
8422 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8423  PyObject *resultobj = 0;
8424  PLFLT *arg1 = (PLFLT *) 0 ;
8425  PLFLT *arg2 = (PLFLT *) 0 ;
8426  PLINT arg3 ;
8427  PLINT arg4 ;
8428  PLFLT arg5 ;
8429  PLFLT arg6 ;
8430  PLFLT arg7 ;
8431  PLFLT arg8 ;
8432  PLINT arg9 ;
8433  PLINT arg10 ;
8434  PLINT arg11 ;
8435  PLFLT arg12 ;
8436  PLFLT arg13 ;
8437  PLINT arg14 ;
8438  PLFLT arg15 ;
8439  PLINT arg16 ;
8440  PLINT *arg17 = (PLINT *) 0 ;
8441  char **arg18 = (char **) 0 ;
8442  PLINT arg19 ;
8443  char **arg20 = (char **) 0 ;
8444  PLFLT *arg21 = (PLFLT *) 0 ;
8445  PLINT *arg22 = (PLINT *) 0 ;
8446  PLINT *arg23 = (PLINT *) 0 ;
8447  PLFLT **arg24 = (PLFLT **) 0 ;
8448  PLFLT temp1 ;
8449  int res1 = SWIG_TMPOBJ ;
8450  PLFLT temp2 ;
8451  int res2 = SWIG_TMPOBJ ;
8452  int val3 ;
8453  int ecode3 = 0 ;
8454  int val4 ;
8455  int ecode4 = 0 ;
8456  double val5 ;
8457  int ecode5 = 0 ;
8458  double val6 ;
8459  int ecode6 = 0 ;
8460  double val7 ;
8461  int ecode7 = 0 ;
8462  double val8 ;
8463  int ecode8 = 0 ;
8464  int val9 ;
8465  int ecode9 = 0 ;
8466  int val10 ;
8467  int ecode10 = 0 ;
8468  int val11 ;
8469  int ecode11 = 0 ;
8470  double val12 ;
8471  int ecode12 = 0 ;
8472  double val13 ;
8473  int ecode13 = 0 ;
8474  int val14 ;
8475  int ecode14 = 0 ;
8476  double val15 ;
8477  int ecode15 = 0 ;
8478  PyArrayObject *tmp16 = NULL ;
8479  PyArrayObject *tmp18 = NULL ;
8480  PyArrayObject *tmp19 = NULL ;
8481  PyArrayObject *tmp21 = NULL ;
8482  PyArrayObject *tmp22 = NULL ;
8483  PyArrayObject *tmp23 = NULL ;
8484  PyArrayObject *tmp24 = NULL ;
8485  PyObject * obj0 = 0 ;
8486  PyObject * obj1 = 0 ;
8487  PyObject * obj2 = 0 ;
8488  PyObject * obj3 = 0 ;
8489  PyObject * obj4 = 0 ;
8490  PyObject * obj5 = 0 ;
8491  PyObject * obj6 = 0 ;
8492  PyObject * obj7 = 0 ;
8493  PyObject * obj8 = 0 ;
8494  PyObject * obj9 = 0 ;
8495  PyObject * obj10 = 0 ;
8496  PyObject * obj11 = 0 ;
8497  PyObject * obj12 = 0 ;
8498  PyObject * obj13 = 0 ;
8499  PyObject * obj14 = 0 ;
8500  PyObject * obj15 = 0 ;
8501  PyObject * obj16 = 0 ;
8502  PyObject * obj17 = 0 ;
8503  PyObject * obj18 = 0 ;
8504  PyObject * obj19 = 0 ;
8505 
8506  arg1 = &temp1;
8507  arg2 = &temp2;
8508  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;
8509  ecode3 = SWIG_AsVal_int(obj0, &val3);
8510  if (!SWIG_IsOK(ecode3)) {
8511  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8512  }
8513  arg3 = (PLINT)(val3);
8514  ecode4 = SWIG_AsVal_int(obj1, &val4);
8515  if (!SWIG_IsOK(ecode4)) {
8516  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8517  }
8518  arg4 = (PLINT)(val4);
8519  ecode5 = SWIG_AsVal_double(obj2, &val5);
8520  if (!SWIG_IsOK(ecode5)) {
8521  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8522  }
8523  arg5 = (PLFLT)(val5);
8524  ecode6 = SWIG_AsVal_double(obj3, &val6);
8525  if (!SWIG_IsOK(ecode6)) {
8526  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8527  }
8528  arg6 = (PLFLT)(val6);
8529  ecode7 = SWIG_AsVal_double(obj4, &val7);
8530  if (!SWIG_IsOK(ecode7)) {
8531  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8532  }
8533  arg7 = (PLFLT)(val7);
8534  ecode8 = SWIG_AsVal_double(obj5, &val8);
8535  if (!SWIG_IsOK(ecode8)) {
8536  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8537  }
8538  arg8 = (PLFLT)(val8);
8539  ecode9 = SWIG_AsVal_int(obj6, &val9);
8540  if (!SWIG_IsOK(ecode9)) {
8541  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8542  }
8543  arg9 = (PLINT)(val9);
8544  ecode10 = SWIG_AsVal_int(obj7, &val10);
8545  if (!SWIG_IsOK(ecode10)) {
8546  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8547  }
8548  arg10 = (PLINT)(val10);
8549  ecode11 = SWIG_AsVal_int(obj8, &val11);
8550  if (!SWIG_IsOK(ecode11)) {
8551  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8552  }
8553  arg11 = (PLINT)(val11);
8554  ecode12 = SWIG_AsVal_double(obj9, &val12);
8555  if (!SWIG_IsOK(ecode12)) {
8556  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8557  }
8558  arg12 = (PLFLT)(val12);
8559  ecode13 = SWIG_AsVal_double(obj10, &val13);
8560  if (!SWIG_IsOK(ecode13)) {
8561  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8562  }
8563  arg13 = (PLFLT)(val13);
8564  ecode14 = SWIG_AsVal_int(obj11, &val14);
8565  if (!SWIG_IsOK(ecode14)) {
8566  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8567  }
8568  arg14 = (PLINT)(val14);
8569  ecode15 = SWIG_AsVal_double(obj12, &val15);
8570  if (!SWIG_IsOK(ecode15)) {
8571  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8572  }
8573  arg15 = (PLFLT)(val15);
8574  {
8575  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8576  if ( tmp16 == NULL )
8577  return NULL;
8578  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8579  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8580  }
8581  {
8582  int i;
8583  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8584  if ( tmp18 == NULL )
8585  return NULL;
8586  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8587  {
8588  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8589  return NULL;
8590  }
8591  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8592  for ( i = 0; i < Alen; i++ )
8593  {
8594  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8595  if ( arg18[i] == NULL )
8596  {
8597  free( arg18 );
8598  return NULL;
8599  }
8600  }
8601  }
8602  {
8603  int i;
8604  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8605  if ( tmp19 == NULL )
8606  return NULL;
8607  Alen = PyArray_DIMS( tmp19 )[0];
8608  arg19 = Alen;
8609  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8610  for ( i = 0; i < Alen; i++ )
8611  {
8612  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8613  if ( arg20[i] == NULL )
8614  {
8615  free( arg20 );
8616  return NULL;
8617  }
8618  }
8619  }
8620  {
8621  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8622  if ( tmp21 == NULL )
8623  return NULL;
8624  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8625  {
8626  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8627  return NULL;
8628  }
8629  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8630  }
8631  {
8632  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8633  if ( tmp22 == NULL )
8634  return NULL;
8635  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8636  {
8637  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8638  return NULL;
8639  }
8640  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8641  }
8642  {
8643  int i;
8644  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8645  if ( tmp23 == NULL )
8646  return NULL;
8647  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8648  {
8649  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8650  return NULL;
8651  }
8652  Xlen = PyArray_DIMS( tmp23 )[0];
8653  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8654  Ylen = -1;
8655  for ( i = 0; i < Xlen; i++ )
8656  if ( arg23[i] > Ylen )
8657  Ylen = arg23[i];
8658  }
8659  {
8660  int i, size;
8661  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8662  if ( tmp24 == NULL )
8663  return NULL;
8664  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8665  {
8666  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8667  return NULL;
8668  }
8669  size = Ylen;
8670  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8671  for ( i = 0; i < Xlen; i++ )
8672  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8673  }
8674  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);
8675  resultobj = SWIG_Py_Void();
8676  if (SWIG_IsTmpObj(res1)) {
8677  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8678  } else {
8679  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8680  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8681  }
8682  if (SWIG_IsTmpObj(res2)) {
8683  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8684  } else {
8685  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8686  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8687  }
8688  {
8689  Py_CLEAR( tmp16 );
8690  }
8691  {
8692  Py_CLEAR( tmp18 ); free( arg18 );
8693  }
8694  {
8695  Py_CLEAR( tmp19 ); free( arg20 );
8696  }
8697  {
8698  Py_CLEAR( tmp21 );
8699  }
8700  {
8701  Py_CLEAR( tmp22 );
8702  }
8703  {
8704  Py_CLEAR( tmp23 );
8705  }
8706  {
8707  Py_CLEAR( tmp24 );
8708  free( arg24 );
8709  }
8710  return resultobj;
8711 fail:
8712  {
8713  Py_CLEAR( tmp16 );
8714  }
8715  {
8716  Py_CLEAR( tmp18 ); free( arg18 );
8717  }
8718  {
8719  Py_CLEAR( tmp19 ); free( arg20 );
8720  }
8721  {
8722  Py_CLEAR( tmp21 );
8723  }
8724  {
8725  Py_CLEAR( tmp22 );
8726  }
8727  {
8728  Py_CLEAR( tmp23 );
8729  }
8730  {
8731  Py_CLEAR( tmp24 );
8732  free( arg24 );
8733  }
8734  return NULL;
8735 }
8736 
8737 
8738 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8739  PyObject *resultobj = 0;
8740  PLFLT arg1 ;
8741  PLFLT arg2 ;
8742  PLFLT arg3 ;
8743  double val1 ;
8744  int ecode1 = 0 ;
8745  double val2 ;
8746  int ecode2 = 0 ;
8747  double val3 ;
8748  int ecode3 = 0 ;
8749  PyObject * obj0 = 0 ;
8750  PyObject * obj1 = 0 ;
8751  PyObject * obj2 = 0 ;
8752 
8753  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8754  ecode1 = SWIG_AsVal_double(obj0, &val1);
8755  if (!SWIG_IsOK(ecode1)) {
8756  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8757  }
8758  arg1 = (PLFLT)(val1);
8759  ecode2 = SWIG_AsVal_double(obj1, &val2);
8760  if (!SWIG_IsOK(ecode2)) {
8761  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8762  }
8763  arg2 = (PLFLT)(val2);
8764  ecode3 = SWIG_AsVal_double(obj2, &val3);
8765  if (!SWIG_IsOK(ecode3)) {
8766  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8767  }
8768  arg3 = (PLFLT)(val3);
8769  pllightsource(arg1,arg2,arg3);
8770  resultobj = SWIG_Py_Void();
8771  return resultobj;
8772 fail:
8773  return NULL;
8774 }
8775 
8776 
8777 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8778  PyObject *resultobj = 0;
8779  PLINT arg1 ;
8780  PLFLT *arg2 = (PLFLT *) 0 ;
8781  PLFLT *arg3 = (PLFLT *) 0 ;
8782  PyArrayObject *tmp1 = NULL ;
8783  PyArrayObject *tmp3 = NULL ;
8784  PyObject * obj0 = 0 ;
8785  PyObject * obj1 = 0 ;
8786 
8787  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8788  {
8789  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8790  if ( tmp1 == NULL )
8791  return NULL;
8792  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8793  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8794  }
8795  {
8796  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8797  if ( tmp3 == NULL )
8798  return NULL;
8799  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8800  {
8801  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8802  return NULL;
8803  }
8804  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8805  }
8806  plline(arg1,(double const *)arg2,(double const *)arg3);
8807  resultobj = SWIG_Py_Void();
8808  {
8809  Py_CLEAR( tmp1 );
8810  }
8811  {
8812  Py_CLEAR( tmp3 );
8813  }
8814  return resultobj;
8815 fail:
8816  {
8817  Py_CLEAR( tmp1 );
8818  }
8819  {
8820  Py_CLEAR( tmp3 );
8821  }
8822  return NULL;
8823 }
8824 
8825 
8826 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8827  PyObject *resultobj = 0;
8828  PLINT arg1 ;
8829  PLFLT *arg2 = (PLFLT *) 0 ;
8830  PLFLT *arg3 = (PLFLT *) 0 ;
8831  PLFLT *arg4 = (PLFLT *) 0 ;
8832  PyArrayObject *tmp1 = NULL ;
8833  PyArrayObject *tmp3 = NULL ;
8834  PyArrayObject *tmp4 = NULL ;
8835  PyObject * obj0 = 0 ;
8836  PyObject * obj1 = 0 ;
8837  PyObject * obj2 = 0 ;
8838 
8839  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8840  {
8841  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8842  if ( tmp1 == NULL )
8843  return NULL;
8844  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8845  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8846  }
8847  {
8848  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8849  if ( tmp3 == NULL )
8850  return NULL;
8851  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8852  {
8853  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8854  return NULL;
8855  }
8856  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8857  }
8858  {
8859  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8860  if ( tmp4 == NULL )
8861  return NULL;
8862  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8863  {
8864  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8865  return NULL;
8866  }
8867  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8868  }
8869  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8870  resultobj = SWIG_Py_Void();
8871  {
8872  Py_CLEAR( tmp1 );
8873  }
8874  {
8875  Py_CLEAR( tmp3 );
8876  }
8877  {
8878  Py_CLEAR( tmp4 );
8879  }
8880  return resultobj;
8881 fail:
8882  {
8883  Py_CLEAR( tmp1 );
8884  }
8885  {
8886  Py_CLEAR( tmp3 );
8887  }
8888  {
8889  Py_CLEAR( tmp4 );
8890  }
8891  return NULL;
8892 }
8893 
8894 
8895 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8896  PyObject *resultobj = 0;
8897  PLINT arg1 ;
8898  int val1 ;
8899  int ecode1 = 0 ;
8900  PyObject * obj0 = 0 ;
8901 
8902  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8903  ecode1 = SWIG_AsVal_int(obj0, &val1);
8904  if (!SWIG_IsOK(ecode1)) {
8905  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8906  }
8907  arg1 = (PLINT)(val1);
8908  pllsty(arg1);
8909  resultobj = SWIG_Py_Void();
8910  return resultobj;
8911 fail:
8912  return NULL;
8913 }
8914 
8915 
8916 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8917  PyObject *resultobj = 0;
8918  PLFLT *arg1 = (PLFLT *) 0 ;
8919  PLFLT *arg2 = (PLFLT *) 0 ;
8920  PLFLT **arg3 = (PLFLT **) 0 ;
8921  PLINT arg4 ;
8922  PLINT arg5 ;
8923  PLINT arg6 ;
8924  PyArrayObject *tmp1 = NULL ;
8925  PyArrayObject *tmp2 = NULL ;
8926  PyArrayObject *tmp3 = NULL ;
8927  int val6 ;
8928  int ecode6 = 0 ;
8929  PyObject * obj0 = 0 ;
8930  PyObject * obj1 = 0 ;
8931  PyObject * obj2 = 0 ;
8932  PyObject * obj3 = 0 ;
8933 
8934  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8935  {
8936  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8937  if ( tmp1 == NULL )
8938  return NULL;
8939  Xlen = PyArray_DIMS( tmp1 )[0];
8940  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8941  }
8942  {
8943  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8944  if ( tmp2 == NULL )
8945  return NULL;
8946  Ylen = PyArray_DIMS( tmp2 )[0];
8947  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8948  }
8949  {
8950  int i, size;
8951  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8952  if ( tmp3 == NULL )
8953  return NULL;
8954  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8955  {
8956  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8957  return NULL;
8958  }
8959  arg4 = PyArray_DIMS( tmp3 )[0];
8960  arg5 = PyArray_DIMS( tmp3 )[1];
8961  size = arg5;
8962  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8963  for ( i = 0; i < arg4; i++ )
8964  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8965  }
8966  ecode6 = SWIG_AsVal_int(obj3, &val6);
8967  if (!SWIG_IsOK(ecode6)) {
8968  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8969  }
8970  arg6 = (PLINT)(val6);
8971  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8972  resultobj = SWIG_Py_Void();
8973  {
8974  Py_CLEAR( tmp1 );
8975  }
8976  {
8977  Py_CLEAR( tmp2 );
8978  }
8979  {
8980  Py_CLEAR( tmp3 );
8981  free( arg3 );
8982  }
8983  return resultobj;
8984 fail:
8985  {
8986  Py_CLEAR( tmp1 );
8987  }
8988  {
8989  Py_CLEAR( tmp2 );
8990  }
8991  {
8992  Py_CLEAR( tmp3 );
8993  free( arg3 );
8994  }
8995  return NULL;
8996 }
8997 
8998 
8999 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9000  PyObject *resultobj = 0;
9001  PLFLT *arg1 = (PLFLT *) 0 ;
9002  PLFLT *arg2 = (PLFLT *) 0 ;
9003  PLFLT **arg3 = (PLFLT **) 0 ;
9004  PLINT arg4 ;
9005  PLINT arg5 ;
9006  PLINT arg6 ;
9007  PLFLT *arg7 = (PLFLT *) 0 ;
9008  PLINT arg8 ;
9009  PyArrayObject *tmp1 = NULL ;
9010  PyArrayObject *tmp2 = NULL ;
9011  PyArrayObject *tmp3 = NULL ;
9012  int val6 ;
9013  int ecode6 = 0 ;
9014  PyArrayObject *tmp7 = NULL ;
9015  PyObject * obj0 = 0 ;
9016  PyObject * obj1 = 0 ;
9017  PyObject * obj2 = 0 ;
9018  PyObject * obj3 = 0 ;
9019  PyObject * obj4 = 0 ;
9020 
9021  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9022  {
9023  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9024  if ( tmp1 == NULL )
9025  return NULL;
9026  Xlen = PyArray_DIMS( tmp1 )[0];
9027  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9028  }
9029  {
9030  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9031  if ( tmp2 == NULL )
9032  return NULL;
9033  Ylen = PyArray_DIMS( tmp2 )[0];
9034  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9035  }
9036  {
9037  int i, size;
9038  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9039  if ( tmp3 == NULL )
9040  return NULL;
9041  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9042  {
9043  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9044  return NULL;
9045  }
9046  arg4 = PyArray_DIMS( tmp3 )[0];
9047  arg5 = PyArray_DIMS( tmp3 )[1];
9048  size = arg5;
9049  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9050  for ( i = 0; i < arg4; i++ )
9051  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9052  }
9053  ecode6 = SWIG_AsVal_int(obj3, &val6);
9054  if (!SWIG_IsOK(ecode6)) {
9055  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9056  }
9057  arg6 = (PLINT)(val6);
9058  {
9059  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9060  if ( tmp7 == NULL )
9061  return NULL;
9062  arg8 = PyArray_DIMS( tmp7 )[0];
9063  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9064  }
9065  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9066  resultobj = SWIG_Py_Void();
9067  {
9068  Py_CLEAR( tmp1 );
9069  }
9070  {
9071  Py_CLEAR( tmp2 );
9072  }
9073  {
9074  Py_CLEAR( tmp3 );
9075  free( arg3 );
9076  }
9077  {
9078  Py_CLEAR( tmp7 );
9079  }
9080  return resultobj;
9081 fail:
9082  {
9083  Py_CLEAR( tmp1 );
9084  }
9085  {
9086  Py_CLEAR( tmp2 );
9087  }
9088  {
9089  Py_CLEAR( tmp3 );
9090  free( arg3 );
9091  }
9092  {
9093  Py_CLEAR( tmp7 );
9094  }
9095  return NULL;
9096 }
9097 
9098 
9099 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9100  PyObject *resultobj = 0;
9101  PLINT *arg1 = (PLINT *) 0 ;
9102  PLINT temp1 ;
9103  int res1 = SWIG_TMPOBJ ;
9104 
9105  arg1 = &temp1;
9106  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
9107  plmkstrm(arg1);
9108  resultobj = SWIG_Py_Void();
9109  if (SWIG_IsTmpObj(res1)) {
9110  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9111  } else {
9112  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9113  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9114  }
9115  return resultobj;
9116 fail:
9117  return NULL;
9118 }
9119 
9120 
9121 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122  PyObject *resultobj = 0;
9123  char *arg1 = (char *) 0 ;
9124  PLFLT arg2 ;
9125  PLFLT arg3 ;
9126  PLFLT arg4 ;
9127  char *arg5 = (char *) 0 ;
9128  int res1 ;
9129  char *buf1 = 0 ;
9130  int alloc1 = 0 ;
9131  double val2 ;
9132  int ecode2 = 0 ;
9133  double val3 ;
9134  int ecode3 = 0 ;
9135  double val4 ;
9136  int ecode4 = 0 ;
9137  int res5 ;
9138  char *buf5 = 0 ;
9139  int alloc5 = 0 ;
9140  PyObject * obj0 = 0 ;
9141  PyObject * obj1 = 0 ;
9142  PyObject * obj2 = 0 ;
9143  PyObject * obj3 = 0 ;
9144  PyObject * obj4 = 0 ;
9145 
9146  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9147  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9148  if (!SWIG_IsOK(res1)) {
9149  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9150  }
9151  arg1 = (char *)(buf1);
9152  ecode2 = SWIG_AsVal_double(obj1, &val2);
9153  if (!SWIG_IsOK(ecode2)) {
9154  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9155  }
9156  arg2 = (PLFLT)(val2);
9157  ecode3 = SWIG_AsVal_double(obj2, &val3);
9158  if (!SWIG_IsOK(ecode3)) {
9159  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9160  }
9161  arg3 = (PLFLT)(val3);
9162  ecode4 = SWIG_AsVal_double(obj3, &val4);
9163  if (!SWIG_IsOK(ecode4)) {
9164  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9165  }
9166  arg4 = (PLFLT)(val4);
9167  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9168  if (!SWIG_IsOK(res5)) {
9169  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9170  }
9171  arg5 = (char *)(buf5);
9172  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9173  resultobj = SWIG_Py_Void();
9174  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9175  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9176  return resultobj;
9177 fail:
9178  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9179  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9180  return NULL;
9181 }
9182 
9183 
9184 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9185  PyObject *resultobj = 0;
9186  char *arg1 = (char *) 0 ;
9187  PLFLT arg2 ;
9188  PLFLT arg3 ;
9189  PLFLT arg4 ;
9190  char *arg5 = (char *) 0 ;
9191  int res1 ;
9192  char *buf1 = 0 ;
9193  int alloc1 = 0 ;
9194  double val2 ;
9195  int ecode2 = 0 ;
9196  double val3 ;
9197  int ecode3 = 0 ;
9198  double val4 ;
9199  int ecode4 = 0 ;
9200  int res5 ;
9201  char *buf5 = 0 ;
9202  int alloc5 = 0 ;
9203  PyObject * obj0 = 0 ;
9204  PyObject * obj1 = 0 ;
9205  PyObject * obj2 = 0 ;
9206  PyObject * obj3 = 0 ;
9207  PyObject * obj4 = 0 ;
9208 
9209  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9210  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9211  if (!SWIG_IsOK(res1)) {
9212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9213  }
9214  arg1 = (char *)(buf1);
9215  ecode2 = SWIG_AsVal_double(obj1, &val2);
9216  if (!SWIG_IsOK(ecode2)) {
9217  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9218  }
9219  arg2 = (PLFLT)(val2);
9220  ecode3 = SWIG_AsVal_double(obj2, &val3);
9221  if (!SWIG_IsOK(ecode3)) {
9222  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9223  }
9224  arg3 = (PLFLT)(val3);
9225  ecode4 = SWIG_AsVal_double(obj3, &val4);
9226  if (!SWIG_IsOK(ecode4)) {
9227  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9228  }
9229  arg4 = (PLFLT)(val4);
9230  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9231  if (!SWIG_IsOK(res5)) {
9232  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9233  }
9234  arg5 = (char *)(buf5);
9235  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9236  resultobj = SWIG_Py_Void();
9237  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9238  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9239  return resultobj;
9240 fail:
9241  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9242  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9243  return NULL;
9244 }
9245 
9246 
9247 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248  PyObject *resultobj = 0;
9249  PLFLT *arg1 = (PLFLT *) 0 ;
9250  PLFLT *arg2 = (PLFLT *) 0 ;
9251  PLFLT **arg3 = (PLFLT **) 0 ;
9252  PLINT arg4 ;
9253  PLINT arg5 ;
9254  PLINT arg6 ;
9255  PLBOOL arg7 ;
9256  PyArrayObject *tmp1 = NULL ;
9257  PyArrayObject *tmp2 = NULL ;
9258  PyArrayObject *tmp3 = NULL ;
9259  int val6 ;
9260  int ecode6 = 0 ;
9261  int val7 ;
9262  int ecode7 = 0 ;
9263  PyObject * obj0 = 0 ;
9264  PyObject * obj1 = 0 ;
9265  PyObject * obj2 = 0 ;
9266  PyObject * obj3 = 0 ;
9267  PyObject * obj4 = 0 ;
9268 
9269  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9270  {
9271  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9272  if ( tmp1 == NULL )
9273  return NULL;
9274  Xlen = PyArray_DIMS( tmp1 )[0];
9275  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9276  }
9277  {
9278  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9279  if ( tmp2 == NULL )
9280  return NULL;
9281  Ylen = PyArray_DIMS( tmp2 )[0];
9282  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9283  }
9284  {
9285  int i, size;
9286  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9287  if ( tmp3 == NULL )
9288  return NULL;
9289  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9290  {
9291  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9292  return NULL;
9293  }
9294  arg4 = PyArray_DIMS( tmp3 )[0];
9295  arg5 = PyArray_DIMS( tmp3 )[1];
9296  size = arg5;
9297  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9298  for ( i = 0; i < arg4; i++ )
9299  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9300  }
9301  ecode6 = SWIG_AsVal_int(obj3, &val6);
9302  if (!SWIG_IsOK(ecode6)) {
9303  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9304  }
9305  arg6 = (PLINT)(val6);
9306  ecode7 = SWIG_AsVal_int(obj4, &val7);
9307  if (!SWIG_IsOK(ecode7)) {
9308  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9309  }
9310  arg7 = (PLBOOL)(val7);
9311  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9312  resultobj = SWIG_Py_Void();
9313  {
9314  Py_CLEAR( tmp1 );
9315  }
9316  {
9317  Py_CLEAR( tmp2 );
9318  }
9319  {
9320  Py_CLEAR( tmp3 );
9321  free( arg3 );
9322  }
9323  return resultobj;
9324 fail:
9325  {
9326  Py_CLEAR( tmp1 );
9327  }
9328  {
9329  Py_CLEAR( tmp2 );
9330  }
9331  {
9332  Py_CLEAR( tmp3 );
9333  free( arg3 );
9334  }
9335  return NULL;
9336 }
9337 
9338 
9339 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340  PyObject *resultobj = 0;
9341  PLFLT *arg1 = (PLFLT *) 0 ;
9342  PLFLT *arg2 = (PLFLT *) 0 ;
9343  PLFLT **arg3 = (PLFLT **) 0 ;
9344  PLINT arg4 ;
9345  PLINT arg5 ;
9346  PLINT arg6 ;
9347  PLFLT *arg7 = (PLFLT *) 0 ;
9348  PLINT arg8 ;
9349  PyArrayObject *tmp1 = NULL ;
9350  PyArrayObject *tmp2 = NULL ;
9351  PyArrayObject *tmp3 = NULL ;
9352  int val6 ;
9353  int ecode6 = 0 ;
9354  PyArrayObject *tmp7 = NULL ;
9355  PyObject * obj0 = 0 ;
9356  PyObject * obj1 = 0 ;
9357  PyObject * obj2 = 0 ;
9358  PyObject * obj3 = 0 ;
9359  PyObject * obj4 = 0 ;
9360 
9361  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9362  {
9363  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9364  if ( tmp1 == NULL )
9365  return NULL;
9366  Xlen = PyArray_DIMS( tmp1 )[0];
9367  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9368  }
9369  {
9370  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9371  if ( tmp2 == NULL )
9372  return NULL;
9373  Ylen = PyArray_DIMS( tmp2 )[0];
9374  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9375  }
9376  {
9377  int i, size;
9378  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9379  if ( tmp3 == NULL )
9380  return NULL;
9381  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9382  {
9383  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9384  return NULL;
9385  }
9386  arg4 = PyArray_DIMS( tmp3 )[0];
9387  arg5 = PyArray_DIMS( tmp3 )[1];
9388  size = arg5;
9389  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9390  for ( i = 0; i < arg4; i++ )
9391  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9392  }
9393  ecode6 = SWIG_AsVal_int(obj3, &val6);
9394  if (!SWIG_IsOK(ecode6)) {
9395  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9396  }
9397  arg6 = (PLINT)(val6);
9398  {
9399  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9400  if ( tmp7 == NULL )
9401  return NULL;
9402  arg8 = PyArray_DIMS( tmp7 )[0];
9403  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9404  }
9405  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9406  resultobj = SWIG_Py_Void();
9407  {
9408  Py_CLEAR( tmp1 );
9409  }
9410  {
9411  Py_CLEAR( tmp2 );
9412  }
9413  {
9414  Py_CLEAR( tmp3 );
9415  free( arg3 );
9416  }
9417  {
9418  Py_CLEAR( tmp7 );
9419  }
9420  return resultobj;
9421 fail:
9422  {
9423  Py_CLEAR( tmp1 );
9424  }
9425  {
9426  Py_CLEAR( tmp2 );
9427  }
9428  {
9429  Py_CLEAR( tmp3 );
9430  free( arg3 );
9431  }
9432  {
9433  Py_CLEAR( tmp7 );
9434  }
9435  return NULL;
9436 }
9437 
9438 
9439 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9440  PyObject *resultobj = 0;
9441  PLFLT *arg1 = (PLFLT *) 0 ;
9442  PLFLT *arg2 = (PLFLT *) 0 ;
9443  PLFLT **arg3 = (PLFLT **) 0 ;
9444  PLINT arg4 ;
9445  PLINT arg5 ;
9446  PLINT arg6 ;
9447  PLFLT *arg7 = (PLFLT *) 0 ;
9448  PLINT arg8 ;
9449  PLINT arg9 ;
9450  PLINT arg10 ;
9451  PLINT *arg11 = (PLINT *) 0 ;
9452  PLINT *arg12 = (PLINT *) 0 ;
9453  PyArrayObject *tmp1 = NULL ;
9454  PyArrayObject *tmp2 = NULL ;
9455  PyArrayObject *tmp3 = NULL ;
9456  int val6 ;
9457  int ecode6 = 0 ;
9458  PyArrayObject *tmp7 = NULL ;
9459  int val9 ;
9460  int ecode9 = 0 ;
9461  PyArrayObject *tmp10 = NULL ;
9462  PyArrayObject *tmp12 = NULL ;
9463  PyObject * obj0 = 0 ;
9464  PyObject * obj1 = 0 ;
9465  PyObject * obj2 = 0 ;
9466  PyObject * obj3 = 0 ;
9467  PyObject * obj4 = 0 ;
9468  PyObject * obj5 = 0 ;
9469  PyObject * obj6 = 0 ;
9470  PyObject * obj7 = 0 ;
9471 
9472  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9473  {
9474  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9475  if ( tmp1 == NULL )
9476  return NULL;
9477  Xlen = PyArray_DIMS( tmp1 )[0];
9478  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9479  }
9480  {
9481  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9482  if ( tmp2 == NULL )
9483  return NULL;
9484  Ylen = PyArray_DIMS( tmp2 )[0];
9485  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9486  }
9487  {
9488  int i, size;
9489  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9490  if ( tmp3 == NULL )
9491  return NULL;
9492  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9493  {
9494  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9495  return NULL;
9496  }
9497  arg4 = PyArray_DIMS( tmp3 )[0];
9498  arg5 = PyArray_DIMS( tmp3 )[1];
9499  size = arg5;
9500  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9501  for ( i = 0; i < arg4; i++ )
9502  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9503  }
9504  ecode6 = SWIG_AsVal_int(obj3, &val6);
9505  if (!SWIG_IsOK(ecode6)) {
9506  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9507  }
9508  arg6 = (PLINT)(val6);
9509  {
9510  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9511  if ( tmp7 == NULL )
9512  return NULL;
9513  arg8 = PyArray_DIMS( tmp7 )[0];
9514  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9515  }
9516  ecode9 = SWIG_AsVal_int(obj5, &val9);
9517  if (!SWIG_IsOK(ecode9)) {
9518  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9519  }
9520  arg9 = (PLINT)(val9);
9521  {
9522  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9523  if ( tmp10 == NULL )
9524  return NULL;
9525  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9526  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9527  }
9528  {
9529  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9530  if ( tmp12 == NULL )
9531  return NULL;
9532  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9533  {
9534  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9535  return NULL;
9536  }
9537  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9538  }
9539  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);
9540  resultobj = SWIG_Py_Void();
9541  {
9542  Py_CLEAR( tmp1 );
9543  }
9544  {
9545  Py_CLEAR( tmp2 );
9546  }
9547  {
9548  Py_CLEAR( tmp3 );
9549  free( arg3 );
9550  }
9551  {
9552  Py_CLEAR( tmp7 );
9553  }
9554  {
9555  Py_CLEAR( tmp10 );
9556  }
9557  {
9558  Py_CLEAR( tmp12 );
9559  }
9560  return resultobj;
9561 fail:
9562  {
9563  Py_CLEAR( tmp1 );
9564  }
9565  {
9566  Py_CLEAR( tmp2 );
9567  }
9568  {
9569  Py_CLEAR( tmp3 );
9570  free( arg3 );
9571  }
9572  {
9573  Py_CLEAR( tmp7 );
9574  }
9575  {
9576  Py_CLEAR( tmp10 );
9577  }
9578  {
9579  Py_CLEAR( tmp12 );
9580  }
9581  return NULL;
9582 }
9583 
9584 
9585 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9586  PyObject *resultobj = 0;
9587  PLFLT *arg1 = (PLFLT *) 0 ;
9588  PLFLT *arg2 = (PLFLT *) 0 ;
9589  PLFLT **arg3 = (PLFLT **) 0 ;
9590  PLINT arg4 ;
9591  PLINT arg5 ;
9592  PLINT arg6 ;
9593  PLFLT *arg7 = (PLFLT *) 0 ;
9594  PLINT arg8 ;
9595  PyArrayObject *tmp1 = NULL ;
9596  PyArrayObject *tmp2 = NULL ;
9597  PyArrayObject *tmp3 = NULL ;
9598  int val6 ;
9599  int ecode6 = 0 ;
9600  PyArrayObject *tmp7 = NULL ;
9601  PyObject * obj0 = 0 ;
9602  PyObject * obj1 = 0 ;
9603  PyObject * obj2 = 0 ;
9604  PyObject * obj3 = 0 ;
9605  PyObject * obj4 = 0 ;
9606 
9607  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9608  {
9609  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9610  if ( tmp1 == NULL )
9611  return NULL;
9612  Xlen = PyArray_DIMS( tmp1 )[0];
9613  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9614  }
9615  {
9616  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9617  if ( tmp2 == NULL )
9618  return NULL;
9619  Ylen = PyArray_DIMS( tmp2 )[0];
9620  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9621  }
9622  {
9623  int i, size;
9624  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9625  if ( tmp3 == NULL )
9626  return NULL;
9627  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9628  {
9629  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9630  return NULL;
9631  }
9632  arg4 = PyArray_DIMS( tmp3 )[0];
9633  arg5 = PyArray_DIMS( tmp3 )[1];
9634  size = arg5;
9635  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9636  for ( i = 0; i < arg4; i++ )
9637  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9638  }
9639  ecode6 = SWIG_AsVal_int(obj3, &val6);
9640  if (!SWIG_IsOK(ecode6)) {
9641  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9642  }
9643  arg6 = (PLINT)(val6);
9644  {
9645  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9646  if ( tmp7 == NULL )
9647  return NULL;
9648  arg8 = PyArray_DIMS( tmp7 )[0];
9649  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9650  }
9651  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9652  resultobj = SWIG_Py_Void();
9653  {
9654  Py_CLEAR( tmp1 );
9655  }
9656  {
9657  Py_CLEAR( tmp2 );
9658  }
9659  {
9660  Py_CLEAR( tmp3 );
9661  free( arg3 );
9662  }
9663  {
9664  Py_CLEAR( tmp7 );
9665  }
9666  return resultobj;
9667 fail:
9668  {
9669  Py_CLEAR( tmp1 );
9670  }
9671  {
9672  Py_CLEAR( tmp2 );
9673  }
9674  {
9675  Py_CLEAR( tmp3 );
9676  free( arg3 );
9677  }
9678  {
9679  Py_CLEAR( tmp7 );
9680  }
9681  return NULL;
9682 }
9683 
9684 
9685 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9686  PyObject *resultobj = 0;
9687  PLFLT *arg1 = (PLFLT *) 0 ;
9688  PLFLT *arg2 = (PLFLT *) 0 ;
9689  PLFLT **arg3 = (PLFLT **) 0 ;
9690  PLINT arg4 ;
9691  PLINT arg5 ;
9692  PLINT arg6 ;
9693  PLFLT *arg7 = (PLFLT *) 0 ;
9694  PLINT arg8 ;
9695  PLINT arg9 ;
9696  PLINT arg10 ;
9697  PLINT *arg11 = (PLINT *) 0 ;
9698  PLINT *arg12 = (PLINT *) 0 ;
9699  PyArrayObject *tmp1 = NULL ;
9700  PyArrayObject *tmp2 = NULL ;
9701  PyArrayObject *tmp3 = NULL ;
9702  int val6 ;
9703  int ecode6 = 0 ;
9704  PyArrayObject *tmp7 = NULL ;
9705  int val9 ;
9706  int ecode9 = 0 ;
9707  PyArrayObject *tmp10 = NULL ;
9708  PyArrayObject *tmp12 = NULL ;
9709  PyObject * obj0 = 0 ;
9710  PyObject * obj1 = 0 ;
9711  PyObject * obj2 = 0 ;
9712  PyObject * obj3 = 0 ;
9713  PyObject * obj4 = 0 ;
9714  PyObject * obj5 = 0 ;
9715  PyObject * obj6 = 0 ;
9716  PyObject * obj7 = 0 ;
9717 
9718  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9719  {
9720  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9721  if ( tmp1 == NULL )
9722  return NULL;
9723  Xlen = PyArray_DIMS( tmp1 )[0];
9724  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9725  }
9726  {
9727  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9728  if ( tmp2 == NULL )
9729  return NULL;
9730  Ylen = PyArray_DIMS( tmp2 )[0];
9731  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9732  }
9733  {
9734  int i, size;
9735  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9736  if ( tmp3 == NULL )
9737  return NULL;
9738  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9739  {
9740  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9741  return NULL;
9742  }
9743  arg4 = PyArray_DIMS( tmp3 )[0];
9744  arg5 = PyArray_DIMS( tmp3 )[1];
9745  size = arg5;
9746  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9747  for ( i = 0; i < arg4; i++ )
9748  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9749  }
9750  ecode6 = SWIG_AsVal_int(obj3, &val6);
9751  if (!SWIG_IsOK(ecode6)) {
9752  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9753  }
9754  arg6 = (PLINT)(val6);
9755  {
9756  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9757  if ( tmp7 == NULL )
9758  return NULL;
9759  arg8 = PyArray_DIMS( tmp7 )[0];
9760  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9761  }
9762  ecode9 = SWIG_AsVal_int(obj5, &val9);
9763  if (!SWIG_IsOK(ecode9)) {
9764  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9765  }
9766  arg9 = (PLINT)(val9);
9767  {
9768  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9769  if ( tmp10 == NULL )
9770  return NULL;
9771  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9772  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9773  }
9774  {
9775  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9776  if ( tmp12 == NULL )
9777  return NULL;
9778  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9779  {
9780  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9781  return NULL;
9782  }
9783  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9784  }
9785  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);
9786  resultobj = SWIG_Py_Void();
9787  {
9788  Py_CLEAR( tmp1 );
9789  }
9790  {
9791  Py_CLEAR( tmp2 );
9792  }
9793  {
9794  Py_CLEAR( tmp3 );
9795  free( arg3 );
9796  }
9797  {
9798  Py_CLEAR( tmp7 );
9799  }
9800  {
9801  Py_CLEAR( tmp10 );
9802  }
9803  {
9804  Py_CLEAR( tmp12 );
9805  }
9806  return resultobj;
9807 fail:
9808  {
9809  Py_CLEAR( tmp1 );
9810  }
9811  {
9812  Py_CLEAR( tmp2 );
9813  }
9814  {
9815  Py_CLEAR( tmp3 );
9816  free( arg3 );
9817  }
9818  {
9819  Py_CLEAR( tmp7 );
9820  }
9821  {
9822  Py_CLEAR( tmp10 );
9823  }
9824  {
9825  Py_CLEAR( tmp12 );
9826  }
9827  return NULL;
9828 }
9829 
9830 
9831 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832  PyObject *resultobj = 0;
9833  int *arg1 = (int *) 0 ;
9834  char **arg2 = (char **) 0 ;
9835  PLINT arg3 ;
9836  int tmp1 ;
9837  int val3 ;
9838  int ecode3 = 0 ;
9839  PyObject * obj0 = 0 ;
9840  PyObject * obj1 = 0 ;
9841  PLINT result;
9842 
9843  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9844  {
9845  int i;
9846  PyObject *unicode_string;
9847 
9848  if ( !PyList_Check( obj0 ) )
9849  {
9850  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9851  return NULL;
9852  }
9853  tmp1 = PyList_Size( obj0 );
9854  arg1 = &tmp1;
9855  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9856  for ( i = 0; i < tmp1; i++ )
9857  {
9858  PyObject *s = PyList_GetItem( obj0, i );
9859  if ( PyString_Check( s ) )
9860  {
9861  arg2[i] = PyString_AsString( s );
9862  }
9863  else if ( PyUnicode_Check( s ) )
9864  {
9865  // unicode_string is never freed? memory leak here?
9866  unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9867  arg2[i] = PyBytes_AS_STRING( unicode_string );
9868  }
9869  else
9870  {
9871  free( arg2 );
9872  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9873  return NULL;
9874  }
9875  }
9876  arg2[i] = 0;
9877  }
9878  ecode3 = SWIG_AsVal_int(obj1, &val3);
9879  if (!SWIG_IsOK(ecode3)) {
9880  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9881  }
9882  arg3 = (PLINT)(val3);
9883  result = (PLINT)plparseopts(arg1,arg2,arg3);
9884  resultobj = SWIG_From_int((int)(result));
9885  {
9886  if ( arg2 )
9887  free( arg2 );
9888  }
9889  return resultobj;
9890 fail:
9891  {
9892  if ( arg2 )
9893  free( arg2 );
9894  }
9895  return NULL;
9896 }
9897 
9898 
9899 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9900  PyObject *resultobj = 0;
9901  PLINT arg1 ;
9902  PLINT *arg2 = (PLINT *) 0 ;
9903  PLINT *arg3 = (PLINT *) 0 ;
9904  PyArrayObject *tmp1 = NULL ;
9905  PyArrayObject *tmp3 = NULL ;
9906  PyObject * obj0 = 0 ;
9907  PyObject * obj1 = 0 ;
9908 
9909  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9910  {
9911  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9912  if ( tmp1 == NULL )
9913  return NULL;
9914  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9915  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9916  }
9917  {
9918  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9919  if ( tmp3 == NULL )
9920  return NULL;
9921  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9922  {
9923  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9924  return NULL;
9925  }
9926  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9927  }
9928  plpat(arg1,(int const *)arg2,(int const *)arg3);
9929  resultobj = SWIG_Py_Void();
9930  {
9931  Py_CLEAR( tmp1 );
9932  }
9933  {
9934  Py_CLEAR( tmp3 );
9935  }
9936  return resultobj;
9937 fail:
9938  {
9939  Py_CLEAR( tmp1 );
9940  }
9941  {
9942  Py_CLEAR( tmp3 );
9943  }
9944  return NULL;
9945 }
9946 
9947 
9948 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9949  PyObject *resultobj = 0;
9950  PLINT arg1 ;
9951  PLFLT arg2 ;
9952  PLFLT arg3 ;
9953  PLFLT arg4 ;
9954  PLFLT arg5 ;
9955  int val1 ;
9956  int ecode1 = 0 ;
9957  double val2 ;
9958  int ecode2 = 0 ;
9959  double val3 ;
9960  int ecode3 = 0 ;
9961  double val4 ;
9962  int ecode4 = 0 ;
9963  double val5 ;
9964  int ecode5 = 0 ;
9965  PyObject * obj0 = 0 ;
9966  PyObject * obj1 = 0 ;
9967  PyObject * obj2 = 0 ;
9968  PyObject * obj3 = 0 ;
9969  PyObject * obj4 = 0 ;
9970 
9971  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9972  ecode1 = SWIG_AsVal_int(obj0, &val1);
9973  if (!SWIG_IsOK(ecode1)) {
9974  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9975  }
9976  arg1 = (PLINT)(val1);
9977  ecode2 = SWIG_AsVal_double(obj1, &val2);
9978  if (!SWIG_IsOK(ecode2)) {
9979  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9980  }
9981  arg2 = (PLFLT)(val2);
9982  ecode3 = SWIG_AsVal_double(obj2, &val3);
9983  if (!SWIG_IsOK(ecode3)) {
9984  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9985  }
9986  arg3 = (PLFLT)(val3);
9987  ecode4 = SWIG_AsVal_double(obj3, &val4);
9988  if (!SWIG_IsOK(ecode4)) {
9989  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9990  }
9991  arg4 = (PLFLT)(val4);
9992  ecode5 = SWIG_AsVal_double(obj4, &val5);
9993  if (!SWIG_IsOK(ecode5)) {
9994  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9995  }
9996  arg5 = (PLFLT)(val5);
9997  plpath(arg1,arg2,arg3,arg4,arg5);
9998  resultobj = SWIG_Py_Void();
9999  return resultobj;
10000 fail:
10001  return NULL;
10002 }
10003 
10004 
10005 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10006  PyObject *resultobj = 0;
10007  PLINT arg1 ;
10008  PLFLT *arg2 = (PLFLT *) 0 ;
10009  PLFLT *arg3 = (PLFLT *) 0 ;
10010  PLINT arg4 ;
10011  PyArrayObject *tmp1 = NULL ;
10012  PyArrayObject *tmp3 = NULL ;
10013  int val4 ;
10014  int ecode4 = 0 ;
10015  PyObject * obj0 = 0 ;
10016  PyObject * obj1 = 0 ;
10017  PyObject * obj2 = 0 ;
10018 
10019  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
10020  {
10021  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10022  if ( tmp1 == NULL )
10023  return NULL;
10024  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10025  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10026  }
10027  {
10028  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10029  if ( tmp3 == NULL )
10030  return NULL;
10031  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10032  {
10033  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10034  return NULL;
10035  }
10036  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10037  }
10038  ecode4 = SWIG_AsVal_int(obj2, &val4);
10039  if (!SWIG_IsOK(ecode4)) {
10040  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10041  }
10042  arg4 = (PLINT)(val4);
10043  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10044  resultobj = SWIG_Py_Void();
10045  {
10046  Py_CLEAR( tmp1 );
10047  }
10048  {
10049  Py_CLEAR( tmp3 );
10050  }
10051  return resultobj;
10052 fail:
10053  {
10054  Py_CLEAR( tmp1 );
10055  }
10056  {
10057  Py_CLEAR( tmp3 );
10058  }
10059  return NULL;
10060 }
10061 
10062 
10063 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064  PyObject *resultobj = 0;
10065  PLINT arg1 ;
10066  PLFLT *arg2 = (PLFLT *) 0 ;
10067  PLFLT *arg3 = (PLFLT *) 0 ;
10068  PLFLT *arg4 = (PLFLT *) 0 ;
10069  PLINT arg5 ;
10070  PyArrayObject *tmp1 = NULL ;
10071  PyArrayObject *tmp3 = NULL ;
10072  PyArrayObject *tmp4 = NULL ;
10073  int val5 ;
10074  int ecode5 = 0 ;
10075  PyObject * obj0 = 0 ;
10076  PyObject * obj1 = 0 ;
10077  PyObject * obj2 = 0 ;
10078  PyObject * obj3 = 0 ;
10079 
10080  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10081  {
10082  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10083  if ( tmp1 == NULL )
10084  return NULL;
10085  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10086  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10087  }
10088  {
10089  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10090  if ( tmp3 == NULL )
10091  return NULL;
10092  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10093  {
10094  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10095  return NULL;
10096  }
10097  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10098  }
10099  {
10100  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10101  if ( tmp4 == NULL )
10102  return NULL;
10103  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10104  {
10105  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10106  return NULL;
10107  }
10108  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10109  }
10110  ecode5 = SWIG_AsVal_int(obj3, &val5);
10111  if (!SWIG_IsOK(ecode5)) {
10112  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10113  }
10114  arg5 = (PLINT)(val5);
10115  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10116  resultobj = SWIG_Py_Void();
10117  {
10118  Py_CLEAR( tmp1 );
10119  }
10120  {
10121  Py_CLEAR( tmp3 );
10122  }
10123  {
10124  Py_CLEAR( tmp4 );
10125  }
10126  return resultobj;
10127 fail:
10128  {
10129  Py_CLEAR( tmp1 );
10130  }
10131  {
10132  Py_CLEAR( tmp3 );
10133  }
10134  {
10135  Py_CLEAR( tmp4 );
10136  }
10137  return NULL;
10138 }
10139 
10140 
10141 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10142  PyObject *resultobj = 0;
10143  PLINT arg1 ;
10144  PLFLT *arg2 = (PLFLT *) 0 ;
10145  PLFLT *arg3 = (PLFLT *) 0 ;
10146  PLFLT *arg4 = (PLFLT *) 0 ;
10147  PLBOOL *arg5 = (PLBOOL *) 0 ;
10148  PLBOOL arg6 ;
10149  PyArrayObject *tmp1 = NULL ;
10150  PyArrayObject *tmp3 = NULL ;
10151  PyArrayObject *tmp4 = NULL ;
10152  PyArrayObject *tmp5 = NULL ;
10153  int val6 ;
10154  int ecode6 = 0 ;
10155  PyObject * obj0 = 0 ;
10156  PyObject * obj1 = 0 ;
10157  PyObject * obj2 = 0 ;
10158  PyObject * obj3 = 0 ;
10159  PyObject * obj4 = 0 ;
10160 
10161  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10162  {
10163  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10164  if ( tmp1 == NULL )
10165  return NULL;
10166  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10167  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10168  }
10169  {
10170  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10171  if ( tmp3 == NULL )
10172  return NULL;
10173  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10174  {
10175  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10176  return NULL;
10177  }
10178  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10179  }
10180  {
10181  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10182  if ( tmp4 == NULL )
10183  return NULL;
10184  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10185  {
10186  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10187  return NULL;
10188  }
10189  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10190  }
10191  {
10192  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10193  if ( tmp5 == NULL )
10194  return NULL;
10195  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10196  {
10197  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10198  return NULL;
10199  }
10200  arg5 = (PLINT *) PyArray_DATA( tmp5 );
10201  }
10202  ecode6 = SWIG_AsVal_int(obj4, &val6);
10203  if (!SWIG_IsOK(ecode6)) {
10204  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10205  }
10206  arg6 = (PLBOOL)(val6);
10207  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10208  resultobj = SWIG_Py_Void();
10209  {
10210  Py_CLEAR( tmp1 );
10211  }
10212  {
10213  Py_CLEAR( tmp3 );
10214  }
10215  {
10216  Py_CLEAR( tmp4 );
10217  }
10218  {
10219  Py_CLEAR( tmp5 );
10220  }
10221  return resultobj;
10222 fail:
10223  {
10224  Py_CLEAR( tmp1 );
10225  }
10226  {
10227  Py_CLEAR( tmp3 );
10228  }
10229  {
10230  Py_CLEAR( tmp4 );
10231  }
10232  {
10233  Py_CLEAR( tmp5 );
10234  }
10235  return NULL;
10236 }
10237 
10238 
10239 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10240  PyObject *resultobj = 0;
10241  PLINT arg1 ;
10242  PLINT arg2 ;
10243  int val1 ;
10244  int ecode1 = 0 ;
10245  int val2 ;
10246  int ecode2 = 0 ;
10247  PyObject * obj0 = 0 ;
10248  PyObject * obj1 = 0 ;
10249 
10250  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10251  ecode1 = SWIG_AsVal_int(obj0, &val1);
10252  if (!SWIG_IsOK(ecode1)) {
10253  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10254  }
10255  arg1 = (PLINT)(val1);
10256  ecode2 = SWIG_AsVal_int(obj1, &val2);
10257  if (!SWIG_IsOK(ecode2)) {
10258  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10259  }
10260  arg2 = (PLINT)(val2);
10261  plprec(arg1,arg2);
10262  resultobj = SWIG_Py_Void();
10263  return resultobj;
10264 fail:
10265  return NULL;
10266 }
10267 
10268 
10269 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10270  PyObject *resultobj = 0;
10271  PLINT arg1 ;
10272  int val1 ;
10273  int ecode1 = 0 ;
10274  PyObject * obj0 = 0 ;
10275 
10276  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10277  ecode1 = SWIG_AsVal_int(obj0, &val1);
10278  if (!SWIG_IsOK(ecode1)) {
10279  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10280  }
10281  arg1 = (PLINT)(val1);
10282  plpsty(arg1);
10283  resultobj = SWIG_Py_Void();
10284  return resultobj;
10285 fail:
10286  return NULL;
10287 }
10288 
10289 
10290 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291  PyObject *resultobj = 0;
10292  PLFLT arg1 ;
10293  PLFLT arg2 ;
10294  PLFLT arg3 ;
10295  PLFLT arg4 ;
10296  PLFLT arg5 ;
10297  char *arg6 = (char *) 0 ;
10298  double val1 ;
10299  int ecode1 = 0 ;
10300  double val2 ;
10301  int ecode2 = 0 ;
10302  double val3 ;
10303  int ecode3 = 0 ;
10304  double val4 ;
10305  int ecode4 = 0 ;
10306  double val5 ;
10307  int ecode5 = 0 ;
10308  int res6 ;
10309  char *buf6 = 0 ;
10310  int alloc6 = 0 ;
10311  PyObject * obj0 = 0 ;
10312  PyObject * obj1 = 0 ;
10313  PyObject * obj2 = 0 ;
10314  PyObject * obj3 = 0 ;
10315  PyObject * obj4 = 0 ;
10316  PyObject * obj5 = 0 ;
10317 
10318  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10319  ecode1 = SWIG_AsVal_double(obj0, &val1);
10320  if (!SWIG_IsOK(ecode1)) {
10321  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10322  }
10323  arg1 = (PLFLT)(val1);
10324  ecode2 = SWIG_AsVal_double(obj1, &val2);
10325  if (!SWIG_IsOK(ecode2)) {
10326  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10327  }
10328  arg2 = (PLFLT)(val2);
10329  ecode3 = SWIG_AsVal_double(obj2, &val3);
10330  if (!SWIG_IsOK(ecode3)) {
10331  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10332  }
10333  arg3 = (PLFLT)(val3);
10334  ecode4 = SWIG_AsVal_double(obj3, &val4);
10335  if (!SWIG_IsOK(ecode4)) {
10336  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10337  }
10338  arg4 = (PLFLT)(val4);
10339  ecode5 = SWIG_AsVal_double(obj4, &val5);
10340  if (!SWIG_IsOK(ecode5)) {
10341  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10342  }
10343  arg5 = (PLFLT)(val5);
10344  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10345  if (!SWIG_IsOK(res6)) {
10346  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10347  }
10348  arg6 = (char *)(buf6);
10349  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10350  resultobj = SWIG_Py_Void();
10351  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10352  return resultobj;
10353 fail:
10354  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10355  return NULL;
10356 }
10357 
10358 
10359 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10360  PyObject *resultobj = 0;
10361  PLFLT arg1 ;
10362  PLFLT arg2 ;
10363  PLFLT arg3 ;
10364  PLFLT arg4 ;
10365  PLFLT arg5 ;
10366  PLFLT arg6 ;
10367  PLFLT arg7 ;
10368  PLFLT arg8 ;
10369  PLFLT arg9 ;
10370  PLFLT arg10 ;
10371  char *arg11 = (char *) 0 ;
10372  double val1 ;
10373  int ecode1 = 0 ;
10374  double val2 ;
10375  int ecode2 = 0 ;
10376  double val3 ;
10377  int ecode3 = 0 ;
10378  double val4 ;
10379  int ecode4 = 0 ;
10380  double val5 ;
10381  int ecode5 = 0 ;
10382  double val6 ;
10383  int ecode6 = 0 ;
10384  double val7 ;
10385  int ecode7 = 0 ;
10386  double val8 ;
10387  int ecode8 = 0 ;
10388  double val9 ;
10389  int ecode9 = 0 ;
10390  double val10 ;
10391  int ecode10 = 0 ;
10392  int res11 ;
10393  char *buf11 = 0 ;
10394  int alloc11 = 0 ;
10395  PyObject * obj0 = 0 ;
10396  PyObject * obj1 = 0 ;
10397  PyObject * obj2 = 0 ;
10398  PyObject * obj3 = 0 ;
10399  PyObject * obj4 = 0 ;
10400  PyObject * obj5 = 0 ;
10401  PyObject * obj6 = 0 ;
10402  PyObject * obj7 = 0 ;
10403  PyObject * obj8 = 0 ;
10404  PyObject * obj9 = 0 ;
10405  PyObject * obj10 = 0 ;
10406 
10407  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10408  ecode1 = SWIG_AsVal_double(obj0, &val1);
10409  if (!SWIG_IsOK(ecode1)) {
10410  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10411  }
10412  arg1 = (PLFLT)(val1);
10413  ecode2 = SWIG_AsVal_double(obj1, &val2);
10414  if (!SWIG_IsOK(ecode2)) {
10415  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10416  }
10417  arg2 = (PLFLT)(val2);
10418  ecode3 = SWIG_AsVal_double(obj2, &val3);
10419  if (!SWIG_IsOK(ecode3)) {
10420  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10421  }
10422  arg3 = (PLFLT)(val3);
10423  ecode4 = SWIG_AsVal_double(obj3, &val4);
10424  if (!SWIG_IsOK(ecode4)) {
10425  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10426  }
10427  arg4 = (PLFLT)(val4);
10428  ecode5 = SWIG_AsVal_double(obj4, &val5);
10429  if (!SWIG_IsOK(ecode5)) {
10430  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10431  }
10432  arg5 = (PLFLT)(val5);
10433  ecode6 = SWIG_AsVal_double(obj5, &val6);
10434  if (!SWIG_IsOK(ecode6)) {
10435  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10436  }
10437  arg6 = (PLFLT)(val6);
10438  ecode7 = SWIG_AsVal_double(obj6, &val7);
10439  if (!SWIG_IsOK(ecode7)) {
10440  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10441  }
10442  arg7 = (PLFLT)(val7);
10443  ecode8 = SWIG_AsVal_double(obj7, &val8);
10444  if (!SWIG_IsOK(ecode8)) {
10445  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10446  }
10447  arg8 = (PLFLT)(val8);
10448  ecode9 = SWIG_AsVal_double(obj8, &val9);
10449  if (!SWIG_IsOK(ecode9)) {
10450  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10451  }
10452  arg9 = (PLFLT)(val9);
10453  ecode10 = SWIG_AsVal_double(obj9, &val10);
10454  if (!SWIG_IsOK(ecode10)) {
10455  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10456  }
10457  arg10 = (PLFLT)(val10);
10458  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10459  if (!SWIG_IsOK(res11)) {
10460  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10461  }
10462  arg11 = (char *)(buf11);
10463  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10464  resultobj = SWIG_Py_Void();
10465  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10466  return resultobj;
10467 fail:
10468  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10469  return NULL;
10470 }
10471 
10472 
10473 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474  PyObject *resultobj = 0;
10475  PLFLT result;
10476 
10477  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10478  result = (PLFLT)plrandd();
10479  resultobj = SWIG_From_double((double)(result));
10480  return resultobj;
10481 fail:
10482  return NULL;
10483 }
10484 
10485 
10486 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10487  PyObject *resultobj = 0;
10488 
10489  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10490  plreplot();
10491  resultobj = SWIG_Py_Void();
10492  return resultobj;
10493 fail:
10494  return NULL;
10495 }
10496 
10497 
10498 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10499  PyObject *resultobj = 0;
10500  PLFLT arg1 ;
10501  PLFLT arg2 ;
10502  PLFLT arg3 ;
10503  PLFLT *arg4 = (PLFLT *) 0 ;
10504  PLFLT *arg5 = (PLFLT *) 0 ;
10505  PLFLT *arg6 = (PLFLT *) 0 ;
10506  double val1 ;
10507  int ecode1 = 0 ;
10508  double val2 ;
10509  int ecode2 = 0 ;
10510  double val3 ;
10511  int ecode3 = 0 ;
10512  PLFLT temp4 ;
10513  int res4 = SWIG_TMPOBJ ;
10514  PLFLT temp5 ;
10515  int res5 = SWIG_TMPOBJ ;
10516  PLFLT temp6 ;
10517  int res6 = SWIG_TMPOBJ ;
10518  PyObject * obj0 = 0 ;
10519  PyObject * obj1 = 0 ;
10520  PyObject * obj2 = 0 ;
10521 
10522  arg4 = &temp4;
10523  arg5 = &temp5;
10524  arg6 = &temp6;
10525  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10526  ecode1 = SWIG_AsVal_double(obj0, &val1);
10527  if (!SWIG_IsOK(ecode1)) {
10528  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10529  }
10530  arg1 = (PLFLT)(val1);
10531  ecode2 = SWIG_AsVal_double(obj1, &val2);
10532  if (!SWIG_IsOK(ecode2)) {
10533  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10534  }
10535  arg2 = (PLFLT)(val2);
10536  ecode3 = SWIG_AsVal_double(obj2, &val3);
10537  if (!SWIG_IsOK(ecode3)) {
10538  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10539  }
10540  arg3 = (PLFLT)(val3);
10541  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10542  resultobj = SWIG_Py_Void();
10543  if (SWIG_IsTmpObj(res4)) {
10544  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10545  } else {
10546  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10547  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10548  }
10549  if (SWIG_IsTmpObj(res5)) {
10550  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10551  } else {
10552  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10553  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10554  }
10555  if (SWIG_IsTmpObj(res6)) {
10556  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10557  } else {
10558  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10559  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10560  }
10561  return resultobj;
10562 fail:
10563  return NULL;
10564 }
10565 
10566 
10567 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568  PyObject *resultobj = 0;
10569  PLFLT arg1 ;
10570  PLFLT arg2 ;
10571  double val1 ;
10572  int ecode1 = 0 ;
10573  double val2 ;
10574  int ecode2 = 0 ;
10575  PyObject * obj0 = 0 ;
10576  PyObject * obj1 = 0 ;
10577 
10578  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10579  ecode1 = SWIG_AsVal_double(obj0, &val1);
10580  if (!SWIG_IsOK(ecode1)) {
10581  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10582  }
10583  arg1 = (PLFLT)(val1);
10584  ecode2 = SWIG_AsVal_double(obj1, &val2);
10585  if (!SWIG_IsOK(ecode2)) {
10586  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10587  }
10588  arg2 = (PLFLT)(val2);
10589  plschr(arg1,arg2);
10590  resultobj = SWIG_Py_Void();
10591  return resultobj;
10592 fail:
10593  return NULL;
10594 }
10595 
10596 
10597 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598  PyObject *resultobj = 0;
10599  PLINT *arg1 = (PLINT *) 0 ;
10600  PLINT *arg2 = (PLINT *) 0 ;
10601  PLINT *arg3 = (PLINT *) 0 ;
10602  PLINT arg4 ;
10603  PyArrayObject *tmp1 = NULL ;
10604  PyArrayObject *tmp2 = NULL ;
10605  PyArrayObject *tmp3 = NULL ;
10606  PyObject * obj0 = 0 ;
10607  PyObject * obj1 = 0 ;
10608  PyObject * obj2 = 0 ;
10609 
10610  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10611  {
10612  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10613  if ( tmp1 == NULL )
10614  return NULL;
10615  Alen = PyArray_DIMS( tmp1 )[0];
10616  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10617  }
10618  {
10619  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10620  if ( tmp2 == NULL )
10621  return NULL;
10622  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10623  {
10624  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10625  return NULL;
10626  }
10627  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10628  }
10629  {
10630  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10631  if ( tmp3 == NULL )
10632  return NULL;
10633  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10634  {
10635  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10636  return NULL;
10637  }
10638  arg4 = PyArray_DIMS( tmp3 )[0];
10639  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10640  }
10641  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10642  resultobj = SWIG_Py_Void();
10643  {
10644  Py_CLEAR( tmp1 );
10645  }
10646  {
10647  Py_CLEAR( tmp2 );
10648  }
10649  {
10650  Py_CLEAR( tmp3 );
10651  }
10652  return resultobj;
10653 fail:
10654  {
10655  Py_CLEAR( tmp1 );
10656  }
10657  {
10658  Py_CLEAR( tmp2 );
10659  }
10660  {
10661  Py_CLEAR( tmp3 );
10662  }
10663  return NULL;
10664 }
10665 
10666 
10667 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10668  PyObject *resultobj = 0;
10669  PLINT *arg1 = (PLINT *) 0 ;
10670  PLINT *arg2 = (PLINT *) 0 ;
10671  PLINT *arg3 = (PLINT *) 0 ;
10672  PLFLT *arg4 = (PLFLT *) 0 ;
10673  PLINT arg5 ;
10674  PyArrayObject *tmp1 = NULL ;
10675  PyArrayObject *tmp2 = NULL ;
10676  PyArrayObject *tmp3 = NULL ;
10677  PyArrayObject *tmp4 = NULL ;
10678  PyObject * obj0 = 0 ;
10679  PyObject * obj1 = 0 ;
10680  PyObject * obj2 = 0 ;
10681  PyObject * obj3 = 0 ;
10682 
10683  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10684  {
10685  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10686  if ( tmp1 == NULL )
10687  return NULL;
10688  Alen = PyArray_DIMS( tmp1 )[0];
10689  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10690  }
10691  {
10692  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10693  if ( tmp2 == NULL )
10694  return NULL;
10695  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10696  {
10697  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10698  return NULL;
10699  }
10700  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10701  }
10702  {
10703  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10704  if ( tmp3 == NULL )
10705  return NULL;
10706  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10707  {
10708  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10709  return NULL;
10710  }
10711  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10712  }
10713  {
10714  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10715  if ( tmp4 == NULL )
10716  return NULL;
10717  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10718  {
10719  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10720  return NULL;
10721  }
10722  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10723  arg5 = PyArray_DIMS( tmp4 )[0];
10724  }
10725  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10726  resultobj = SWIG_Py_Void();
10727  {
10728  Py_CLEAR( tmp1 );
10729  }
10730  {
10731  Py_CLEAR( tmp2 );
10732  }
10733  {
10734  Py_CLEAR( tmp3 );
10735  }
10736  {
10737  Py_CLEAR( tmp4 );
10738  }
10739  return resultobj;
10740 fail:
10741  {
10742  Py_CLEAR( tmp1 );
10743  }
10744  {
10745  Py_CLEAR( tmp2 );
10746  }
10747  {
10748  Py_CLEAR( tmp3 );
10749  }
10750  {
10751  Py_CLEAR( tmp4 );
10752  }
10753  return NULL;
10754 }
10755 
10756 
10757 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10758  PyObject *resultobj = 0;
10759  PLINT arg1 ;
10760  int val1 ;
10761  int ecode1 = 0 ;
10762  PyObject * obj0 = 0 ;
10763 
10764  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10765  ecode1 = SWIG_AsVal_int(obj0, &val1);
10766  if (!SWIG_IsOK(ecode1)) {
10767  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10768  }
10769  arg1 = (PLINT)(val1);
10770  plscmap0n(arg1);
10771  resultobj = SWIG_Py_Void();
10772  return resultobj;
10773 fail:
10774  return NULL;
10775 }
10776 
10777 
10778 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779  PyObject *resultobj = 0;
10780  PLINT *arg1 = (PLINT *) 0 ;
10781  PLINT *arg2 = (PLINT *) 0 ;
10782  PLINT *arg3 = (PLINT *) 0 ;
10783  PLINT arg4 ;
10784  PyArrayObject *tmp1 = NULL ;
10785  PyArrayObject *tmp2 = NULL ;
10786  PyArrayObject *tmp3 = NULL ;
10787  PyObject * obj0 = 0 ;
10788  PyObject * obj1 = 0 ;
10789  PyObject * obj2 = 0 ;
10790 
10791  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10792  {
10793  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10794  if ( tmp1 == NULL )
10795  return NULL;
10796  Alen = PyArray_DIMS( tmp1 )[0];
10797  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10798  }
10799  {
10800  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10801  if ( tmp2 == NULL )
10802  return NULL;
10803  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10804  {
10805  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10806  return NULL;
10807  }
10808  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10809  }
10810  {
10811  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10812  if ( tmp3 == NULL )
10813  return NULL;
10814  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10815  {
10816  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10817  return NULL;
10818  }
10819  arg4 = PyArray_DIMS( tmp3 )[0];
10820  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10821  }
10822  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10823  resultobj = SWIG_Py_Void();
10824  {
10825  Py_CLEAR( tmp1 );
10826  }
10827  {
10828  Py_CLEAR( tmp2 );
10829  }
10830  {
10831  Py_CLEAR( tmp3 );
10832  }
10833  return resultobj;
10834 fail:
10835  {
10836  Py_CLEAR( tmp1 );
10837  }
10838  {
10839  Py_CLEAR( tmp2 );
10840  }
10841  {
10842  Py_CLEAR( tmp3 );
10843  }
10844  return NULL;
10845 }
10846 
10847 
10848 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10849  PyObject *resultobj = 0;
10850  PLINT *arg1 = (PLINT *) 0 ;
10851  PLINT *arg2 = (PLINT *) 0 ;
10852  PLINT *arg3 = (PLINT *) 0 ;
10853  PLFLT *arg4 = (PLFLT *) 0 ;
10854  PLINT arg5 ;
10855  PyArrayObject *tmp1 = NULL ;
10856  PyArrayObject *tmp2 = NULL ;
10857  PyArrayObject *tmp3 = NULL ;
10858  PyArrayObject *tmp4 = NULL ;
10859  PyObject * obj0 = 0 ;
10860  PyObject * obj1 = 0 ;
10861  PyObject * obj2 = 0 ;
10862  PyObject * obj3 = 0 ;
10863 
10864  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10865  {
10866  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10867  if ( tmp1 == NULL )
10868  return NULL;
10869  Alen = PyArray_DIMS( tmp1 )[0];
10870  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10871  }
10872  {
10873  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10874  if ( tmp2 == NULL )
10875  return NULL;
10876  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10877  {
10878  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10879  return NULL;
10880  }
10881  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10882  }
10883  {
10884  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10885  if ( tmp3 == NULL )
10886  return NULL;
10887  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10888  {
10889  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10890  return NULL;
10891  }
10892  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10893  }
10894  {
10895  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10896  if ( tmp4 == NULL )
10897  return NULL;
10898  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10899  {
10900  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10901  return NULL;
10902  }
10903  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10904  arg5 = PyArray_DIMS( tmp4 )[0];
10905  }
10906  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10907  resultobj = SWIG_Py_Void();
10908  {
10909  Py_CLEAR( tmp1 );
10910  }
10911  {
10912  Py_CLEAR( tmp2 );
10913  }
10914  {
10915  Py_CLEAR( tmp3 );
10916  }
10917  {
10918  Py_CLEAR( tmp4 );
10919  }
10920  return resultobj;
10921 fail:
10922  {
10923  Py_CLEAR( tmp1 );
10924  }
10925  {
10926  Py_CLEAR( tmp2 );
10927  }
10928  {
10929  Py_CLEAR( tmp3 );
10930  }
10931  {
10932  Py_CLEAR( tmp4 );
10933  }
10934  return NULL;
10935 }
10936 
10937 
10938 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10939  PyObject *resultobj = 0;
10940  PLBOOL arg1 ;
10941  PLINT arg2 ;
10942  PLFLT *arg3 = (PLFLT *) 0 ;
10943  PLFLT *arg4 = (PLFLT *) 0 ;
10944  PLFLT *arg5 = (PLFLT *) 0 ;
10945  PLFLT *arg6 = (PLFLT *) 0 ;
10946  PLBOOL *arg7 = (PLBOOL *) 0 ;
10947  int val1 ;
10948  int ecode1 = 0 ;
10949  PyArrayObject *tmp2 = NULL ;
10950  PyArrayObject *tmp4 = NULL ;
10951  PyArrayObject *tmp5 = NULL ;
10952  PyArrayObject *tmp6 = NULL ;
10953  PyArrayObject *tmp7 = NULL ;
10954  PyObject * obj0 = 0 ;
10955  PyObject * obj1 = 0 ;
10956  PyObject * obj2 = 0 ;
10957  PyObject * obj3 = 0 ;
10958  PyObject * obj4 = 0 ;
10959  PyObject * obj5 = 0 ;
10960 
10961  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10962  ecode1 = SWIG_AsVal_int(obj0, &val1);
10963  if (!SWIG_IsOK(ecode1)) {
10964  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10965  }
10966  arg1 = (PLBOOL)(val1);
10967  {
10968  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10969  if ( tmp2 == NULL )
10970  return NULL;
10971  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10972  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10973  }
10974  {
10975  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10976  if ( tmp4 == NULL )
10977  return NULL;
10978  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10979  {
10980  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10981  return NULL;
10982  }
10983  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10984  }
10985  {
10986  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10987  if ( tmp5 == NULL )
10988  return NULL;
10989  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10990  {
10991  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10992  return NULL;
10993  }
10994  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10995  }
10996  {
10997  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10998  if ( tmp6 == NULL )
10999  return NULL;
11000  if ( PyArray_DIMS( tmp6 )[0] != Alen )
11001  {
11002  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11003  return NULL;
11004  }
11005  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11006  }
11007  {
11008  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
11009  if ( tmp7 == NULL )
11010  return NULL;
11011  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11012  {
11013  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11014  return NULL;
11015  }
11016  arg7 = (PLINT *) PyArray_DATA( tmp7 );
11017  }
11018  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11019  resultobj = SWIG_Py_Void();
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 resultobj;
11036 fail:
11037  {
11038  Py_CLEAR( tmp2 );
11039  }
11040  {
11041  Py_CLEAR( tmp4 );
11042  }
11043  {
11044  Py_CLEAR( tmp5 );
11045  }
11046  {
11047  Py_CLEAR( tmp6 );
11048  }
11049  {
11050  Py_CLEAR( tmp7 );
11051  }
11052  return NULL;
11053 }
11054 
11055 
11056 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057  PyObject *resultobj = 0;
11058  PLBOOL arg1 ;
11059  PLINT arg2 ;
11060  PLFLT *arg3 = (PLFLT *) 0 ;
11061  PLFLT *arg4 = (PLFLT *) 0 ;
11062  PLFLT *arg5 = (PLFLT *) 0 ;
11063  PLFLT *arg6 = (PLFLT *) 0 ;
11064  PLFLT *arg7 = (PLFLT *) 0 ;
11065  PLBOOL *arg8 = (PLBOOL *) 0 ;
11066  int val1 ;
11067  int ecode1 = 0 ;
11068  PyArrayObject *tmp2 = NULL ;
11069  PyArrayObject *tmp4 = NULL ;
11070  PyArrayObject *tmp5 = NULL ;
11071  PyArrayObject *tmp6 = NULL ;
11072  PyArrayObject *tmp7 = NULL ;
11073  PyArrayObject *tmp8 = NULL ;
11074  PyObject * obj0 = 0 ;
11075  PyObject * obj1 = 0 ;
11076  PyObject * obj2 = 0 ;
11077  PyObject * obj3 = 0 ;
11078  PyObject * obj4 = 0 ;
11079  PyObject * obj5 = 0 ;
11080  PyObject * obj6 = 0 ;
11081 
11082  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
11083  ecode1 = SWIG_AsVal_int(obj0, &val1);
11084  if (!SWIG_IsOK(ecode1)) {
11085  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11086  }
11087  arg1 = (PLBOOL)(val1);
11088  {
11089  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
11090  if ( tmp2 == NULL )
11091  return NULL;
11092  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11093  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11094  }
11095  {
11096  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
11097  if ( tmp4 == NULL )
11098  return NULL;
11099  if ( PyArray_DIMS( tmp4 )[0] != Alen )
11100  {
11101  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11102  return NULL;
11103  }
11104  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11105  }
11106  {
11107  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
11108  if ( tmp5 == NULL )
11109  return NULL;
11110  if ( PyArray_DIMS( tmp5 )[0] != Alen )
11111  {
11112  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11113  return NULL;
11114  }
11115  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11116  }
11117  {
11118  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
11119  if ( tmp6 == NULL )
11120  return NULL;
11121  if ( PyArray_DIMS( tmp6 )[0] != Alen )
11122  {
11123  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11124  return NULL;
11125  }
11126  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11127  }
11128  {
11129  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11130  if ( tmp7 == NULL )
11131  return NULL;
11132  if ( PyArray_DIMS( tmp7 )[0] != Alen )
11133  {
11134  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11135  return NULL;
11136  }
11137  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11138  }
11139  {
11140  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
11141  if ( tmp8 == NULL )
11142  return NULL;
11143  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11144  {
11145  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11146  return NULL;
11147  }
11148  arg8 = (PLINT *) PyArray_DATA( tmp8 );
11149  }
11150  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11151  resultobj = SWIG_Py_Void();
11152  {
11153  Py_CLEAR( tmp2 );
11154  }
11155  {
11156  Py_CLEAR( tmp4 );
11157  }
11158  {
11159  Py_CLEAR( tmp5 );
11160  }
11161  {
11162  Py_CLEAR( tmp6 );
11163  }
11164  {
11165  Py_CLEAR( tmp7 );
11166  }
11167  {
11168  Py_CLEAR( tmp8 );
11169  }
11170  return resultobj;
11171 fail:
11172  {
11173  Py_CLEAR( tmp2 );
11174  }
11175  {
11176  Py_CLEAR( tmp4 );
11177  }
11178  {
11179  Py_CLEAR( tmp5 );
11180  }
11181  {
11182  Py_CLEAR( tmp6 );
11183  }
11184  {
11185  Py_CLEAR( tmp7 );
11186  }
11187  {
11188  Py_CLEAR( tmp8 );
11189  }
11190  return NULL;
11191 }
11192 
11193 
11194 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11195  PyObject *resultobj = 0;
11196  PLINT arg1 ;
11197  int val1 ;
11198  int ecode1 = 0 ;
11199  PyObject * obj0 = 0 ;
11200 
11201  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11202  ecode1 = SWIG_AsVal_int(obj0, &val1);
11203  if (!SWIG_IsOK(ecode1)) {
11204  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11205  }
11206  arg1 = (PLINT)(val1);
11207  plscmap1n(arg1);
11208  resultobj = SWIG_Py_Void();
11209  return resultobj;
11210 fail:
11211  return NULL;
11212 }
11213 
11214 
11215 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11216  PyObject *resultobj = 0;
11217  PLFLT arg1 ;
11218  PLFLT arg2 ;
11219  double val1 ;
11220  int ecode1 = 0 ;
11221  double val2 ;
11222  int ecode2 = 0 ;
11223  PyObject * obj0 = 0 ;
11224  PyObject * obj1 = 0 ;
11225 
11226  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11227  ecode1 = SWIG_AsVal_double(obj0, &val1);
11228  if (!SWIG_IsOK(ecode1)) {
11229  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11230  }
11231  arg1 = (PLFLT)(val1);
11232  ecode2 = SWIG_AsVal_double(obj1, &val2);
11233  if (!SWIG_IsOK(ecode2)) {
11234  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11235  }
11236  arg2 = (PLFLT)(val2);
11237  plscmap1_range(arg1,arg2);
11238  resultobj = SWIG_Py_Void();
11239  return resultobj;
11240 fail:
11241  return NULL;
11242 }
11243 
11244 
11245 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11246  PyObject *resultobj = 0;
11247  PLFLT *arg1 = (PLFLT *) 0 ;
11248  PLFLT *arg2 = (PLFLT *) 0 ;
11249  PLFLT temp1 ;
11250  int res1 = SWIG_TMPOBJ ;
11251  PLFLT temp2 ;
11252  int res2 = SWIG_TMPOBJ ;
11253 
11254  arg1 = &temp1;
11255  arg2 = &temp2;
11256  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11257  plgcmap1_range(arg1,arg2);
11258  resultobj = SWIG_Py_Void();
11259  if (SWIG_IsTmpObj(res1)) {
11260  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11261  } else {
11262  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11264  }
11265  if (SWIG_IsTmpObj(res2)) {
11266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11267  } else {
11268  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11270  }
11271  return resultobj;
11272 fail:
11273  return NULL;
11274 }
11275 
11276 
11277 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11278  PyObject *resultobj = 0;
11279  PLINT arg1 ;
11280  PLINT arg2 ;
11281  PLINT arg3 ;
11282  PLINT arg4 ;
11283  int val1 ;
11284  int ecode1 = 0 ;
11285  int val2 ;
11286  int ecode2 = 0 ;
11287  int val3 ;
11288  int ecode3 = 0 ;
11289  int val4 ;
11290  int ecode4 = 0 ;
11291  PyObject * obj0 = 0 ;
11292  PyObject * obj1 = 0 ;
11293  PyObject * obj2 = 0 ;
11294  PyObject * obj3 = 0 ;
11295 
11296  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11297  ecode1 = SWIG_AsVal_int(obj0, &val1);
11298  if (!SWIG_IsOK(ecode1)) {
11299  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11300  }
11301  arg1 = (PLINT)(val1);
11302  ecode2 = SWIG_AsVal_int(obj1, &val2);
11303  if (!SWIG_IsOK(ecode2)) {
11304  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11305  }
11306  arg2 = (PLINT)(val2);
11307  ecode3 = SWIG_AsVal_int(obj2, &val3);
11308  if (!SWIG_IsOK(ecode3)) {
11309  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11310  }
11311  arg3 = (PLINT)(val3);
11312  ecode4 = SWIG_AsVal_int(obj3, &val4);
11313  if (!SWIG_IsOK(ecode4)) {
11314  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11315  }
11316  arg4 = (PLINT)(val4);
11317  plscol0(arg1,arg2,arg3,arg4);
11318  resultobj = SWIG_Py_Void();
11319  return resultobj;
11320 fail:
11321  return NULL;
11322 }
11323 
11324 
11325 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11326  PyObject *resultobj = 0;
11327  PLINT arg1 ;
11328  PLINT arg2 ;
11329  PLINT arg3 ;
11330  PLINT arg4 ;
11331  PLFLT arg5 ;
11332  int val1 ;
11333  int ecode1 = 0 ;
11334  int val2 ;
11335  int ecode2 = 0 ;
11336  int val3 ;
11337  int ecode3 = 0 ;
11338  int val4 ;
11339  int ecode4 = 0 ;
11340  double val5 ;
11341  int ecode5 = 0 ;
11342  PyObject * obj0 = 0 ;
11343  PyObject * obj1 = 0 ;
11344  PyObject * obj2 = 0 ;
11345  PyObject * obj3 = 0 ;
11346  PyObject * obj4 = 0 ;
11347 
11348  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11349  ecode1 = SWIG_AsVal_int(obj0, &val1);
11350  if (!SWIG_IsOK(ecode1)) {
11351  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11352  }
11353  arg1 = (PLINT)(val1);
11354  ecode2 = SWIG_AsVal_int(obj1, &val2);
11355  if (!SWIG_IsOK(ecode2)) {
11356  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11357  }
11358  arg2 = (PLINT)(val2);
11359  ecode3 = SWIG_AsVal_int(obj2, &val3);
11360  if (!SWIG_IsOK(ecode3)) {
11361  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11362  }
11363  arg3 = (PLINT)(val3);
11364  ecode4 = SWIG_AsVal_int(obj3, &val4);
11365  if (!SWIG_IsOK(ecode4)) {
11366  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11367  }
11368  arg4 = (PLINT)(val4);
11369  ecode5 = SWIG_AsVal_double(obj4, &val5);
11370  if (!SWIG_IsOK(ecode5)) {
11371  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11372  }
11373  arg5 = (PLFLT)(val5);
11374  plscol0a(arg1,arg2,arg3,arg4,arg5);
11375  resultobj = SWIG_Py_Void();
11376  return resultobj;
11377 fail:
11378  return NULL;
11379 }
11380 
11381 
11382 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11383  PyObject *resultobj = 0;
11384  PLINT arg1 ;
11385  PLINT arg2 ;
11386  PLINT arg3 ;
11387  int val1 ;
11388  int ecode1 = 0 ;
11389  int val2 ;
11390  int ecode2 = 0 ;
11391  int val3 ;
11392  int ecode3 = 0 ;
11393  PyObject * obj0 = 0 ;
11394  PyObject * obj1 = 0 ;
11395  PyObject * obj2 = 0 ;
11396 
11397  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11398  ecode1 = SWIG_AsVal_int(obj0, &val1);
11399  if (!SWIG_IsOK(ecode1)) {
11400  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11401  }
11402  arg1 = (PLINT)(val1);
11403  ecode2 = SWIG_AsVal_int(obj1, &val2);
11404  if (!SWIG_IsOK(ecode2)) {
11405  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11406  }
11407  arg2 = (PLINT)(val2);
11408  ecode3 = SWIG_AsVal_int(obj2, &val3);
11409  if (!SWIG_IsOK(ecode3)) {
11410  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11411  }
11412  arg3 = (PLINT)(val3);
11413  plscolbg(arg1,arg2,arg3);
11414  resultobj = SWIG_Py_Void();
11415  return resultobj;
11416 fail:
11417  return NULL;
11418 }
11419 
11420 
11421 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11422  PyObject *resultobj = 0;
11423  PLINT arg1 ;
11424  PLINT arg2 ;
11425  PLINT arg3 ;
11426  PLFLT arg4 ;
11427  int val1 ;
11428  int ecode1 = 0 ;
11429  int val2 ;
11430  int ecode2 = 0 ;
11431  int val3 ;
11432  int ecode3 = 0 ;
11433  double val4 ;
11434  int ecode4 = 0 ;
11435  PyObject * obj0 = 0 ;
11436  PyObject * obj1 = 0 ;
11437  PyObject * obj2 = 0 ;
11438  PyObject * obj3 = 0 ;
11439 
11440  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11441  ecode1 = SWIG_AsVal_int(obj0, &val1);
11442  if (!SWIG_IsOK(ecode1)) {
11443  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11444  }
11445  arg1 = (PLINT)(val1);
11446  ecode2 = SWIG_AsVal_int(obj1, &val2);
11447  if (!SWIG_IsOK(ecode2)) {
11448  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11449  }
11450  arg2 = (PLINT)(val2);
11451  ecode3 = SWIG_AsVal_int(obj2, &val3);
11452  if (!SWIG_IsOK(ecode3)) {
11453  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11454  }
11455  arg3 = (PLINT)(val3);
11456  ecode4 = SWIG_AsVal_double(obj3, &val4);
11457  if (!SWIG_IsOK(ecode4)) {
11458  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11459  }
11460  arg4 = (PLFLT)(val4);
11461  plscolbga(arg1,arg2,arg3,arg4);
11462  resultobj = SWIG_Py_Void();
11463  return resultobj;
11464 fail:
11465  return NULL;
11466 }
11467 
11468 
11469 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470  PyObject *resultobj = 0;
11471  PLINT arg1 ;
11472  int val1 ;
11473  int ecode1 = 0 ;
11474  PyObject * obj0 = 0 ;
11475 
11476  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11477  ecode1 = SWIG_AsVal_int(obj0, &val1);
11478  if (!SWIG_IsOK(ecode1)) {
11479  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11480  }
11481  arg1 = (PLINT)(val1);
11482  plscolor(arg1);
11483  resultobj = SWIG_Py_Void();
11484  return resultobj;
11485 fail:
11486  return NULL;
11487 }
11488 
11489 
11490 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11491  PyObject *resultobj = 0;
11492  PLINT arg1 ;
11493  int val1 ;
11494  int ecode1 = 0 ;
11495  PyObject * obj0 = 0 ;
11496 
11497  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11498  ecode1 = SWIG_AsVal_int(obj0, &val1);
11499  if (!SWIG_IsOK(ecode1)) {
11500  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11501  }
11502  arg1 = (PLINT)(val1);
11503  plscompression(arg1);
11504  resultobj = SWIG_Py_Void();
11505  return resultobj;
11506 fail:
11507  return NULL;
11508 }
11509 
11510 
11511 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11512  PyObject *resultobj = 0;
11513  char *arg1 = (char *) 0 ;
11514  int res1 ;
11515  char *buf1 = 0 ;
11516  int alloc1 = 0 ;
11517  PyObject * obj0 = 0 ;
11518 
11519  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11520  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11521  if (!SWIG_IsOK(res1)) {
11522  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11523  }
11524  arg1 = (char *)(buf1);
11525  plsdev((char const *)arg1);
11526  resultobj = SWIG_Py_Void();
11527  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11528  return resultobj;
11529 fail:
11530  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11531  return NULL;
11532 }
11533 
11534 
11535 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11536  PyObject *resultobj = 0;
11537  PLFLT arg1 ;
11538  PLFLT arg2 ;
11539  PLFLT arg3 ;
11540  PLFLT arg4 ;
11541  double val1 ;
11542  int ecode1 = 0 ;
11543  double val2 ;
11544  int ecode2 = 0 ;
11545  double val3 ;
11546  int ecode3 = 0 ;
11547  double val4 ;
11548  int ecode4 = 0 ;
11549  PyObject * obj0 = 0 ;
11550  PyObject * obj1 = 0 ;
11551  PyObject * obj2 = 0 ;
11552  PyObject * obj3 = 0 ;
11553 
11554  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11555  ecode1 = SWIG_AsVal_double(obj0, &val1);
11556  if (!SWIG_IsOK(ecode1)) {
11557  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11558  }
11559  arg1 = (PLFLT)(val1);
11560  ecode2 = SWIG_AsVal_double(obj1, &val2);
11561  if (!SWIG_IsOK(ecode2)) {
11562  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11563  }
11564  arg2 = (PLFLT)(val2);
11565  ecode3 = SWIG_AsVal_double(obj2, &val3);
11566  if (!SWIG_IsOK(ecode3)) {
11567  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11568  }
11569  arg3 = (PLFLT)(val3);
11570  ecode4 = SWIG_AsVal_double(obj3, &val4);
11571  if (!SWIG_IsOK(ecode4)) {
11572  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11573  }
11574  arg4 = (PLFLT)(val4);
11575  plsdidev(arg1,arg2,arg3,arg4);
11576  resultobj = SWIG_Py_Void();
11577  return resultobj;
11578 fail:
11579  return NULL;
11580 }
11581 
11582 
11583 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11584  PyObject *resultobj = 0;
11585  PLINT arg1 ;
11586  PLINT arg2 ;
11587  PLINT arg3 ;
11588  PLINT arg4 ;
11589  PLFLT arg5 ;
11590  PLFLT arg6 ;
11591  int val1 ;
11592  int ecode1 = 0 ;
11593  int val2 ;
11594  int ecode2 = 0 ;
11595  int val3 ;
11596  int ecode3 = 0 ;
11597  int val4 ;
11598  int ecode4 = 0 ;
11599  double val5 ;
11600  int ecode5 = 0 ;
11601  double val6 ;
11602  int ecode6 = 0 ;
11603  PyObject * obj0 = 0 ;
11604  PyObject * obj1 = 0 ;
11605  PyObject * obj2 = 0 ;
11606  PyObject * obj3 = 0 ;
11607  PyObject * obj4 = 0 ;
11608  PyObject * obj5 = 0 ;
11609 
11610  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11611  ecode1 = SWIG_AsVal_int(obj0, &val1);
11612  if (!SWIG_IsOK(ecode1)) {
11613  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11614  }
11615  arg1 = (PLINT)(val1);
11616  ecode2 = SWIG_AsVal_int(obj1, &val2);
11617  if (!SWIG_IsOK(ecode2)) {
11618  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11619  }
11620  arg2 = (PLINT)(val2);
11621  ecode3 = SWIG_AsVal_int(obj2, &val3);
11622  if (!SWIG_IsOK(ecode3)) {
11623  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11624  }
11625  arg3 = (PLINT)(val3);
11626  ecode4 = SWIG_AsVal_int(obj3, &val4);
11627  if (!SWIG_IsOK(ecode4)) {
11628  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11629  }
11630  arg4 = (PLINT)(val4);
11631  ecode5 = SWIG_AsVal_double(obj4, &val5);
11632  if (!SWIG_IsOK(ecode5)) {
11633  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11634  }
11635  arg5 = (PLFLT)(val5);
11636  ecode6 = SWIG_AsVal_double(obj5, &val6);
11637  if (!SWIG_IsOK(ecode6)) {
11638  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11639  }
11640  arg6 = (PLFLT)(val6);
11641  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11642  resultobj = SWIG_Py_Void();
11643  return resultobj;
11644 fail:
11645  return NULL;
11646 }
11647 
11648 
11649 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11650  PyObject *resultobj = 0;
11651  PLFLT arg1 ;
11652  double val1 ;
11653  int ecode1 = 0 ;
11654  PyObject * obj0 = 0 ;
11655 
11656  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11657  ecode1 = SWIG_AsVal_double(obj0, &val1);
11658  if (!SWIG_IsOK(ecode1)) {
11659  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11660  }
11661  arg1 = (PLFLT)(val1);
11662  plsdiori(arg1);
11663  resultobj = SWIG_Py_Void();
11664  return resultobj;
11665 fail:
11666  return NULL;
11667 }
11668 
11669 
11670 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671  PyObject *resultobj = 0;
11672  PLFLT arg1 ;
11673  PLFLT arg2 ;
11674  PLFLT arg3 ;
11675  PLFLT arg4 ;
11676  double val1 ;
11677  int ecode1 = 0 ;
11678  double val2 ;
11679  int ecode2 = 0 ;
11680  double val3 ;
11681  int ecode3 = 0 ;
11682  double val4 ;
11683  int ecode4 = 0 ;
11684  PyObject * obj0 = 0 ;
11685  PyObject * obj1 = 0 ;
11686  PyObject * obj2 = 0 ;
11687  PyObject * obj3 = 0 ;
11688 
11689  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11690  ecode1 = SWIG_AsVal_double(obj0, &val1);
11691  if (!SWIG_IsOK(ecode1)) {
11692  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11693  }
11694  arg1 = (PLFLT)(val1);
11695  ecode2 = SWIG_AsVal_double(obj1, &val2);
11696  if (!SWIG_IsOK(ecode2)) {
11697  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11698  }
11699  arg2 = (PLFLT)(val2);
11700  ecode3 = SWIG_AsVal_double(obj2, &val3);
11701  if (!SWIG_IsOK(ecode3)) {
11702  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11703  }
11704  arg3 = (PLFLT)(val3);
11705  ecode4 = SWIG_AsVal_double(obj3, &val4);
11706  if (!SWIG_IsOK(ecode4)) {
11707  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11708  }
11709  arg4 = (PLFLT)(val4);
11710  plsdiplt(arg1,arg2,arg3,arg4);
11711  resultobj = SWIG_Py_Void();
11712  return resultobj;
11713 fail:
11714  return NULL;
11715 }
11716 
11717 
11718 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719  PyObject *resultobj = 0;
11720  PLFLT arg1 ;
11721  PLFLT arg2 ;
11722  PLFLT arg3 ;
11723  PLFLT arg4 ;
11724  double val1 ;
11725  int ecode1 = 0 ;
11726  double val2 ;
11727  int ecode2 = 0 ;
11728  double val3 ;
11729  int ecode3 = 0 ;
11730  double val4 ;
11731  int ecode4 = 0 ;
11732  PyObject * obj0 = 0 ;
11733  PyObject * obj1 = 0 ;
11734  PyObject * obj2 = 0 ;
11735  PyObject * obj3 = 0 ;
11736 
11737  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11738  ecode1 = SWIG_AsVal_double(obj0, &val1);
11739  if (!SWIG_IsOK(ecode1)) {
11740  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11741  }
11742  arg1 = (PLFLT)(val1);
11743  ecode2 = SWIG_AsVal_double(obj1, &val2);
11744  if (!SWIG_IsOK(ecode2)) {
11745  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11746  }
11747  arg2 = (PLFLT)(val2);
11748  ecode3 = SWIG_AsVal_double(obj2, &val3);
11749  if (!SWIG_IsOK(ecode3)) {
11750  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11751  }
11752  arg3 = (PLFLT)(val3);
11753  ecode4 = SWIG_AsVal_double(obj3, &val4);
11754  if (!SWIG_IsOK(ecode4)) {
11755  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11756  }
11757  arg4 = (PLFLT)(val4);
11758  plsdiplz(arg1,arg2,arg3,arg4);
11759  resultobj = SWIG_Py_Void();
11760  return resultobj;
11761 fail:
11762  return NULL;
11763 }
11764 
11765 
11766 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767  PyObject *resultobj = 0;
11768  unsigned int arg1 ;
11769  unsigned int val1 ;
11770  int ecode1 = 0 ;
11771  PyObject * obj0 = 0 ;
11772 
11773  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11774  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11775  if (!SWIG_IsOK(ecode1)) {
11776  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11777  }
11778  arg1 = (unsigned int)(val1);
11779  plseed(arg1);
11780  resultobj = SWIG_Py_Void();
11781  return resultobj;
11782 fail:
11783  return NULL;
11784 }
11785 
11786 
11787 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11788  PyObject *resultobj = 0;
11789  char arg1 ;
11790  char val1 ;
11791  int ecode1 = 0 ;
11792  PyObject * obj0 = 0 ;
11793 
11794  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11795  ecode1 = SWIG_AsVal_char(obj0, &val1);
11796  if (!SWIG_IsOK(ecode1)) {
11797  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11798  }
11799  arg1 = (char)(val1);
11800  plsesc(arg1);
11801  resultobj = SWIG_Py_Void();
11802  return resultobj;
11803 fail:
11804  return NULL;
11805 }
11806 
11807 
11808 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809  PyObject *resultobj = 0;
11810  char *arg1 = (char *) 0 ;
11811  char *arg2 = (char *) 0 ;
11812  int res1 ;
11813  char *buf1 = 0 ;
11814  int alloc1 = 0 ;
11815  int res2 ;
11816  char *buf2 = 0 ;
11817  int alloc2 = 0 ;
11818  PyObject * obj0 = 0 ;
11819  PyObject * obj1 = 0 ;
11820  PLINT result;
11821 
11822  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11823  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11824  if (!SWIG_IsOK(res1)) {
11825  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11826  }
11827  arg1 = (char *)(buf1);
11828  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11829  if (!SWIG_IsOK(res2)) {
11830  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11831  }
11832  arg2 = (char *)(buf2);
11833  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11834  resultobj = SWIG_From_int((int)(result));
11835  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11836  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11837  return resultobj;
11838 fail:
11839  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11840  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11841  return NULL;
11842 }
11843 
11844 
11845 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11846  PyObject *resultobj = 0;
11847  PLINT arg1 ;
11848  PLINT arg2 ;
11849  PLINT arg3 ;
11850  int val1 ;
11851  int ecode1 = 0 ;
11852  int val2 ;
11853  int ecode2 = 0 ;
11854  int val3 ;
11855  int ecode3 = 0 ;
11856  PyObject * obj0 = 0 ;
11857  PyObject * obj1 = 0 ;
11858  PyObject * obj2 = 0 ;
11859 
11860  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11861  ecode1 = SWIG_AsVal_int(obj0, &val1);
11862  if (!SWIG_IsOK(ecode1)) {
11863  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11864  }
11865  arg1 = (PLINT)(val1);
11866  ecode2 = SWIG_AsVal_int(obj1, &val2);
11867  if (!SWIG_IsOK(ecode2)) {
11868  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11869  }
11870  arg2 = (PLINT)(val2);
11871  ecode3 = SWIG_AsVal_int(obj2, &val3);
11872  if (!SWIG_IsOK(ecode3)) {
11873  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11874  }
11875  arg3 = (PLINT)(val3);
11876  plsfam(arg1,arg2,arg3);
11877  resultobj = SWIG_Py_Void();
11878  return resultobj;
11879 fail:
11880  return NULL;
11881 }
11882 
11883 
11884 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11885  PyObject *resultobj = 0;
11886  PLUNICODE arg1 ;
11887  unsigned int val1 ;
11888  int ecode1 = 0 ;
11889  PyObject * obj0 = 0 ;
11890 
11891  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11892  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11893  if (!SWIG_IsOK(ecode1)) {
11894  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11895  }
11896  arg1 = (PLUNICODE)(val1);
11897  plsfci(arg1);
11898  resultobj = SWIG_Py_Void();
11899  return resultobj;
11900 fail:
11901  return NULL;
11902 }
11903 
11904 
11905 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11906  PyObject *resultobj = 0;
11907  char *arg1 = (char *) 0 ;
11908  int res1 ;
11909  char *buf1 = 0 ;
11910  int alloc1 = 0 ;
11911  PyObject * obj0 = 0 ;
11912 
11913  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11914  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11915  if (!SWIG_IsOK(res1)) {
11916  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11917  }
11918  arg1 = (char *)(buf1);
11919  plsfnam((char const *)arg1);
11920  resultobj = SWIG_Py_Void();
11921  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11922  return resultobj;
11923 fail:
11924  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11925  return NULL;
11926 }
11927 
11928 
11929 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11930  PyObject *resultobj = 0;
11931  PLINT arg1 ;
11932  PLINT arg2 ;
11933  PLINT arg3 ;
11934  int val1 ;
11935  int ecode1 = 0 ;
11936  int val2 ;
11937  int ecode2 = 0 ;
11938  int val3 ;
11939  int ecode3 = 0 ;
11940  PyObject * obj0 = 0 ;
11941  PyObject * obj1 = 0 ;
11942  PyObject * obj2 = 0 ;
11943 
11944  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11945  ecode1 = SWIG_AsVal_int(obj0, &val1);
11946  if (!SWIG_IsOK(ecode1)) {
11947  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11948  }
11949  arg1 = (PLINT)(val1);
11950  ecode2 = SWIG_AsVal_int(obj1, &val2);
11951  if (!SWIG_IsOK(ecode2)) {
11952  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11953  }
11954  arg2 = (PLINT)(val2);
11955  ecode3 = SWIG_AsVal_int(obj2, &val3);
11956  if (!SWIG_IsOK(ecode3)) {
11957  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11958  }
11959  arg3 = (PLINT)(val3);
11960  plsfont(arg1,arg2,arg3);
11961  resultobj = SWIG_Py_Void();
11962  return resultobj;
11963 fail:
11964  return NULL;
11965 }
11966 
11967 
11968 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969  PyObject *resultobj = 0;
11970  PLFLT **arg1 = (PLFLT **) 0 ;
11971  PLINT arg2 ;
11972  PLINT arg3 ;
11973  defined_func arg4 = (defined_func) 0 ;
11974  PLFLT arg5 ;
11975  PLFLT arg6 ;
11976  PLFLT arg7 ;
11977  PLFLT arg8 ;
11978  PLFLT *arg9 = (PLFLT *) 0 ;
11979  PLINT arg10 ;
11980  PLFLT arg11 ;
11981  PLINT arg12 ;
11982  PLFLT arg13 ;
11983  fill_func arg14 = (fill_func) 0 ;
11984  PLBOOL arg15 ;
11985  pltr_func arg16 = (pltr_func) 0 ;
11986  PLPointer arg17 = (PLPointer) 0 ;
11987  PyArrayObject *tmp1 = NULL ;
11988  double val5 ;
11989  int ecode5 = 0 ;
11990  double val6 ;
11991  int ecode6 = 0 ;
11992  double val7 ;
11993  int ecode7 = 0 ;
11994  double val8 ;
11995  int ecode8 = 0 ;
11996  PyArrayObject *tmp9 = NULL ;
11997  double val11 ;
11998  int ecode11 = 0 ;
11999  int val12 ;
12000  int ecode12 = 0 ;
12001  double val13 ;
12002  int ecode13 = 0 ;
12003  int val15 ;
12004  int ecode15 = 0 ;
12005  PyObject * obj0 = 0 ;
12006  PyObject * obj1 = 0 ;
12007  PyObject * obj2 = 0 ;
12008  PyObject * obj3 = 0 ;
12009  PyObject * obj4 = 0 ;
12010  PyObject * obj5 = 0 ;
12011  PyObject * obj6 = 0 ;
12012  PyObject * obj7 = 0 ;
12013  PyObject * obj8 = 0 ;
12014  PyObject * obj9 = 0 ;
12015  PyObject * obj10 = 0 ;
12016  PyObject * obj11 = 0 ;
12017 
12018  {
12019  python_pltr = 0;
12020  arg16 = NULL;
12021  }
12022  {
12023  arg17 = NULL;
12024  }
12025  {
12026  arg4 = NULL;
12027  }
12028  {
12029  arg14 = plfill;
12030  }
12031  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
12032  {
12033  int i, size;
12034  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12035  if ( tmp1 == NULL )
12036  return NULL;
12037  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12038  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12039  size = arg3;
12040  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12041  for ( i = 0; i < arg2; i++ )
12042  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12043  }
12044  ecode5 = SWIG_AsVal_double(obj1, &val5);
12045  if (!SWIG_IsOK(ecode5)) {
12046  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12047  }
12048  arg5 = (PLFLT)(val5);
12049  ecode6 = SWIG_AsVal_double(obj2, &val6);
12050  if (!SWIG_IsOK(ecode6)) {
12051  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12052  }
12053  arg6 = (PLFLT)(val6);
12054  ecode7 = SWIG_AsVal_double(obj3, &val7);
12055  if (!SWIG_IsOK(ecode7)) {
12056  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12057  }
12058  arg7 = (PLFLT)(val7);
12059  ecode8 = SWIG_AsVal_double(obj4, &val8);
12060  if (!SWIG_IsOK(ecode8)) {
12061  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12062  }
12063  arg8 = (PLFLT)(val8);
12064  {
12065  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
12066  if ( tmp9 == NULL )
12067  return NULL;
12068  arg10 = PyArray_DIMS( tmp9 )[0];
12069  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12070  }
12071  ecode11 = SWIG_AsVal_double(obj6, &val11);
12072  if (!SWIG_IsOK(ecode11)) {
12073  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12074  }
12075  arg11 = (PLFLT)(val11);
12076  ecode12 = SWIG_AsVal_int(obj7, &val12);
12077  if (!SWIG_IsOK(ecode12)) {
12078  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12079  }
12080  arg12 = (PLINT)(val12);
12081  ecode13 = SWIG_AsVal_double(obj8, &val13);
12082  if (!SWIG_IsOK(ecode13)) {
12083  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12084  }
12085  arg13 = (PLFLT)(val13);
12086  ecode15 = SWIG_AsVal_int(obj9, &val15);
12087  if (!SWIG_IsOK(ecode15)) {
12088  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12089  }
12090  arg15 = (PLBOOL)(val15);
12091  if (obj10) {
12092  {
12093  // it must be a callable or None
12094  if ( obj10 == Py_None )
12095  {
12096  arg16 = NULL;
12097  }
12098  else
12099  {
12100  if ( !PyCallable_Check( (PyObject *) obj10 ) )
12101  {
12102  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12103  return NULL;
12104  }
12105  arg16 = marshal_pltr( obj10 );
12106  }
12107  }
12108  }
12109  if (obj11) {
12110  {
12111  if ( obj11 == Py_None )
12112  arg17 = NULL;
12113  else
12114  {
12115  arg17 = marshal_PLPointer( obj11, 0 );
12116  }
12117  }
12118  }
12119  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12120  resultobj = SWIG_Py_Void();
12121  {
12122  Py_CLEAR( tmp1 );
12123  free( arg1 );
12124  }
12125  {
12126  Py_CLEAR( tmp9 );
12127  }
12128  {
12129  cleanup_pltr();
12130  }
12131  {
12133  }
12134  return resultobj;
12135 fail:
12136  {
12137  Py_CLEAR( tmp1 );
12138  free( arg1 );
12139  }
12140  {
12141  Py_CLEAR( tmp9 );
12142  }
12143  {
12144  cleanup_pltr();
12145  }
12146  {
12148  }
12149  return NULL;
12150 }
12151 
12152 
12153 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154  PyObject *resultobj = 0;
12155  PLFLT **arg1 = (PLFLT **) 0 ;
12156  PLINT arg2 ;
12157  PLINT arg3 ;
12158  defined_func arg4 = (defined_func) 0 ;
12159  PLFLT arg5 ;
12160  PLFLT arg6 ;
12161  PLFLT arg7 ;
12162  PLFLT arg8 ;
12163  PLFLT arg9 ;
12164  PLFLT arg10 ;
12165  PLINT arg11 ;
12166  PLFLT arg12 ;
12167  PLFLT arg13 ;
12168  PLINT arg14 ;
12169  PLFLT arg15 ;
12170  PLINT arg16 ;
12171  PLFLT arg17 ;
12172  fill_func arg18 = (fill_func) 0 ;
12173  PLBOOL arg19 ;
12174  pltr_func arg20 = (pltr_func) 0 ;
12175  PLPointer arg21 = (PLPointer) 0 ;
12176  PyArrayObject *tmp1 = NULL ;
12177  double val5 ;
12178  int ecode5 = 0 ;
12179  double val6 ;
12180  int ecode6 = 0 ;
12181  double val7 ;
12182  int ecode7 = 0 ;
12183  double val8 ;
12184  int ecode8 = 0 ;
12185  double val9 ;
12186  int ecode9 = 0 ;
12187  double val10 ;
12188  int ecode10 = 0 ;
12189  int val11 ;
12190  int ecode11 = 0 ;
12191  double val12 ;
12192  int ecode12 = 0 ;
12193  double val13 ;
12194  int ecode13 = 0 ;
12195  int val14 ;
12196  int ecode14 = 0 ;
12197  double val15 ;
12198  int ecode15 = 0 ;
12199  int val16 ;
12200  int ecode16 = 0 ;
12201  double val17 ;
12202  int ecode17 = 0 ;
12203  int val19 ;
12204  int ecode19 = 0 ;
12205  PyObject * obj0 = 0 ;
12206  PyObject * obj1 = 0 ;
12207  PyObject * obj2 = 0 ;
12208  PyObject * obj3 = 0 ;
12209  PyObject * obj4 = 0 ;
12210  PyObject * obj5 = 0 ;
12211  PyObject * obj6 = 0 ;
12212  PyObject * obj7 = 0 ;
12213  PyObject * obj8 = 0 ;
12214  PyObject * obj9 = 0 ;
12215  PyObject * obj10 = 0 ;
12216  PyObject * obj11 = 0 ;
12217  PyObject * obj12 = 0 ;
12218  PyObject * obj13 = 0 ;
12219  PyObject * obj14 = 0 ;
12220  PyObject * obj15 = 0 ;
12221  PyObject * obj16 = 0 ;
12222 
12223  {
12224  python_pltr = 0;
12225  arg20 = NULL;
12226  }
12227  {
12228  arg21 = NULL;
12229  }
12230  {
12231  arg4 = NULL;
12232  }
12233  {
12234  arg18 = plfill;
12235  }
12236  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;
12237  {
12238  int i, size;
12239  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12240  if ( tmp1 == NULL )
12241  return NULL;
12242  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12243  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12244  size = arg3;
12245  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12246  for ( i = 0; i < arg2; i++ )
12247  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12248  }
12249  ecode5 = SWIG_AsVal_double(obj1, &val5);
12250  if (!SWIG_IsOK(ecode5)) {
12251  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12252  }
12253  arg5 = (PLFLT)(val5);
12254  ecode6 = SWIG_AsVal_double(obj2, &val6);
12255  if (!SWIG_IsOK(ecode6)) {
12256  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12257  }
12258  arg6 = (PLFLT)(val6);
12259  ecode7 = SWIG_AsVal_double(obj3, &val7);
12260  if (!SWIG_IsOK(ecode7)) {
12261  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12262  }
12263  arg7 = (PLFLT)(val7);
12264  ecode8 = SWIG_AsVal_double(obj4, &val8);
12265  if (!SWIG_IsOK(ecode8)) {
12266  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12267  }
12268  arg8 = (PLFLT)(val8);
12269  ecode9 = SWIG_AsVal_double(obj5, &val9);
12270  if (!SWIG_IsOK(ecode9)) {
12271  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12272  }
12273  arg9 = (PLFLT)(val9);
12274  ecode10 = SWIG_AsVal_double(obj6, &val10);
12275  if (!SWIG_IsOK(ecode10)) {
12276  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12277  }
12278  arg10 = (PLFLT)(val10);
12279  ecode11 = SWIG_AsVal_int(obj7, &val11);
12280  if (!SWIG_IsOK(ecode11)) {
12281  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12282  }
12283  arg11 = (PLINT)(val11);
12284  ecode12 = SWIG_AsVal_double(obj8, &val12);
12285  if (!SWIG_IsOK(ecode12)) {
12286  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12287  }
12288  arg12 = (PLFLT)(val12);
12289  ecode13 = SWIG_AsVal_double(obj9, &val13);
12290  if (!SWIG_IsOK(ecode13)) {
12291  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12292  }
12293  arg13 = (PLFLT)(val13);
12294  ecode14 = SWIG_AsVal_int(obj10, &val14);
12295  if (!SWIG_IsOK(ecode14)) {
12296  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12297  }
12298  arg14 = (PLINT)(val14);
12299  ecode15 = SWIG_AsVal_double(obj11, &val15);
12300  if (!SWIG_IsOK(ecode15)) {
12301  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12302  }
12303  arg15 = (PLFLT)(val15);
12304  ecode16 = SWIG_AsVal_int(obj12, &val16);
12305  if (!SWIG_IsOK(ecode16)) {
12306  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12307  }
12308  arg16 = (PLINT)(val16);
12309  ecode17 = SWIG_AsVal_double(obj13, &val17);
12310  if (!SWIG_IsOK(ecode17)) {
12311  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12312  }
12313  arg17 = (PLFLT)(val17);
12314  ecode19 = SWIG_AsVal_int(obj14, &val19);
12315  if (!SWIG_IsOK(ecode19)) {
12316  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12317  }
12318  arg19 = (PLBOOL)(val19);
12319  if (obj15) {
12320  {
12321  // it must be a callable or None
12322  if ( obj15 == Py_None )
12323  {
12324  arg20 = NULL;
12325  }
12326  else
12327  {
12328  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12329  {
12330  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12331  return NULL;
12332  }
12333  arg20 = marshal_pltr( obj15 );
12334  }
12335  }
12336  }
12337  if (obj16) {
12338  {
12339  if ( obj16 == Py_None )
12340  arg21 = NULL;
12341  else
12342  {
12343  arg21 = marshal_PLPointer( obj16, 0 );
12344  }
12345  }
12346  }
12347  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12348  resultobj = SWIG_Py_Void();
12349  {
12350  Py_CLEAR( tmp1 );
12351  free( arg1 );
12352  }
12353  {
12354  cleanup_pltr();
12355  }
12356  {
12358  }
12359  return resultobj;
12360 fail:
12361  {
12362  Py_CLEAR( tmp1 );
12363  free( arg1 );
12364  }
12365  {
12366  cleanup_pltr();
12367  }
12368  {
12370  }
12371  return NULL;
12372 }
12373 
12374 
12375 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12376  PyObject *resultobj = 0;
12377  label_func arg1 = (label_func) 0 ;
12378  PLPointer arg2 = (PLPointer) 0 ;
12379  int res2 ;
12380  PyObject * obj0 = 0 ;
12381  PyObject * obj1 = 0 ;
12382 
12383  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12384  {
12385  // Release reference to previous function if applicable
12386  if ( python_label )
12387  {
12388  Py_CLEAR( python_label );
12389  python_label = 0;
12390  }
12391  // it must be a callable or None
12392  if ( obj0 == Py_None )
12393  {
12394  arg1 = NULL;
12395  }
12396  else
12397  {
12398  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12399  {
12400  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12401  return NULL;
12402  }
12403  // hold a reference to it
12404  Py_XINCREF( (PyObject *) obj0 );
12405  python_label = (PyObject *) obj0;
12406  // this function handles calling the python function
12407  arg1 = do_label_callback;
12408  }
12409  }
12410  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12411  if (!SWIG_IsOK(res2)) {
12412  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12413  }
12414  plslabelfunc(arg1,arg2);
12415  resultobj = SWIG_Py_Void();
12416  return resultobj;
12417 fail:
12418  return NULL;
12419 }
12420 
12421 
12422 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12423  PyObject *resultobj = 0;
12424  PLFLT arg1 ;
12425  PLFLT arg2 ;
12426  double val1 ;
12427  int ecode1 = 0 ;
12428  double val2 ;
12429  int ecode2 = 0 ;
12430  PyObject * obj0 = 0 ;
12431  PyObject * obj1 = 0 ;
12432 
12433  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12434  ecode1 = SWIG_AsVal_double(obj0, &val1);
12435  if (!SWIG_IsOK(ecode1)) {
12436  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12437  }
12438  arg1 = (PLFLT)(val1);
12439  ecode2 = SWIG_AsVal_double(obj1, &val2);
12440  if (!SWIG_IsOK(ecode2)) {
12441  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12442  }
12443  arg2 = (PLFLT)(val2);
12444  plsmaj(arg1,arg2);
12445  resultobj = SWIG_Py_Void();
12446  return resultobj;
12447 fail:
12448  return NULL;
12449 }
12450 
12451 
12452 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12453  PyObject *resultobj = 0;
12454  PLINT arg1 ;
12455  PLINT arg2 ;
12456  void *arg3 = (void *) 0 ;
12457  int val1 ;
12458  int ecode1 = 0 ;
12459  int val2 ;
12460  int ecode2 = 0 ;
12461  int res3 ;
12462  Py_ssize_t size3 = 0 ;
12463  void *buf3 = 0 ;
12464  PyObject * obj0 = 0 ;
12465  PyObject * obj1 = 0 ;
12466  PyObject * obj2 = 0 ;
12467 
12468  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12469  ecode1 = SWIG_AsVal_int(obj0, &val1);
12470  if (!SWIG_IsOK(ecode1)) {
12471  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12472  }
12473  arg1 = (PLINT)(val1);
12474  ecode2 = SWIG_AsVal_int(obj1, &val2);
12475  if (!SWIG_IsOK(ecode2)) {
12476  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12477  }
12478  arg2 = (PLINT)(val2);
12479  {
12480  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12481  if (res3<0) {
12482  PyErr_Clear();
12483  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12484  }
12485  arg3 = (void *) buf3;
12486  }
12487  plsmem(arg1,arg2,arg3);
12488  resultobj = SWIG_Py_Void();
12489  return resultobj;
12490 fail:
12491  return NULL;
12492 }
12493 
12494 
12495 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496  PyObject *resultobj = 0;
12497  PLINT arg1 ;
12498  PLINT arg2 ;
12499  void *arg3 = (void *) 0 ;
12500  int val1 ;
12501  int ecode1 = 0 ;
12502  int val2 ;
12503  int ecode2 = 0 ;
12504  int res3 ;
12505  Py_ssize_t size3 = 0 ;
12506  void *buf3 = 0 ;
12507  PyObject * obj0 = 0 ;
12508  PyObject * obj1 = 0 ;
12509  PyObject * obj2 = 0 ;
12510 
12511  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12512  ecode1 = SWIG_AsVal_int(obj0, &val1);
12513  if (!SWIG_IsOK(ecode1)) {
12514  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12515  }
12516  arg1 = (PLINT)(val1);
12517  ecode2 = SWIG_AsVal_int(obj1, &val2);
12518  if (!SWIG_IsOK(ecode2)) {
12519  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12520  }
12521  arg2 = (PLINT)(val2);
12522  {
12523  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12524  if (res3<0) {
12525  PyErr_Clear();
12526  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12527  }
12528  arg3 = (void *) buf3;
12529  }
12530  plsmema(arg1,arg2,arg3);
12531  resultobj = SWIG_Py_Void();
12532  return resultobj;
12533 fail:
12534  return NULL;
12535 }
12536 
12537 
12538 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12539  PyObject *resultobj = 0;
12540  PLFLT arg1 ;
12541  PLFLT arg2 ;
12542  double val1 ;
12543  int ecode1 = 0 ;
12544  double val2 ;
12545  int ecode2 = 0 ;
12546  PyObject * obj0 = 0 ;
12547  PyObject * obj1 = 0 ;
12548 
12549  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12550  ecode1 = SWIG_AsVal_double(obj0, &val1);
12551  if (!SWIG_IsOK(ecode1)) {
12552  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12553  }
12554  arg1 = (PLFLT)(val1);
12555  ecode2 = SWIG_AsVal_double(obj1, &val2);
12556  if (!SWIG_IsOK(ecode2)) {
12557  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12558  }
12559  arg2 = (PLFLT)(val2);
12560  plsmin(arg1,arg2);
12561  resultobj = SWIG_Py_Void();
12562  return resultobj;
12563 fail:
12564  return NULL;
12565 }
12566 
12567 
12568 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12569  PyObject *resultobj = 0;
12570  PLINT arg1 ;
12571  int val1 ;
12572  int ecode1 = 0 ;
12573  PyObject * obj0 = 0 ;
12574 
12575  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12576  ecode1 = SWIG_AsVal_int(obj0, &val1);
12577  if (!SWIG_IsOK(ecode1)) {
12578  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12579  }
12580  arg1 = (PLINT)(val1);
12581  plsori(arg1);
12582  resultobj = SWIG_Py_Void();
12583  return resultobj;
12584 fail:
12585  return NULL;
12586 }
12587 
12588 
12589 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12590  PyObject *resultobj = 0;
12591  PLFLT arg1 ;
12592  PLFLT arg2 ;
12593  PLINT arg3 ;
12594  PLINT arg4 ;
12595  PLINT arg5 ;
12596  PLINT arg6 ;
12597  double val1 ;
12598  int ecode1 = 0 ;
12599  double val2 ;
12600  int ecode2 = 0 ;
12601  int val3 ;
12602  int ecode3 = 0 ;
12603  int val4 ;
12604  int ecode4 = 0 ;
12605  int val5 ;
12606  int ecode5 = 0 ;
12607  int val6 ;
12608  int ecode6 = 0 ;
12609  PyObject * obj0 = 0 ;
12610  PyObject * obj1 = 0 ;
12611  PyObject * obj2 = 0 ;
12612  PyObject * obj3 = 0 ;
12613  PyObject * obj4 = 0 ;
12614  PyObject * obj5 = 0 ;
12615 
12616  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12617  ecode1 = SWIG_AsVal_double(obj0, &val1);
12618  if (!SWIG_IsOK(ecode1)) {
12619  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12620  }
12621  arg1 = (PLFLT)(val1);
12622  ecode2 = SWIG_AsVal_double(obj1, &val2);
12623  if (!SWIG_IsOK(ecode2)) {
12624  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12625  }
12626  arg2 = (PLFLT)(val2);
12627  ecode3 = SWIG_AsVal_int(obj2, &val3);
12628  if (!SWIG_IsOK(ecode3)) {
12629  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12630  }
12631  arg3 = (PLINT)(val3);
12632  ecode4 = SWIG_AsVal_int(obj3, &val4);
12633  if (!SWIG_IsOK(ecode4)) {
12634  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12635  }
12636  arg4 = (PLINT)(val4);
12637  ecode5 = SWIG_AsVal_int(obj4, &val5);
12638  if (!SWIG_IsOK(ecode5)) {
12639  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12640  }
12641  arg5 = (PLINT)(val5);
12642  ecode6 = SWIG_AsVal_int(obj5, &val6);
12643  if (!SWIG_IsOK(ecode6)) {
12644  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12645  }
12646  arg6 = (PLINT)(val6);
12647  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12648  resultobj = SWIG_Py_Void();
12649  return resultobj;
12650 fail:
12651  return NULL;
12652 }
12653 
12654 
12655 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656  PyObject *resultobj = 0;
12657  char *arg1 = (char *) 0 ;
12658  int res1 ;
12659  char *buf1 = 0 ;
12660  int alloc1 = 0 ;
12661  PyObject * obj0 = 0 ;
12662 
12663  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12664  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12665  if (!SWIG_IsOK(res1)) {
12666  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12667  }
12668  arg1 = (char *)(buf1);
12669  plspal0((char const *)arg1);
12670  resultobj = SWIG_Py_Void();
12671  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12672  return resultobj;
12673 fail:
12674  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12675  return NULL;
12676 }
12677 
12678 
12679 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680  PyObject *resultobj = 0;
12681  char *arg1 = (char *) 0 ;
12682  PLBOOL arg2 ;
12683  int res1 ;
12684  char *buf1 = 0 ;
12685  int alloc1 = 0 ;
12686  int val2 ;
12687  int ecode2 = 0 ;
12688  PyObject * obj0 = 0 ;
12689  PyObject * obj1 = 0 ;
12690 
12691  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12692  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12693  if (!SWIG_IsOK(res1)) {
12694  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12695  }
12696  arg1 = (char *)(buf1);
12697  ecode2 = SWIG_AsVal_int(obj1, &val2);
12698  if (!SWIG_IsOK(ecode2)) {
12699  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12700  }
12701  arg2 = (PLBOOL)(val2);
12702  plspal1((char const *)arg1,arg2);
12703  resultobj = SWIG_Py_Void();
12704  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12705  return resultobj;
12706 fail:
12707  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12708  return NULL;
12709 }
12710 
12711 
12712 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12713  PyObject *resultobj = 0;
12714  PLBOOL arg1 ;
12715  int val1 ;
12716  int ecode1 = 0 ;
12717  PyObject * obj0 = 0 ;
12718 
12719  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12720  ecode1 = SWIG_AsVal_int(obj0, &val1);
12721  if (!SWIG_IsOK(ecode1)) {
12722  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12723  }
12724  arg1 = (PLBOOL)(val1);
12725  plspause(arg1);
12726  resultobj = SWIG_Py_Void();
12727  return resultobj;
12728 fail:
12729  return NULL;
12730 }
12731 
12732 
12733 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734  PyObject *resultobj = 0;
12735  PLINT arg1 ;
12736  int val1 ;
12737  int ecode1 = 0 ;
12738  PyObject * obj0 = 0 ;
12739 
12740  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12741  ecode1 = SWIG_AsVal_int(obj0, &val1);
12742  if (!SWIG_IsOK(ecode1)) {
12743  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12744  }
12745  arg1 = (PLINT)(val1);
12746  plsstrm(arg1);
12747  resultobj = SWIG_Py_Void();
12748  return resultobj;
12749 fail:
12750  return NULL;
12751 }
12752 
12753 
12754 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12755  PyObject *resultobj = 0;
12756  PLINT arg1 ;
12757  PLINT arg2 ;
12758  int val1 ;
12759  int ecode1 = 0 ;
12760  int val2 ;
12761  int ecode2 = 0 ;
12762  PyObject * obj0 = 0 ;
12763  PyObject * obj1 = 0 ;
12764 
12765  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12766  ecode1 = SWIG_AsVal_int(obj0, &val1);
12767  if (!SWIG_IsOK(ecode1)) {
12768  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12769  }
12770  arg1 = (PLINT)(val1);
12771  ecode2 = SWIG_AsVal_int(obj1, &val2);
12772  if (!SWIG_IsOK(ecode2)) {
12773  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12774  }
12775  arg2 = (PLINT)(val2);
12776  plssub(arg1,arg2);
12777  resultobj = SWIG_Py_Void();
12778  return resultobj;
12779 fail:
12780  return NULL;
12781 }
12782 
12783 
12784 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12785  PyObject *resultobj = 0;
12786  PLFLT arg1 ;
12787  PLFLT arg2 ;
12788  double val1 ;
12789  int ecode1 = 0 ;
12790  double val2 ;
12791  int ecode2 = 0 ;
12792  PyObject * obj0 = 0 ;
12793  PyObject * obj1 = 0 ;
12794 
12795  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12796  ecode1 = SWIG_AsVal_double(obj0, &val1);
12797  if (!SWIG_IsOK(ecode1)) {
12798  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12799  }
12800  arg1 = (PLFLT)(val1);
12801  ecode2 = SWIG_AsVal_double(obj1, &val2);
12802  if (!SWIG_IsOK(ecode2)) {
12803  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12804  }
12805  arg2 = (PLFLT)(val2);
12806  plssym(arg1,arg2);
12807  resultobj = SWIG_Py_Void();
12808  return resultobj;
12809 fail:
12810  return NULL;
12811 }
12812 
12813 
12814 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12815  PyObject *resultobj = 0;
12816  PLINT arg1 ;
12817  PLINT arg2 ;
12818  int val1 ;
12819  int ecode1 = 0 ;
12820  int val2 ;
12821  int ecode2 = 0 ;
12822  PyObject * obj0 = 0 ;
12823  PyObject * obj1 = 0 ;
12824 
12825  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12826  ecode1 = SWIG_AsVal_int(obj0, &val1);
12827  if (!SWIG_IsOK(ecode1)) {
12828  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12829  }
12830  arg1 = (PLINT)(val1);
12831  ecode2 = SWIG_AsVal_int(obj1, &val2);
12832  if (!SWIG_IsOK(ecode2)) {
12833  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12834  }
12835  arg2 = (PLINT)(val2);
12836  plstar(arg1,arg2);
12837  resultobj = SWIG_Py_Void();
12838  return resultobj;
12839 fail:
12840  return NULL;
12841 }
12842 
12843 
12844 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845  PyObject *resultobj = 0;
12846  char *arg1 = (char *) 0 ;
12847  PLINT arg2 ;
12848  PLINT arg3 ;
12849  int res1 ;
12850  char *buf1 = 0 ;
12851  int alloc1 = 0 ;
12852  int val2 ;
12853  int ecode2 = 0 ;
12854  int val3 ;
12855  int ecode3 = 0 ;
12856  PyObject * obj0 = 0 ;
12857  PyObject * obj1 = 0 ;
12858  PyObject * obj2 = 0 ;
12859 
12860  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12861  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12862  if (!SWIG_IsOK(res1)) {
12863  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12864  }
12865  arg1 = (char *)(buf1);
12866  ecode2 = SWIG_AsVal_int(obj1, &val2);
12867  if (!SWIG_IsOK(ecode2)) {
12868  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12869  }
12870  arg2 = (PLINT)(val2);
12871  ecode3 = SWIG_AsVal_int(obj2, &val3);
12872  if (!SWIG_IsOK(ecode3)) {
12873  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12874  }
12875  arg3 = (PLINT)(val3);
12876  plstart((char const *)arg1,arg2,arg3);
12877  resultobj = SWIG_Py_Void();
12878  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12879  return resultobj;
12880 fail:
12881  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12882  return NULL;
12883 }
12884 
12885 
12886 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12887  PyObject *resultobj = 0;
12888  ct_func arg1 = (ct_func) 0 ;
12889  PLPointer arg2 = (PLPointer) 0 ;
12890  int res2 ;
12891  PyObject * obj0 = 0 ;
12892  PyObject * obj1 = 0 ;
12893 
12894  {
12895  python_ct = 0;
12896  arg1 = NULL;
12897  }
12898  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12899  if (obj0) {
12900  {
12901  if ( python_ct )
12902  cleanup_ct();
12903  // it must be a callable or none
12904  if ( obj0 == Py_None )
12905  {
12906  arg1 = NULL;
12907  }
12908  else
12909  {
12910  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12911  {
12912  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12913  return NULL;
12914  }
12915  arg1 = marshal_ct( obj0 );
12916  }
12917  }
12918  }
12919  if (obj1) {
12920  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12921  if (!SWIG_IsOK(res2)) {
12922  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12923  }
12924  }
12925  plstransform(arg1,arg2);
12926  resultobj = SWIG_Py_Void();
12927  return resultobj;
12928 fail:
12929  return NULL;
12930 }
12931 
12932 
12933 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934  PyObject *resultobj = 0;
12935  PLINT arg1 ;
12936  PLFLT *arg2 = (PLFLT *) 0 ;
12937  PLFLT *arg3 = (PLFLT *) 0 ;
12938  char *arg4 = (char *) 0 ;
12939  PyArrayObject *tmp1 = NULL ;
12940  PyArrayObject *tmp3 = NULL ;
12941  int res4 ;
12942  char *buf4 = 0 ;
12943  int alloc4 = 0 ;
12944  PyObject * obj0 = 0 ;
12945  PyObject * obj1 = 0 ;
12946  PyObject * obj2 = 0 ;
12947 
12948  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12949  {
12950  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12951  if ( tmp1 == NULL )
12952  return NULL;
12953  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12954  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12955  }
12956  {
12957  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12958  if ( tmp3 == NULL )
12959  return NULL;
12960  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12961  {
12962  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12963  return NULL;
12964  }
12965  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12966  }
12967  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12968  if (!SWIG_IsOK(res4)) {
12969  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12970  }
12971  arg4 = (char *)(buf4);
12972  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12973  resultobj = SWIG_Py_Void();
12974  {
12975  Py_CLEAR( tmp1 );
12976  }
12977  {
12978  Py_CLEAR( tmp3 );
12979  }
12980  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12981  return resultobj;
12982 fail:
12983  {
12984  Py_CLEAR( tmp1 );
12985  }
12986  {
12987  Py_CLEAR( tmp3 );
12988  }
12989  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12990  return NULL;
12991 }
12992 
12993 
12994 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12995  PyObject *resultobj = 0;
12996  PLINT arg1 ;
12997  PLFLT *arg2 = (PLFLT *) 0 ;
12998  PLFLT *arg3 = (PLFLT *) 0 ;
12999  PLFLT *arg4 = (PLFLT *) 0 ;
13000  char *arg5 = (char *) 0 ;
13001  PyArrayObject *tmp1 = NULL ;
13002  PyArrayObject *tmp3 = NULL ;
13003  PyArrayObject *tmp4 = NULL ;
13004  int res5 ;
13005  char *buf5 = 0 ;
13006  int alloc5 = 0 ;
13007  PyObject * obj0 = 0 ;
13008  PyObject * obj1 = 0 ;
13009  PyObject * obj2 = 0 ;
13010  PyObject * obj3 = 0 ;
13011 
13012  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13013  {
13014  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13015  if ( tmp1 == NULL )
13016  return NULL;
13017  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13018  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13019  }
13020  {
13021  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13022  if ( tmp3 == NULL )
13023  return NULL;
13024  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13025  {
13026  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13027  return NULL;
13028  }
13029  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13030  }
13031  {
13032  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
13033  if ( tmp4 == NULL )
13034  return NULL;
13035  if ( PyArray_DIMS( tmp4 )[0] != Alen )
13036  {
13037  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13038  return NULL;
13039  }
13040  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13041  }
13042  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
13043  if (!SWIG_IsOK(res5)) {
13044  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13045  }
13046  arg5 = (char *)(buf5);
13047  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13048  resultobj = SWIG_Py_Void();
13049  {
13050  Py_CLEAR( tmp1 );
13051  }
13052  {
13053  Py_CLEAR( tmp3 );
13054  }
13055  {
13056  Py_CLEAR( tmp4 );
13057  }
13058  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13059  return resultobj;
13060 fail:
13061  {
13062  Py_CLEAR( tmp1 );
13063  }
13064  {
13065  Py_CLEAR( tmp3 );
13066  }
13067  {
13068  Py_CLEAR( tmp4 );
13069  }
13070  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13071  return NULL;
13072 }
13073 
13074 
13075 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076  PyObject *resultobj = 0;
13077  PLINT arg1 ;
13078  PLINT arg2 ;
13079  PLFLT arg3 ;
13080  PLFLT arg4 ;
13081  int val1 ;
13082  int ecode1 = 0 ;
13083  int val2 ;
13084  int ecode2 = 0 ;
13085  double val3 ;
13086  int ecode3 = 0 ;
13087  double val4 ;
13088  int ecode4 = 0 ;
13089  PyObject * obj0 = 0 ;
13090  PyObject * obj1 = 0 ;
13091  PyObject * obj2 = 0 ;
13092  PyObject * obj3 = 0 ;
13093 
13094  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13095  ecode1 = SWIG_AsVal_int(obj0, &val1);
13096  if (!SWIG_IsOK(ecode1)) {
13097  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13098  }
13099  arg1 = (PLINT)(val1);
13100  ecode2 = SWIG_AsVal_int(obj1, &val2);
13101  if (!SWIG_IsOK(ecode2)) {
13102  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13103  }
13104  arg2 = (PLINT)(val2);
13105  ecode3 = SWIG_AsVal_double(obj2, &val3);
13106  if (!SWIG_IsOK(ecode3)) {
13107  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13108  }
13109  arg3 = (PLFLT)(val3);
13110  ecode4 = SWIG_AsVal_double(obj3, &val4);
13111  if (!SWIG_IsOK(ecode4)) {
13112  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13113  }
13114  arg4 = (PLFLT)(val4);
13115  plstripa(arg1,arg2,arg3,arg4);
13116  resultobj = SWIG_Py_Void();
13117  return resultobj;
13118 fail:
13119  return NULL;
13120 }
13121 
13122 
13123 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13124  PyObject *resultobj = 0;
13125  PLINT *arg1 = (PLINT *) 0 ;
13126  char *arg2 = (char *) 0 ;
13127  char *arg3 = (char *) 0 ;
13128  PLFLT arg4 ;
13129  PLFLT arg5 ;
13130  PLFLT arg6 ;
13131  PLFLT arg7 ;
13132  PLFLT arg8 ;
13133  PLFLT arg9 ;
13134  PLFLT arg10 ;
13135  PLBOOL arg11 ;
13136  PLBOOL arg12 ;
13137  PLINT arg13 ;
13138  PLINT arg14 ;
13139  PLINT *arg15 = (PLINT *) 0 ;
13140  PLINT *arg16 = (PLINT *) 0 ;
13141  char **arg17 ;
13142  char *arg18 = (char *) 0 ;
13143  char *arg19 = (char *) 0 ;
13144  char *arg20 = (char *) 0 ;
13145  PLINT temp1 ;
13146  int res1 = SWIG_TMPOBJ ;
13147  int res2 ;
13148  char *buf2 = 0 ;
13149  int alloc2 = 0 ;
13150  int res3 ;
13151  char *buf3 = 0 ;
13152  int alloc3 = 0 ;
13153  double val4 ;
13154  int ecode4 = 0 ;
13155  double val5 ;
13156  int ecode5 = 0 ;
13157  double val6 ;
13158  int ecode6 = 0 ;
13159  double val7 ;
13160  int ecode7 = 0 ;
13161  double val8 ;
13162  int ecode8 = 0 ;
13163  double val9 ;
13164  int ecode9 = 0 ;
13165  double val10 ;
13166  int ecode10 = 0 ;
13167  int val11 ;
13168  int ecode11 = 0 ;
13169  int val12 ;
13170  int ecode12 = 0 ;
13171  int val13 ;
13172  int ecode13 = 0 ;
13173  int val14 ;
13174  int ecode14 = 0 ;
13175  PyArrayObject *tmp15 = NULL ;
13176  PyArrayObject *tmp16 = NULL ;
13177  char **tmp17 = NULL ;
13178  int res18 ;
13179  char *buf18 = 0 ;
13180  int alloc18 = 0 ;
13181  int res19 ;
13182  char *buf19 = 0 ;
13183  int alloc19 = 0 ;
13184  int res20 ;
13185  char *buf20 = 0 ;
13186  int alloc20 = 0 ;
13187  PyObject * obj0 = 0 ;
13188  PyObject * obj1 = 0 ;
13189  PyObject * obj2 = 0 ;
13190  PyObject * obj3 = 0 ;
13191  PyObject * obj4 = 0 ;
13192  PyObject * obj5 = 0 ;
13193  PyObject * obj6 = 0 ;
13194  PyObject * obj7 = 0 ;
13195  PyObject * obj8 = 0 ;
13196  PyObject * obj9 = 0 ;
13197  PyObject * obj10 = 0 ;
13198  PyObject * obj11 = 0 ;
13199  PyObject * obj12 = 0 ;
13200  PyObject * obj13 = 0 ;
13201  PyObject * obj14 = 0 ;
13202  PyObject * obj15 = 0 ;
13203  PyObject * obj16 = 0 ;
13204  PyObject * obj17 = 0 ;
13205  PyObject * obj18 = 0 ;
13206 
13207  arg1 = &temp1;
13208  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;
13209  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13210  if (!SWIG_IsOK(res2)) {
13211  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13212  }
13213  arg2 = (char *)(buf2);
13214  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13215  if (!SWIG_IsOK(res3)) {
13216  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13217  }
13218  arg3 = (char *)(buf3);
13219  ecode4 = SWIG_AsVal_double(obj2, &val4);
13220  if (!SWIG_IsOK(ecode4)) {
13221  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13222  }
13223  arg4 = (PLFLT)(val4);
13224  ecode5 = SWIG_AsVal_double(obj3, &val5);
13225  if (!SWIG_IsOK(ecode5)) {
13226  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13227  }
13228  arg5 = (PLFLT)(val5);
13229  ecode6 = SWIG_AsVal_double(obj4, &val6);
13230  if (!SWIG_IsOK(ecode6)) {
13231  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13232  }
13233  arg6 = (PLFLT)(val6);
13234  ecode7 = SWIG_AsVal_double(obj5, &val7);
13235  if (!SWIG_IsOK(ecode7)) {
13236  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13237  }
13238  arg7 = (PLFLT)(val7);
13239  ecode8 = SWIG_AsVal_double(obj6, &val8);
13240  if (!SWIG_IsOK(ecode8)) {
13241  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13242  }
13243  arg8 = (PLFLT)(val8);
13244  ecode9 = SWIG_AsVal_double(obj7, &val9);
13245  if (!SWIG_IsOK(ecode9)) {
13246  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13247  }
13248  arg9 = (PLFLT)(val9);
13249  ecode10 = SWIG_AsVal_double(obj8, &val10);
13250  if (!SWIG_IsOK(ecode10)) {
13251  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13252  }
13253  arg10 = (PLFLT)(val10);
13254  ecode11 = SWIG_AsVal_int(obj9, &val11);
13255  if (!SWIG_IsOK(ecode11)) {
13256  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13257  }
13258  arg11 = (PLBOOL)(val11);
13259  ecode12 = SWIG_AsVal_int(obj10, &val12);
13260  if (!SWIG_IsOK(ecode12)) {
13261  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13262  }
13263  arg12 = (PLBOOL)(val12);
13264  ecode13 = SWIG_AsVal_int(obj11, &val13);
13265  if (!SWIG_IsOK(ecode13)) {
13266  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13267  }
13268  arg13 = (PLINT)(val13);
13269  ecode14 = SWIG_AsVal_int(obj12, &val14);
13270  if (!SWIG_IsOK(ecode14)) {
13271  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13272  }
13273  arg14 = (PLINT)(val14);
13274  {
13275  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13276  if ( tmp15 == NULL )
13277  return NULL;
13278  Alen = PyArray_DIMS( tmp15 )[0];
13279  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13280  }
13281  {
13282  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13283  if ( tmp16 == NULL )
13284  return NULL;
13285  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13286  {
13287  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13288  return NULL;
13289  }
13290  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13291  }
13292  {
13293  int i;
13294  PyObject *elt, *unicode_string;
13295 
13296  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13297  {
13298  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13299  return NULL;
13300  }
13301  if ( Alen != 4 )
13302  {
13303  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13304  return NULL;
13305  }
13306  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13307  if ( tmp17 == NULL )
13308  return NULL;
13309  arg17 = tmp17;
13310  for ( i = 0; i < 4; i++ )
13311  {
13312  arg17[i] = NULL;
13313  elt = PySequence_Fast_GET_ITEM( obj15, i );
13314  if ( PyString_Check( elt ) )
13315  {
13316  arg17[i] = PyString_AsString( elt );
13317  }
13318  else if ( PyUnicode_Check( elt ) )
13319  {
13320  unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13321  arg17[i] = PyBytes_AS_STRING( unicode_string );
13322  }
13323  if ( arg17[i] == NULL )
13324  {
13325  free( tmp17 );
13326  return NULL;
13327  }
13328  }
13329  }
13330  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13331  if (!SWIG_IsOK(res18)) {
13332  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13333  }
13334  arg18 = (char *)(buf18);
13335  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13336  if (!SWIG_IsOK(res19)) {
13337  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13338  }
13339  arg19 = (char *)(buf19);
13340  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13341  if (!SWIG_IsOK(res20)) {
13342  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13343  }
13344  arg20 = (char *)(buf20);
13345  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);
13346  resultobj = SWIG_Py_Void();
13347  if (SWIG_IsTmpObj(res1)) {
13348  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13349  } else {
13350  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13351  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13352  }
13353  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13354  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13355  {
13356  Py_CLEAR( tmp15 );
13357  }
13358  {
13359  Py_CLEAR( tmp16 );
13360  }
13361  {
13362  free( tmp17 );
13363  }
13364  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13365  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13366  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13367  return resultobj;
13368 fail:
13369  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13370  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13371  {
13372  Py_CLEAR( tmp15 );
13373  }
13374  {
13375  Py_CLEAR( tmp16 );
13376  }
13377  {
13378  free( tmp17 );
13379  }
13380  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13381  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13382  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13383  return NULL;
13384 }
13385 
13386 
13387 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388  PyObject *resultobj = 0;
13389  PLINT arg1 ;
13390  int val1 ;
13391  int ecode1 = 0 ;
13392  PyObject * obj0 = 0 ;
13393 
13394  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13395  ecode1 = SWIG_AsVal_int(obj0, &val1);
13396  if (!SWIG_IsOK(ecode1)) {
13397  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13398  }
13399  arg1 = (PLINT)(val1);
13400  plstripd(arg1);
13401  resultobj = SWIG_Py_Void();
13402  return resultobj;
13403 fail:
13404  return NULL;
13405 }
13406 
13407 
13408 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409  PyObject *resultobj = 0;
13410  PLINT arg1 ;
13411  PLINT *arg2 = (PLINT *) 0 ;
13412  PLINT *arg3 = (PLINT *) 0 ;
13413  PyArrayObject *tmp1 = NULL ;
13414  PyArrayObject *tmp3 = NULL ;
13415  PyObject * obj0 = 0 ;
13416  PyObject * obj1 = 0 ;
13417 
13418  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13419  {
13420  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13421  if ( tmp1 == NULL )
13422  return NULL;
13423  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13424  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13425  }
13426  {
13427  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13428  if ( tmp3 == NULL )
13429  return NULL;
13430  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13431  {
13432  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13433  return NULL;
13434  }
13435  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13436  }
13437  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13438  resultobj = SWIG_Py_Void();
13439  {
13440  Py_CLEAR( tmp1 );
13441  }
13442  {
13443  Py_CLEAR( tmp3 );
13444  }
13445  return resultobj;
13446 fail:
13447  {
13448  Py_CLEAR( tmp1 );
13449  }
13450  {
13451  Py_CLEAR( tmp3 );
13452  }
13453  return NULL;
13454 }
13455 
13456 
13457 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458  PyObject *resultobj = 0;
13459  PLFLT *arg1 = (PLFLT *) 0 ;
13460  PLFLT *arg2 = (PLFLT *) 0 ;
13461  PLINT arg3 ;
13462  PLBOOL arg4 ;
13463  PyArrayObject *tmp1 = NULL ;
13464  PyArrayObject *tmp2 = NULL ;
13465  int val4 ;
13466  int ecode4 = 0 ;
13467  PyObject * obj0 = 0 ;
13468  PyObject * obj1 = 0 ;
13469  PyObject * obj2 = 0 ;
13470 
13471  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13472  {
13473  if ( obj0 != Py_None )
13474  {
13475  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13476  if ( tmp1 == NULL )
13477  return NULL;
13478  Alen = PyArray_DIMS( tmp1 )[0];
13479  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13480  }
13481  else
13482  {
13483  arg1 = NULL;
13484  Alen = 0;
13485  }
13486  }
13487  {
13488  if ( obj1 != Py_None )
13489  {
13490  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13491  if ( tmp2 == NULL )
13492  return NULL;
13493  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13494  {
13495  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13496  return NULL;
13497  }
13498  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13499  arg3 = PyArray_DIMS( tmp2 )[0];
13500  }
13501  else
13502  {
13503  arg2 = NULL;
13504  arg3 = 0;
13505  }
13506  }
13507  ecode4 = SWIG_AsVal_int(obj2, &val4);
13508  if (!SWIG_IsOK(ecode4)) {
13509  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13510  }
13511  arg4 = (PLBOOL)(val4);
13512  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13513  resultobj = SWIG_Py_Void();
13514  {
13515  Py_CLEAR( tmp1 );
13516  }
13517  {
13518  Py_CLEAR( tmp2 );
13519  }
13520  return resultobj;
13521 fail:
13522  {
13523  Py_CLEAR( tmp1 );
13524  }
13525  {
13526  Py_CLEAR( tmp2 );
13527  }
13528  return NULL;
13529 }
13530 
13531 
13532 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13533  PyObject *resultobj = 0;
13534  PLFLT arg1 ;
13535  PLFLT arg2 ;
13536  PLFLT arg3 ;
13537  PLFLT arg4 ;
13538  double val1 ;
13539  int ecode1 = 0 ;
13540  double val2 ;
13541  int ecode2 = 0 ;
13542  double val3 ;
13543  int ecode3 = 0 ;
13544  double val4 ;
13545  int ecode4 = 0 ;
13546  PyObject * obj0 = 0 ;
13547  PyObject * obj1 = 0 ;
13548  PyObject * obj2 = 0 ;
13549  PyObject * obj3 = 0 ;
13550 
13551  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13552  ecode1 = SWIG_AsVal_double(obj0, &val1);
13553  if (!SWIG_IsOK(ecode1)) {
13554  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13555  }
13556  arg1 = (PLFLT)(val1);
13557  ecode2 = SWIG_AsVal_double(obj1, &val2);
13558  if (!SWIG_IsOK(ecode2)) {
13559  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13560  }
13561  arg2 = (PLFLT)(val2);
13562  ecode3 = SWIG_AsVal_double(obj2, &val3);
13563  if (!SWIG_IsOK(ecode3)) {
13564  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13565  }
13566  arg3 = (PLFLT)(val3);
13567  ecode4 = SWIG_AsVal_double(obj3, &val4);
13568  if (!SWIG_IsOK(ecode4)) {
13569  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13570  }
13571  arg4 = (PLFLT)(val4);
13572  plsvpa(arg1,arg2,arg3,arg4);
13573  resultobj = SWIG_Py_Void();
13574  return resultobj;
13575 fail:
13576  return NULL;
13577 }
13578 
13579 
13580 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13581  PyObject *resultobj = 0;
13582  PLINT arg1 ;
13583  PLINT arg2 ;
13584  int val1 ;
13585  int ecode1 = 0 ;
13586  int val2 ;
13587  int ecode2 = 0 ;
13588  PyObject * obj0 = 0 ;
13589  PyObject * obj1 = 0 ;
13590 
13591  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13592  ecode1 = SWIG_AsVal_int(obj0, &val1);
13593  if (!SWIG_IsOK(ecode1)) {
13594  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13595  }
13596  arg1 = (PLINT)(val1);
13597  ecode2 = SWIG_AsVal_int(obj1, &val2);
13598  if (!SWIG_IsOK(ecode2)) {
13599  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13600  }
13601  arg2 = (PLINT)(val2);
13602  plsxax(arg1,arg2);
13603  resultobj = SWIG_Py_Void();
13604  return resultobj;
13605 fail:
13606  return NULL;
13607 }
13608 
13609 
13610 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13611  PyObject *resultobj = 0;
13612  PLINT arg1 ;
13613  PLINT arg2 ;
13614  int val1 ;
13615  int ecode1 = 0 ;
13616  int val2 ;
13617  int ecode2 = 0 ;
13618  PyObject * obj0 = 0 ;
13619  PyObject * obj1 = 0 ;
13620 
13621  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13622  ecode1 = SWIG_AsVal_int(obj0, &val1);
13623  if (!SWIG_IsOK(ecode1)) {
13624  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13625  }
13626  arg1 = (PLINT)(val1);
13627  ecode2 = SWIG_AsVal_int(obj1, &val2);
13628  if (!SWIG_IsOK(ecode2)) {
13629  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13630  }
13631  arg2 = (PLINT)(val2);
13632  plsyax(arg1,arg2);
13633  resultobj = SWIG_Py_Void();
13634  return resultobj;
13635 fail:
13636  return NULL;
13637 }
13638 
13639 
13640 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13641  PyObject *resultobj = 0;
13642  PLINT arg1 ;
13643  PLFLT *arg2 = (PLFLT *) 0 ;
13644  PLFLT *arg3 = (PLFLT *) 0 ;
13645  PLINT arg4 ;
13646  PyArrayObject *tmp1 = NULL ;
13647  PyArrayObject *tmp3 = NULL ;
13648  int val4 ;
13649  int ecode4 = 0 ;
13650  PyObject * obj0 = 0 ;
13651  PyObject * obj1 = 0 ;
13652  PyObject * obj2 = 0 ;
13653 
13654  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13655  {
13656  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13657  if ( tmp1 == NULL )
13658  return NULL;
13659  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13660  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13661  }
13662  {
13663  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13664  if ( tmp3 == NULL )
13665  return NULL;
13666  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13667  {
13668  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13669  return NULL;
13670  }
13671  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13672  }
13673  ecode4 = SWIG_AsVal_int(obj2, &val4);
13674  if (!SWIG_IsOK(ecode4)) {
13675  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13676  }
13677  arg4 = (PLINT)(val4);
13678  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13679  resultobj = SWIG_Py_Void();
13680  {
13681  Py_CLEAR( tmp1 );
13682  }
13683  {
13684  Py_CLEAR( tmp3 );
13685  }
13686  return resultobj;
13687 fail:
13688  {
13689  Py_CLEAR( tmp1 );
13690  }
13691  {
13692  Py_CLEAR( tmp3 );
13693  }
13694  return NULL;
13695 }
13696 
13697 
13698 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13699  PyObject *resultobj = 0;
13700  PLINT arg1 ;
13701  PLINT arg2 ;
13702  int val1 ;
13703  int ecode1 = 0 ;
13704  int val2 ;
13705  int ecode2 = 0 ;
13706  PyObject * obj0 = 0 ;
13707  PyObject * obj1 = 0 ;
13708 
13709  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13710  ecode1 = SWIG_AsVal_int(obj0, &val1);
13711  if (!SWIG_IsOK(ecode1)) {
13712  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13713  }
13714  arg1 = (PLINT)(val1);
13715  ecode2 = SWIG_AsVal_int(obj1, &val2);
13716  if (!SWIG_IsOK(ecode2)) {
13717  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13718  }
13719  arg2 = (PLINT)(val2);
13720  plszax(arg1,arg2);
13721  resultobj = SWIG_Py_Void();
13722  return resultobj;
13723 fail:
13724  return NULL;
13725 }
13726 
13727 
13728 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13729  PyObject *resultobj = 0;
13730 
13731  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13732  pltext();
13733  resultobj = SWIG_Py_Void();
13734  return resultobj;
13735 fail:
13736  return NULL;
13737 }
13738 
13739 
13740 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13741  PyObject *resultobj = 0;
13742  char *arg1 = (char *) 0 ;
13743  int res1 ;
13744  char *buf1 = 0 ;
13745  int alloc1 = 0 ;
13746  PyObject * obj0 = 0 ;
13747 
13748  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13749  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13750  if (!SWIG_IsOK(res1)) {
13751  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13752  }
13753  arg1 = (char *)(buf1);
13754  pltimefmt((char const *)arg1);
13755  resultobj = SWIG_Py_Void();
13756  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13757  return resultobj;
13758 fail:
13759  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13760  return NULL;
13761 }
13762 
13763 
13764 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13765  PyObject *resultobj = 0;
13766  PLFLT arg1 ;
13767  double val1 ;
13768  int ecode1 = 0 ;
13769  PyObject * obj0 = 0 ;
13770 
13771  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13772  ecode1 = SWIG_AsVal_double(obj0, &val1);
13773  if (!SWIG_IsOK(ecode1)) {
13774  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13775  }
13776  arg1 = (PLFLT)(val1);
13777  plvasp(arg1);
13778  resultobj = SWIG_Py_Void();
13779  return resultobj;
13780 fail:
13781  return NULL;
13782 }
13783 
13784 
13785 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13786  PyObject *resultobj = 0;
13787  PLFLT **arg1 = (PLFLT **) 0 ;
13788  PLFLT **arg2 = (PLFLT **) 0 ;
13789  PLINT arg3 ;
13790  PLINT arg4 ;
13791  PLFLT arg5 ;
13792  pltr_func arg6 = (pltr_func) 0 ;
13793  PLPointer arg7 = (PLPointer) 0 ;
13794  PyArrayObject *tmp1 = NULL ;
13795  PyArrayObject *tmp2 = NULL ;
13796  double val5 ;
13797  int ecode5 = 0 ;
13798  PyObject * obj0 = 0 ;
13799  PyObject * obj1 = 0 ;
13800  PyObject * obj2 = 0 ;
13801  PyObject * obj3 = 0 ;
13802  PyObject * obj4 = 0 ;
13803 
13804  {
13805  python_pltr = 0;
13806  arg6 = NULL;
13807  }
13808  {
13809  arg7 = NULL;
13810  }
13811  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13812  {
13813  int i, size;
13814  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13815  if ( tmp1 == NULL )
13816  return NULL;
13817  Xlen = PyArray_DIMS( tmp1 )[0];
13818  Ylen = PyArray_DIMS( tmp1 )[1];
13819  size = Ylen;
13820  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13821  for ( i = 0; i < Xlen; i++ )
13822  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13823  }
13824  {
13825  int i, size;
13826  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13827  if ( tmp2 == NULL )
13828  return NULL;
13829  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13830  {
13831  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13832  return NULL;
13833  }
13834  arg3 = PyArray_DIMS( tmp2 )[0];
13835  arg4 = PyArray_DIMS( tmp2 )[1];
13836  size = arg4;
13837  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13838  for ( i = 0; i < arg3; i++ )
13839  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13840  }
13841  ecode5 = SWIG_AsVal_double(obj2, &val5);
13842  if (!SWIG_IsOK(ecode5)) {
13843  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13844  }
13845  arg5 = (PLFLT)(val5);
13846  if (obj3) {
13847  {
13848  // it must be a callable or None
13849  if ( obj3 == Py_None )
13850  {
13851  arg6 = NULL;
13852  }
13853  else
13854  {
13855  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13856  {
13857  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13858  return NULL;
13859  }
13860  arg6 = marshal_pltr( obj3 );
13861  }
13862  }
13863  }
13864  if (obj4) {
13865  {
13866  if ( obj4 == Py_None )
13867  arg7 = NULL;
13868  else
13869  {
13870  arg7 = marshal_PLPointer( obj4, 0 );
13871  }
13872  }
13873  }
13874  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13875  resultobj = SWIG_Py_Void();
13876  {
13877  Py_CLEAR( tmp1 );
13878  free( arg1 );
13879  }
13880  {
13881  Py_CLEAR( tmp2 );
13882  free( arg2 );
13883  }
13884  {
13885  cleanup_pltr();
13886  }
13887  {
13889  }
13890  return resultobj;
13891 fail:
13892  {
13893  Py_CLEAR( tmp1 );
13894  free( arg1 );
13895  }
13896  {
13897  Py_CLEAR( tmp2 );
13898  free( arg2 );
13899  }
13900  {
13901  cleanup_pltr();
13902  }
13903  {
13905  }
13906  return NULL;
13907 }
13908 
13909 
13910 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13911  PyObject *resultobj = 0;
13912  PLFLT arg1 ;
13913  PLFLT arg2 ;
13914  PLFLT arg3 ;
13915  PLFLT arg4 ;
13916  PLFLT arg5 ;
13917  double val1 ;
13918  int ecode1 = 0 ;
13919  double val2 ;
13920  int ecode2 = 0 ;
13921  double val3 ;
13922  int ecode3 = 0 ;
13923  double val4 ;
13924  int ecode4 = 0 ;
13925  double val5 ;
13926  int ecode5 = 0 ;
13927  PyObject * obj0 = 0 ;
13928  PyObject * obj1 = 0 ;
13929  PyObject * obj2 = 0 ;
13930  PyObject * obj3 = 0 ;
13931  PyObject * obj4 = 0 ;
13932 
13933  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13934  ecode1 = SWIG_AsVal_double(obj0, &val1);
13935  if (!SWIG_IsOK(ecode1)) {
13936  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13937  }
13938  arg1 = (PLFLT)(val1);
13939  ecode2 = SWIG_AsVal_double(obj1, &val2);
13940  if (!SWIG_IsOK(ecode2)) {
13941  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13942  }
13943  arg2 = (PLFLT)(val2);
13944  ecode3 = SWIG_AsVal_double(obj2, &val3);
13945  if (!SWIG_IsOK(ecode3)) {
13946  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13947  }
13948  arg3 = (PLFLT)(val3);
13949  ecode4 = SWIG_AsVal_double(obj3, &val4);
13950  if (!SWIG_IsOK(ecode4)) {
13951  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13952  }
13953  arg4 = (PLFLT)(val4);
13954  ecode5 = SWIG_AsVal_double(obj4, &val5);
13955  if (!SWIG_IsOK(ecode5)) {
13956  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13957  }
13958  arg5 = (PLFLT)(val5);
13959  plvpas(arg1,arg2,arg3,arg4,arg5);
13960  resultobj = SWIG_Py_Void();
13961  return resultobj;
13962 fail:
13963  return NULL;
13964 }
13965 
13966 
13967 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13968  PyObject *resultobj = 0;
13969  PLFLT arg1 ;
13970  PLFLT arg2 ;
13971  PLFLT arg3 ;
13972  PLFLT arg4 ;
13973  double val1 ;
13974  int ecode1 = 0 ;
13975  double val2 ;
13976  int ecode2 = 0 ;
13977  double val3 ;
13978  int ecode3 = 0 ;
13979  double val4 ;
13980  int ecode4 = 0 ;
13981  PyObject * obj0 = 0 ;
13982  PyObject * obj1 = 0 ;
13983  PyObject * obj2 = 0 ;
13984  PyObject * obj3 = 0 ;
13985 
13986  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13987  ecode1 = SWIG_AsVal_double(obj0, &val1);
13988  if (!SWIG_IsOK(ecode1)) {
13989  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13990  }
13991  arg1 = (PLFLT)(val1);
13992  ecode2 = SWIG_AsVal_double(obj1, &val2);
13993  if (!SWIG_IsOK(ecode2)) {
13994  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13995  }
13996  arg2 = (PLFLT)(val2);
13997  ecode3 = SWIG_AsVal_double(obj2, &val3);
13998  if (!SWIG_IsOK(ecode3)) {
13999  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14000  }
14001  arg3 = (PLFLT)(val3);
14002  ecode4 = SWIG_AsVal_double(obj3, &val4);
14003  if (!SWIG_IsOK(ecode4)) {
14004  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14005  }
14006  arg4 = (PLFLT)(val4);
14007  plvpor(arg1,arg2,arg3,arg4);
14008  resultobj = SWIG_Py_Void();
14009  return resultobj;
14010 fail:
14011  return NULL;
14012 }
14013 
14014 
14015 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14016  PyObject *resultobj = 0;
14017 
14018  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
14019  plvsta();
14020  resultobj = SWIG_Py_Void();
14021  return resultobj;
14022 fail:
14023  return NULL;
14024 }
14025 
14026 
14027 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14028  PyObject *resultobj = 0;
14029  PLFLT arg1 ;
14030  PLFLT arg2 ;
14031  PLFLT arg3 ;
14032  PLFLT arg4 ;
14033  PLFLT arg5 ;
14034  PLFLT arg6 ;
14035  PLFLT arg7 ;
14036  PLFLT arg8 ;
14037  PLFLT arg9 ;
14038  PLFLT arg10 ;
14039  PLFLT arg11 ;
14040  double val1 ;
14041  int ecode1 = 0 ;
14042  double val2 ;
14043  int ecode2 = 0 ;
14044  double val3 ;
14045  int ecode3 = 0 ;
14046  double val4 ;
14047  int ecode4 = 0 ;
14048  double val5 ;
14049  int ecode5 = 0 ;
14050  double val6 ;
14051  int ecode6 = 0 ;
14052  double val7 ;
14053  int ecode7 = 0 ;
14054  double val8 ;
14055  int ecode8 = 0 ;
14056  double val9 ;
14057  int ecode9 = 0 ;
14058  double val10 ;
14059  int ecode10 = 0 ;
14060  double val11 ;
14061  int ecode11 = 0 ;
14062  PyObject * obj0 = 0 ;
14063  PyObject * obj1 = 0 ;
14064  PyObject * obj2 = 0 ;
14065  PyObject * obj3 = 0 ;
14066  PyObject * obj4 = 0 ;
14067  PyObject * obj5 = 0 ;
14068  PyObject * obj6 = 0 ;
14069  PyObject * obj7 = 0 ;
14070  PyObject * obj8 = 0 ;
14071  PyObject * obj9 = 0 ;
14072  PyObject * obj10 = 0 ;
14073 
14074  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14075  ecode1 = SWIG_AsVal_double(obj0, &val1);
14076  if (!SWIG_IsOK(ecode1)) {
14077  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14078  }
14079  arg1 = (PLFLT)(val1);
14080  ecode2 = SWIG_AsVal_double(obj1, &val2);
14081  if (!SWIG_IsOK(ecode2)) {
14082  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14083  }
14084  arg2 = (PLFLT)(val2);
14085  ecode3 = SWIG_AsVal_double(obj2, &val3);
14086  if (!SWIG_IsOK(ecode3)) {
14087  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14088  }
14089  arg3 = (PLFLT)(val3);
14090  ecode4 = SWIG_AsVal_double(obj3, &val4);
14091  if (!SWIG_IsOK(ecode4)) {
14092  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14093  }
14094  arg4 = (PLFLT)(val4);
14095  ecode5 = SWIG_AsVal_double(obj4, &val5);
14096  if (!SWIG_IsOK(ecode5)) {
14097  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14098  }
14099  arg5 = (PLFLT)(val5);
14100  ecode6 = SWIG_AsVal_double(obj5, &val6);
14101  if (!SWIG_IsOK(ecode6)) {
14102  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14103  }
14104  arg6 = (PLFLT)(val6);
14105  ecode7 = SWIG_AsVal_double(obj6, &val7);
14106  if (!SWIG_IsOK(ecode7)) {
14107  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14108  }
14109  arg7 = (PLFLT)(val7);
14110  ecode8 = SWIG_AsVal_double(obj7, &val8);
14111  if (!SWIG_IsOK(ecode8)) {
14112  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14113  }
14114  arg8 = (PLFLT)(val8);
14115  ecode9 = SWIG_AsVal_double(obj8, &val9);
14116  if (!SWIG_IsOK(ecode9)) {
14117  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14118  }
14119  arg9 = (PLFLT)(val9);
14120  ecode10 = SWIG_AsVal_double(obj9, &val10);
14121  if (!SWIG_IsOK(ecode10)) {
14122  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14123  }
14124  arg10 = (PLFLT)(val10);
14125  ecode11 = SWIG_AsVal_double(obj10, &val11);
14126  if (!SWIG_IsOK(ecode11)) {
14127  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14128  }
14129  arg11 = (PLFLT)(val11);
14130  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14131  resultobj = SWIG_Py_Void();
14132  return resultobj;
14133 fail:
14134  return NULL;
14135 }
14136 
14137 
14138 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14139  PyObject *resultobj = 0;
14140  PLFLT arg1 ;
14141  double val1 ;
14142  int ecode1 = 0 ;
14143  PyObject * obj0 = 0 ;
14144 
14145  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
14146  ecode1 = SWIG_AsVal_double(obj0, &val1);
14147  if (!SWIG_IsOK(ecode1)) {
14148  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14149  }
14150  arg1 = (PLFLT)(val1);
14151  plwidth(arg1);
14152  resultobj = SWIG_Py_Void();
14153  return resultobj;
14154 fail:
14155  return NULL;
14156 }
14157 
14158 
14159 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160  PyObject *resultobj = 0;
14161  PLFLT arg1 ;
14162  PLFLT arg2 ;
14163  PLFLT arg3 ;
14164  PLFLT arg4 ;
14165  double val1 ;
14166  int ecode1 = 0 ;
14167  double val2 ;
14168  int ecode2 = 0 ;
14169  double val3 ;
14170  int ecode3 = 0 ;
14171  double val4 ;
14172  int ecode4 = 0 ;
14173  PyObject * obj0 = 0 ;
14174  PyObject * obj1 = 0 ;
14175  PyObject * obj2 = 0 ;
14176  PyObject * obj3 = 0 ;
14177 
14178  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14179  ecode1 = SWIG_AsVal_double(obj0, &val1);
14180  if (!SWIG_IsOK(ecode1)) {
14181  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14182  }
14183  arg1 = (PLFLT)(val1);
14184  ecode2 = SWIG_AsVal_double(obj1, &val2);
14185  if (!SWIG_IsOK(ecode2)) {
14186  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14187  }
14188  arg2 = (PLFLT)(val2);
14189  ecode3 = SWIG_AsVal_double(obj2, &val3);
14190  if (!SWIG_IsOK(ecode3)) {
14191  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14192  }
14193  arg3 = (PLFLT)(val3);
14194  ecode4 = SWIG_AsVal_double(obj3, &val4);
14195  if (!SWIG_IsOK(ecode4)) {
14196  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14197  }
14198  arg4 = (PLFLT)(val4);
14199  plwind(arg1,arg2,arg3,arg4);
14200  resultobj = SWIG_Py_Void();
14201  return resultobj;
14202 fail:
14203  return NULL;
14204 }
14205 
14206 
14207 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14208  PyObject *resultobj = 0;
14209  PLBOOL arg1 ;
14210  PLBOOL *arg2 = (PLBOOL *) 0 ;
14211  int val1 ;
14212  int ecode1 = 0 ;
14213  PLBOOL temp2 ;
14214  int res2 = SWIG_TMPOBJ ;
14215  PyObject * obj0 = 0 ;
14216 
14217  arg2 = &temp2;
14218  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14219  ecode1 = SWIG_AsVal_int(obj0, &val1);
14220  if (!SWIG_IsOK(ecode1)) {
14221  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14222  }
14223  arg1 = (PLBOOL)(val1);
14224  plxormod(arg1,arg2);
14225  resultobj = SWIG_Py_Void();
14226  if (SWIG_IsTmpObj(res2)) {
14227  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14228  } else {
14229  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14230  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14231  }
14232  return resultobj;
14233 fail:
14234  return NULL;
14235 }
14236 
14237 
14238 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239  PyObject *resultobj = 0;
14240  mapform_func arg1 = (mapform_func) 0 ;
14241  char *arg2 = (char *) 0 ;
14242  PLFLT arg3 ;
14243  PLFLT arg4 ;
14244  PLFLT arg5 ;
14245  PLFLT arg6 ;
14246  int res2 ;
14247  char *buf2 = 0 ;
14248  int alloc2 = 0 ;
14249  double val3 ;
14250  int ecode3 = 0 ;
14251  double val4 ;
14252  int ecode4 = 0 ;
14253  double val5 ;
14254  int ecode5 = 0 ;
14255  double val6 ;
14256  int ecode6 = 0 ;
14257  PyObject * obj0 = 0 ;
14258  PyObject * obj1 = 0 ;
14259  PyObject * obj2 = 0 ;
14260  PyObject * obj3 = 0 ;
14261  PyObject * obj4 = 0 ;
14262  PyObject * obj5 = 0 ;
14263 
14264  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14265  {
14266  // it must be a callable or none
14267  if ( obj0 == Py_None )
14268  {
14269  arg1 = NULL;
14270  }
14271  else
14272  {
14273  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14274  {
14275  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14276  return NULL;
14277  }
14278  arg1 = marshal_mapform( obj0 );
14279  }
14280  }
14281  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14282  if (!SWIG_IsOK(res2)) {
14283  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14284  }
14285  arg2 = (char *)(buf2);
14286  ecode3 = SWIG_AsVal_double(obj2, &val3);
14287  if (!SWIG_IsOK(ecode3)) {
14288  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14289  }
14290  arg3 = (PLFLT)(val3);
14291  ecode4 = SWIG_AsVal_double(obj3, &val4);
14292  if (!SWIG_IsOK(ecode4)) {
14293  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14294  }
14295  arg4 = (PLFLT)(val4);
14296  ecode5 = SWIG_AsVal_double(obj4, &val5);
14297  if (!SWIG_IsOK(ecode5)) {
14298  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14299  }
14300  arg5 = (PLFLT)(val5);
14301  ecode6 = SWIG_AsVal_double(obj5, &val6);
14302  if (!SWIG_IsOK(ecode6)) {
14303  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14304  }
14305  arg6 = (PLFLT)(val6);
14306  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14307  resultobj = SWIG_Py_Void();
14308  {
14309  cleanup_mapform();
14310  }
14311  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14312  return resultobj;
14313 fail:
14314  {
14315  cleanup_mapform();
14316  }
14317  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14318  return NULL;
14319 }
14320 
14321 
14322 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14323  PyObject *resultobj = 0;
14324  mapform_func arg1 = (mapform_func) 0 ;
14325  char *arg2 = (char *) 0 ;
14326  PLFLT arg3 ;
14327  PLFLT arg4 ;
14328  PLFLT arg5 ;
14329  PLFLT arg6 ;
14330  PLINT *arg7 = (PLINT *) 0 ;
14331  PLINT arg8 ;
14332  int res2 ;
14333  char *buf2 = 0 ;
14334  int alloc2 = 0 ;
14335  double val3 ;
14336  int ecode3 = 0 ;
14337  double val4 ;
14338  int ecode4 = 0 ;
14339  double val5 ;
14340  int ecode5 = 0 ;
14341  double val6 ;
14342  int ecode6 = 0 ;
14343  PyArrayObject *tmp7 = NULL ;
14344  PyObject * obj0 = 0 ;
14345  PyObject * obj1 = 0 ;
14346  PyObject * obj2 = 0 ;
14347  PyObject * obj3 = 0 ;
14348  PyObject * obj4 = 0 ;
14349  PyObject * obj5 = 0 ;
14350  PyObject * obj6 = 0 ;
14351 
14352  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14353  {
14354  // it must be a callable or none
14355  if ( obj0 == Py_None )
14356  {
14357  arg1 = NULL;
14358  }
14359  else
14360  {
14361  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14362  {
14363  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14364  return NULL;
14365  }
14366  arg1 = marshal_mapform( obj0 );
14367  }
14368  }
14369  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14370  if (!SWIG_IsOK(res2)) {
14371  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14372  }
14373  arg2 = (char *)(buf2);
14374  ecode3 = SWIG_AsVal_double(obj2, &val3);
14375  if (!SWIG_IsOK(ecode3)) {
14376  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14377  }
14378  arg3 = (PLFLT)(val3);
14379  ecode4 = SWIG_AsVal_double(obj3, &val4);
14380  if (!SWIG_IsOK(ecode4)) {
14381  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14382  }
14383  arg4 = (PLFLT)(val4);
14384  ecode5 = SWIG_AsVal_double(obj4, &val5);
14385  if (!SWIG_IsOK(ecode5)) {
14386  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14387  }
14388  arg5 = (PLFLT)(val5);
14389  ecode6 = SWIG_AsVal_double(obj5, &val6);
14390  if (!SWIG_IsOK(ecode6)) {
14391  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14392  }
14393  arg6 = (PLFLT)(val6);
14394  {
14395  if ( obj6 != Py_None )
14396  {
14397  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14398  if ( tmp7 == NULL )
14399  return NULL;
14400  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14401  arg8 = PyArray_DIMS( tmp7 )[0];
14402  }
14403  else
14404  {
14405  arg7 = NULL;
14406  arg8 = 0;
14407  }
14408  }
14409  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14410  resultobj = SWIG_Py_Void();
14411  {
14412  cleanup_mapform();
14413  }
14414  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14415  {
14416  Py_CLEAR( tmp7 );
14417  }
14418  return resultobj;
14419 fail:
14420  {
14421  cleanup_mapform();
14422  }
14423  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14424  {
14425  Py_CLEAR( tmp7 );
14426  }
14427  return NULL;
14428 }
14429 
14430 
14431 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14432  PyObject *resultobj = 0;
14433  mapform_func arg1 = (mapform_func) 0 ;
14434  char *arg2 = (char *) 0 ;
14435  char *arg3 = (char *) 0 ;
14436  PLFLT arg4 ;
14437  PLFLT arg5 ;
14438  PLFLT arg6 ;
14439  PLFLT arg7 ;
14440  PLINT *arg8 = (PLINT *) 0 ;
14441  PLINT arg9 ;
14442  int res2 ;
14443  char *buf2 = 0 ;
14444  int alloc2 = 0 ;
14445  int res3 ;
14446  char *buf3 = 0 ;
14447  int alloc3 = 0 ;
14448  double val4 ;
14449  int ecode4 = 0 ;
14450  double val5 ;
14451  int ecode5 = 0 ;
14452  double val6 ;
14453  int ecode6 = 0 ;
14454  double val7 ;
14455  int ecode7 = 0 ;
14456  PyArrayObject *tmp8 = NULL ;
14457  PyObject * obj0 = 0 ;
14458  PyObject * obj1 = 0 ;
14459  PyObject * obj2 = 0 ;
14460  PyObject * obj3 = 0 ;
14461  PyObject * obj4 = 0 ;
14462  PyObject * obj5 = 0 ;
14463  PyObject * obj6 = 0 ;
14464  PyObject * obj7 = 0 ;
14465 
14466  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
14467  {
14468  // it must be a callable or none
14469  if ( obj0 == Py_None )
14470  {
14471  arg1 = NULL;
14472  }
14473  else
14474  {
14475  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14476  {
14477  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14478  return NULL;
14479  }
14480  arg1 = marshal_mapform( obj0 );
14481  }
14482  }
14483  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14484  if (!SWIG_IsOK(res2)) {
14485  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14486  }
14487  arg2 = (char *)(buf2);
14488  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
14489  if (!SWIG_IsOK(res3)) {
14490  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14491  }
14492  arg3 = (char *)(buf3);
14493  ecode4 = SWIG_AsVal_double(obj3, &val4);
14494  if (!SWIG_IsOK(ecode4)) {
14495  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14496  }
14497  arg4 = (PLFLT)(val4);
14498  ecode5 = SWIG_AsVal_double(obj4, &val5);
14499  if (!SWIG_IsOK(ecode5)) {
14500  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14501  }
14502  arg5 = (PLFLT)(val5);
14503  ecode6 = SWIG_AsVal_double(obj5, &val6);
14504  if (!SWIG_IsOK(ecode6)) {
14505  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14506  }
14507  arg6 = (PLFLT)(val6);
14508  ecode7 = SWIG_AsVal_double(obj6, &val7);
14509  if (!SWIG_IsOK(ecode7)) {
14510  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14511  }
14512  arg7 = (PLFLT)(val7);
14513  {
14514  if ( obj7 != Py_None )
14515  {
14516  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
14517  if ( tmp8 == NULL )
14518  return NULL;
14519  arg8 = (PLINT *) PyArray_DATA( tmp8 );
14520  arg9 = PyArray_DIMS( tmp8 )[0];
14521  }
14522  else
14523  {
14524  arg8 = NULL;
14525  arg9 = 0;
14526  }
14527  }
14528  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14529  resultobj = SWIG_Py_Void();
14530  {
14531  cleanup_mapform();
14532  }
14533  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14534  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14535  {
14536  Py_CLEAR( tmp8 );
14537  }
14538  return resultobj;
14539 fail:
14540  {
14541  cleanup_mapform();
14542  }
14543  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14544  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14545  {
14546  Py_CLEAR( tmp8 );
14547  }
14548  return NULL;
14549 }
14550 
14551 
14552 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14553  PyObject *resultobj = 0;
14554  mapform_func arg1 = (mapform_func) 0 ;
14555  char *arg2 = (char *) 0 ;
14556  PLFLT arg3 ;
14557  PLFLT arg4 ;
14558  PLFLT arg5 ;
14559  char *arg6 = (char *) 0 ;
14560  PLFLT arg7 ;
14561  PLFLT arg8 ;
14562  PLFLT arg9 ;
14563  PLFLT arg10 ;
14564  PLINT arg11 ;
14565  int res2 ;
14566  char *buf2 = 0 ;
14567  int alloc2 = 0 ;
14568  double val3 ;
14569  int ecode3 = 0 ;
14570  double val4 ;
14571  int ecode4 = 0 ;
14572  double val5 ;
14573  int ecode5 = 0 ;
14574  int res6 ;
14575  char *buf6 = 0 ;
14576  int alloc6 = 0 ;
14577  double val7 ;
14578  int ecode7 = 0 ;
14579  double val8 ;
14580  int ecode8 = 0 ;
14581  double val9 ;
14582  int ecode9 = 0 ;
14583  double val10 ;
14584  int ecode10 = 0 ;
14585  int val11 ;
14586  int ecode11 = 0 ;
14587  PyObject * obj0 = 0 ;
14588  PyObject * obj1 = 0 ;
14589  PyObject * obj2 = 0 ;
14590  PyObject * obj3 = 0 ;
14591  PyObject * obj4 = 0 ;
14592  PyObject * obj5 = 0 ;
14593  PyObject * obj6 = 0 ;
14594  PyObject * obj7 = 0 ;
14595  PyObject * obj8 = 0 ;
14596  PyObject * obj9 = 0 ;
14597  PyObject * obj10 = 0 ;
14598 
14599  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14600  {
14601  // it must be a callable or none
14602  if ( obj0 == Py_None )
14603  {
14604  arg1 = NULL;
14605  }
14606  else
14607  {
14608  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14609  {
14610  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14611  return NULL;
14612  }
14613  arg1 = marshal_mapform( obj0 );
14614  }
14615  }
14616  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14617  if (!SWIG_IsOK(res2)) {
14618  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14619  }
14620  arg2 = (char *)(buf2);
14621  ecode3 = SWIG_AsVal_double(obj2, &val3);
14622  if (!SWIG_IsOK(ecode3)) {
14623  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14624  }
14625  arg3 = (PLFLT)(val3);
14626  ecode4 = SWIG_AsVal_double(obj3, &val4);
14627  if (!SWIG_IsOK(ecode4)) {
14628  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14629  }
14630  arg4 = (PLFLT)(val4);
14631  ecode5 = SWIG_AsVal_double(obj4, &val5);
14632  if (!SWIG_IsOK(ecode5)) {
14633  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14634  }
14635  arg5 = (PLFLT)(val5);
14636  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
14637  if (!SWIG_IsOK(res6)) {
14638  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14639  }
14640  arg6 = (char *)(buf6);
14641  ecode7 = SWIG_AsVal_double(obj6, &val7);
14642  if (!SWIG_IsOK(ecode7)) {
14643  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14644  }
14645  arg7 = (PLFLT)(val7);
14646  ecode8 = SWIG_AsVal_double(obj7, &val8);
14647  if (!SWIG_IsOK(ecode8)) {
14648  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14649  }
14650  arg8 = (PLFLT)(val8);
14651  ecode9 = SWIG_AsVal_double(obj8, &val9);
14652  if (!SWIG_IsOK(ecode9)) {
14653  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14654  }
14655  arg9 = (PLFLT)(val9);
14656  ecode10 = SWIG_AsVal_double(obj9, &val10);
14657  if (!SWIG_IsOK(ecode10)) {
14658  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14659  }
14660  arg10 = (PLFLT)(val10);
14661  ecode11 = SWIG_AsVal_int(obj10, &val11);
14662  if (!SWIG_IsOK(ecode11)) {
14663  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14664  }
14665  arg11 = (PLINT)(val11);
14666  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14667  resultobj = SWIG_Py_Void();
14668  {
14669  cleanup_mapform();
14670  }
14671  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14672  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14673  return resultobj;
14674 fail:
14675  {
14676  cleanup_mapform();
14677  }
14678  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14679  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14680  return NULL;
14681 }
14682 
14683 
14684 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14685  PyObject *resultobj = 0;
14686  mapform_func arg1 = (mapform_func) 0 ;
14687  char *arg2 = (char *) 0 ;
14688  PLFLT arg3 ;
14689  PLFLT arg4 ;
14690  PLFLT arg5 ;
14691  PLFLT arg6 ;
14692  PLINT *arg7 = (PLINT *) 0 ;
14693  PLINT arg8 ;
14694  int res2 ;
14695  char *buf2 = 0 ;
14696  int alloc2 = 0 ;
14697  double val3 ;
14698  int ecode3 = 0 ;
14699  double val4 ;
14700  int ecode4 = 0 ;
14701  double val5 ;
14702  int ecode5 = 0 ;
14703  double val6 ;
14704  int ecode6 = 0 ;
14705  PyArrayObject *tmp7 = NULL ;
14706  PyObject * obj0 = 0 ;
14707  PyObject * obj1 = 0 ;
14708  PyObject * obj2 = 0 ;
14709  PyObject * obj3 = 0 ;
14710  PyObject * obj4 = 0 ;
14711  PyObject * obj5 = 0 ;
14712  PyObject * obj6 = 0 ;
14713 
14714  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14715  {
14716  // it must be a callable or none
14717  if ( obj0 == Py_None )
14718  {
14719  arg1 = NULL;
14720  }
14721  else
14722  {
14723  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14724  {
14725  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14726  return NULL;
14727  }
14728  arg1 = marshal_mapform( obj0 );
14729  }
14730  }
14731  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14732  if (!SWIG_IsOK(res2)) {
14733  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14734  }
14735  arg2 = (char *)(buf2);
14736  ecode3 = SWIG_AsVal_double(obj2, &val3);
14737  if (!SWIG_IsOK(ecode3)) {
14738  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14739  }
14740  arg3 = (PLFLT)(val3);
14741  ecode4 = SWIG_AsVal_double(obj3, &val4);
14742  if (!SWIG_IsOK(ecode4)) {
14743  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14744  }
14745  arg4 = (PLFLT)(val4);
14746  ecode5 = SWIG_AsVal_double(obj4, &val5);
14747  if (!SWIG_IsOK(ecode5)) {
14748  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14749  }
14750  arg5 = (PLFLT)(val5);
14751  ecode6 = SWIG_AsVal_double(obj5, &val6);
14752  if (!SWIG_IsOK(ecode6)) {
14753  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14754  }
14755  arg6 = (PLFLT)(val6);
14756  {
14757  if ( obj6 != Py_None )
14758  {
14759  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14760  if ( tmp7 == NULL )
14761  return NULL;
14762  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14763  arg8 = PyArray_DIMS( tmp7 )[0];
14764  }
14765  else
14766  {
14767  arg7 = NULL;
14768  arg8 = 0;
14769  }
14770  }
14771  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14772  resultobj = SWIG_Py_Void();
14773  {
14774  cleanup_mapform();
14775  }
14776  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14777  {
14778  Py_CLEAR( tmp7 );
14779  }
14780  return resultobj;
14781 fail:
14782  {
14783  cleanup_mapform();
14784  }
14785  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14786  {
14787  Py_CLEAR( tmp7 );
14788  }
14789  return NULL;
14790 }
14791 
14792 
14793 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14794  PyObject *resultobj = 0;
14795  mapform_func arg1 = (mapform_func) 0 ;
14796  PLFLT arg2 ;
14797  PLFLT arg3 ;
14798  PLFLT arg4 ;
14799  PLFLT arg5 ;
14800  PLFLT arg6 ;
14801  PLFLT arg7 ;
14802  double val2 ;
14803  int ecode2 = 0 ;
14804  double val3 ;
14805  int ecode3 = 0 ;
14806  double val4 ;
14807  int ecode4 = 0 ;
14808  double val5 ;
14809  int ecode5 = 0 ;
14810  double val6 ;
14811  int ecode6 = 0 ;
14812  double val7 ;
14813  int ecode7 = 0 ;
14814  PyObject * obj0 = 0 ;
14815  PyObject * obj1 = 0 ;
14816  PyObject * obj2 = 0 ;
14817  PyObject * obj3 = 0 ;
14818  PyObject * obj4 = 0 ;
14819  PyObject * obj5 = 0 ;
14820  PyObject * obj6 = 0 ;
14821 
14822  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14823  {
14824  // it must be a callable or none
14825  if ( obj0 == Py_None )
14826  {
14827  arg1 = NULL;
14828  }
14829  else
14830  {
14831  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14832  {
14833  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14834  return NULL;
14835  }
14836  arg1 = marshal_mapform( obj0 );
14837  }
14838  }
14839  ecode2 = SWIG_AsVal_double(obj1, &val2);
14840  if (!SWIG_IsOK(ecode2)) {
14841  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14842  }
14843  arg2 = (PLFLT)(val2);
14844  ecode3 = SWIG_AsVal_double(obj2, &val3);
14845  if (!SWIG_IsOK(ecode3)) {
14846  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14847  }
14848  arg3 = (PLFLT)(val3);
14849  ecode4 = SWIG_AsVal_double(obj3, &val4);
14850  if (!SWIG_IsOK(ecode4)) {
14851  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14852  }
14853  arg4 = (PLFLT)(val4);
14854  ecode5 = SWIG_AsVal_double(obj4, &val5);
14855  if (!SWIG_IsOK(ecode5)) {
14856  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14857  }
14858  arg5 = (PLFLT)(val5);
14859  ecode6 = SWIG_AsVal_double(obj5, &val6);
14860  if (!SWIG_IsOK(ecode6)) {
14861  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14862  }
14863  arg6 = (PLFLT)(val6);
14864  ecode7 = SWIG_AsVal_double(obj6, &val7);
14865  if (!SWIG_IsOK(ecode7)) {
14866  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14867  }
14868  arg7 = (PLFLT)(val7);
14869  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14870  resultobj = SWIG_Py_Void();
14871  {
14872  cleanup_mapform();
14873  }
14874  return resultobj;
14875 fail:
14876  {
14877  cleanup_mapform();
14878  }
14879  return NULL;
14880 }
14881 
14882 
14883 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14884  PyObject *resultobj = 0;
14885  PLFLT **arg1 = (PLFLT **) 0 ;
14886  PLINT arg2 ;
14887  PLINT arg3 ;
14888  PLFLT arg4 ;
14889  PLFLT arg5 ;
14890  PLFLT arg6 ;
14891  PLFLT arg7 ;
14892  PLFLT arg8 ;
14893  PLFLT arg9 ;
14894  PLFLT arg10 ;
14895  PLFLT arg11 ;
14896  PLFLT arg12 ;
14897  PLFLT arg13 ;
14898  PyArrayObject *tmp1 = NULL ;
14899  double val4 ;
14900  int ecode4 = 0 ;
14901  double val5 ;
14902  int ecode5 = 0 ;
14903  double val6 ;
14904  int ecode6 = 0 ;
14905  double val7 ;
14906  int ecode7 = 0 ;
14907  double val8 ;
14908  int ecode8 = 0 ;
14909  double val9 ;
14910  int ecode9 = 0 ;
14911  double val10 ;
14912  int ecode10 = 0 ;
14913  double val11 ;
14914  int ecode11 = 0 ;
14915  double val12 ;
14916  int ecode12 = 0 ;
14917  double val13 ;
14918  int ecode13 = 0 ;
14919  PyObject * obj0 = 0 ;
14920  PyObject * obj1 = 0 ;
14921  PyObject * obj2 = 0 ;
14922  PyObject * obj3 = 0 ;
14923  PyObject * obj4 = 0 ;
14924  PyObject * obj5 = 0 ;
14925  PyObject * obj6 = 0 ;
14926  PyObject * obj7 = 0 ;
14927  PyObject * obj8 = 0 ;
14928  PyObject * obj9 = 0 ;
14929  PyObject * obj10 = 0 ;
14930 
14931  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14932  {
14933  int i, size;
14934  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14935  if ( tmp1 == NULL )
14936  return NULL;
14937  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14938  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14939  size = arg3;
14940  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14941  for ( i = 0; i < arg2; i++ )
14942  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14943  }
14944  ecode4 = SWIG_AsVal_double(obj1, &val4);
14945  if (!SWIG_IsOK(ecode4)) {
14946  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14947  }
14948  arg4 = (PLFLT)(val4);
14949  ecode5 = SWIG_AsVal_double(obj2, &val5);
14950  if (!SWIG_IsOK(ecode5)) {
14951  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14952  }
14953  arg5 = (PLFLT)(val5);
14954  ecode6 = SWIG_AsVal_double(obj3, &val6);
14955  if (!SWIG_IsOK(ecode6)) {
14956  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14957  }
14958  arg6 = (PLFLT)(val6);
14959  ecode7 = SWIG_AsVal_double(obj4, &val7);
14960  if (!SWIG_IsOK(ecode7)) {
14961  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14962  }
14963  arg7 = (PLFLT)(val7);
14964  ecode8 = SWIG_AsVal_double(obj5, &val8);
14965  if (!SWIG_IsOK(ecode8)) {
14966  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14967  }
14968  arg8 = (PLFLT)(val8);
14969  ecode9 = SWIG_AsVal_double(obj6, &val9);
14970  if (!SWIG_IsOK(ecode9)) {
14971  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14972  }
14973  arg9 = (PLFLT)(val9);
14974  ecode10 = SWIG_AsVal_double(obj7, &val10);
14975  if (!SWIG_IsOK(ecode10)) {
14976  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14977  }
14978  arg10 = (PLFLT)(val10);
14979  ecode11 = SWIG_AsVal_double(obj8, &val11);
14980  if (!SWIG_IsOK(ecode11)) {
14981  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14982  }
14983  arg11 = (PLFLT)(val11);
14984  ecode12 = SWIG_AsVal_double(obj9, &val12);
14985  if (!SWIG_IsOK(ecode12)) {
14986  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14987  }
14988  arg12 = (PLFLT)(val12);
14989  ecode13 = SWIG_AsVal_double(obj10, &val13);
14990  if (!SWIG_IsOK(ecode13)) {
14991  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14992  }
14993  arg13 = (PLFLT)(val13);
14994  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14995  resultobj = SWIG_Py_Void();
14996  {
14997  Py_CLEAR( tmp1 );
14998  free( arg1 );
14999  }
15000  return resultobj;
15001 fail:
15002  {
15003  Py_CLEAR( tmp1 );
15004  free( arg1 );
15005  }
15006  return NULL;
15007 }
15008 
15009 
15010 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15011  PyObject *resultobj = 0;
15012  PLFLT **arg1 = (PLFLT **) 0 ;
15013  PLINT arg2 ;
15014  PLINT arg3 ;
15015  PLFLT arg4 ;
15016  PLFLT arg5 ;
15017  PLFLT arg6 ;
15018  PLFLT arg7 ;
15019  PLFLT arg8 ;
15020  PLFLT arg9 ;
15021  PLFLT arg10 ;
15022  PLFLT arg11 ;
15023  pltr_func arg12 = (pltr_func) 0 ;
15024  PLPointer arg13 = (PLPointer) 0 ;
15025  PyArrayObject *tmp1 = NULL ;
15026  double val4 ;
15027  int ecode4 = 0 ;
15028  double val5 ;
15029  int ecode5 = 0 ;
15030  double val6 ;
15031  int ecode6 = 0 ;
15032  double val7 ;
15033  int ecode7 = 0 ;
15034  double val8 ;
15035  int ecode8 = 0 ;
15036  double val9 ;
15037  int ecode9 = 0 ;
15038  double val10 ;
15039  int ecode10 = 0 ;
15040  double val11 ;
15041  int ecode11 = 0 ;
15042  PyObject * obj0 = 0 ;
15043  PyObject * obj1 = 0 ;
15044  PyObject * obj2 = 0 ;
15045  PyObject * obj3 = 0 ;
15046  PyObject * obj4 = 0 ;
15047  PyObject * obj5 = 0 ;
15048  PyObject * obj6 = 0 ;
15049  PyObject * obj7 = 0 ;
15050  PyObject * obj8 = 0 ;
15051  PyObject * obj9 = 0 ;
15052  PyObject * obj10 = 0 ;
15053 
15054  {
15055  python_pltr = 0;
15056  arg12 = NULL;
15057  }
15058  {
15059  arg13 = NULL;
15060  }
15061  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
15062  {
15063  int i, size;
15064  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15065  if ( tmp1 == NULL )
15066  return NULL;
15067  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15068  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15069  size = arg3;
15070  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15071  for ( i = 0; i < arg2; i++ )
15072  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15073  }
15074  ecode4 = SWIG_AsVal_double(obj1, &val4);
15075  if (!SWIG_IsOK(ecode4)) {
15076  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15077  }
15078  arg4 = (PLFLT)(val4);
15079  ecode5 = SWIG_AsVal_double(obj2, &val5);
15080  if (!SWIG_IsOK(ecode5)) {
15081  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15082  }
15083  arg5 = (PLFLT)(val5);
15084  ecode6 = SWIG_AsVal_double(obj3, &val6);
15085  if (!SWIG_IsOK(ecode6)) {
15086  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15087  }
15088  arg6 = (PLFLT)(val6);
15089  ecode7 = SWIG_AsVal_double(obj4, &val7);
15090  if (!SWIG_IsOK(ecode7)) {
15091  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15092  }
15093  arg7 = (PLFLT)(val7);
15094  ecode8 = SWIG_AsVal_double(obj5, &val8);
15095  if (!SWIG_IsOK(ecode8)) {
15096  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15097  }
15098  arg8 = (PLFLT)(val8);
15099  ecode9 = SWIG_AsVal_double(obj6, &val9);
15100  if (!SWIG_IsOK(ecode9)) {
15101  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15102  }
15103  arg9 = (PLFLT)(val9);
15104  ecode10 = SWIG_AsVal_double(obj7, &val10);
15105  if (!SWIG_IsOK(ecode10)) {
15106  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15107  }
15108  arg10 = (PLFLT)(val10);
15109  ecode11 = SWIG_AsVal_double(obj8, &val11);
15110  if (!SWIG_IsOK(ecode11)) {
15111  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15112  }
15113  arg11 = (PLFLT)(val11);
15114  if (obj9) {
15115  {
15116  // it must be a callable or None
15117  if ( obj9 == Py_None )
15118  {
15119  arg12 = NULL;
15120  }
15121  else
15122  {
15123  if ( !PyCallable_Check( (PyObject *) obj9 ) )
15124  {
15125  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15126  return NULL;
15127  }
15128  arg12 = marshal_pltr( obj9 );
15129  }
15130  }
15131  }
15132  if (obj10) {
15133  {
15134  if ( obj10 == Py_None )
15135  arg13 = NULL;
15136  else
15137  {
15138  arg13 = marshal_PLPointer( obj10, 1 );
15139  }
15140  }
15141  }
15142  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15143  resultobj = SWIG_Py_Void();
15144  {
15145  Py_CLEAR( tmp1 );
15146  free( arg1 );
15147  }
15148  {
15149  cleanup_pltr();
15150  }
15151  {
15153  }
15154  return resultobj;
15155 fail:
15156  {
15157  Py_CLEAR( tmp1 );
15158  free( arg1 );
15159  }
15160  {
15161  cleanup_pltr();
15162  }
15163  {
15165  }
15166  return NULL;
15167 }
15168 
15169 
15170 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171  PyObject *resultobj = 0;
15172 
15173  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
15174  plClearOpts();
15175  resultobj = SWIG_Py_Void();
15176  return resultobj;
15177 fail:
15178  return NULL;
15179 }
15180 
15181 
15182 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183  PyObject *resultobj = 0;
15184 
15185  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
15186  plResetOpts();
15187  resultobj = SWIG_Py_Void();
15188  return resultobj;
15189 fail:
15190  return NULL;
15191 }
15192 
15193 
15194 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195  PyObject *resultobj = 0;
15196  char *arg1 = (char *) 0 ;
15197  char *arg2 = (char *) 0 ;
15198  int res1 ;
15199  char *buf1 = 0 ;
15200  int alloc1 = 0 ;
15201  int res2 ;
15202  char *buf2 = 0 ;
15203  int alloc2 = 0 ;
15204  PyObject * obj0 = 0 ;
15205  PyObject * obj1 = 0 ;
15206 
15207  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
15208  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
15209  if (!SWIG_IsOK(res1)) {
15210  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15211  }
15212  arg1 = (char *)(buf1);
15213  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15214  if (!SWIG_IsOK(res2)) {
15215  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15216  }
15217  arg2 = (char *)(buf2);
15218  plSetUsage((char const *)arg1,(char const *)arg2);
15219  resultobj = SWIG_Py_Void();
15220  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15221  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15222  return resultobj;
15223 fail:
15224  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15225  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15226  return NULL;
15227 }
15228 
15229 
15230 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15231  PyObject *resultobj = 0;
15232 
15233  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
15234  plOptUsage();
15235  resultobj = SWIG_Py_Void();
15236  return resultobj;
15237 fail:
15238  return NULL;
15239 }
15240 
15241 
15242 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15243  PyObject *resultobj = 0;
15244  PLFLT **arg1 = (PLFLT **) 0 ;
15245  PLINT arg2 ;
15246  PLINT arg3 ;
15247  PLFLT *arg4 = (PLFLT *) 0 ;
15248  PLFLT *arg5 = (PLFLT *) 0 ;
15249  PyArrayObject *tmp1 = NULL ;
15250  PLFLT temp4 ;
15251  int res4 = SWIG_TMPOBJ ;
15252  PLFLT temp5 ;
15253  int res5 = SWIG_TMPOBJ ;
15254  PyObject * obj0 = 0 ;
15255 
15256  arg4 = &temp4;
15257  arg5 = &temp5;
15258  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
15259  {
15260  int i, size;
15261  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15262  if ( tmp1 == NULL )
15263  return NULL;
15264  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15265  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15266  size = arg3;
15267  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15268  for ( i = 0; i < arg2; i++ )
15269  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15270  }
15271  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15272  resultobj = SWIG_Py_Void();
15273  if (SWIG_IsTmpObj(res4)) {
15274  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15275  } else {
15276  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15277  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15278  }
15279  if (SWIG_IsTmpObj(res5)) {
15280  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15281  } else {
15282  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15283  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15284  }
15285  {
15286  Py_CLEAR( tmp1 );
15287  free( arg1 );
15288  }
15289  return resultobj;
15290 fail:
15291  {
15292  Py_CLEAR( tmp1 );
15293  free( arg1 );
15294  }
15295  return NULL;
15296 }
15297 
15298 
15299 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300  PyObject *resultobj = 0;
15301  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15302  void *argp1 = 0 ;
15303  int res1 = 0 ;
15304  PyObject * obj0 = 0 ;
15305  PLINT result;
15306 
15307  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
15308  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15309  if (!SWIG_IsOK(res1)) {
15310  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15311  }
15312  arg1 = (PLGraphicsIn *)(argp1);
15313  result = (PLINT)plGetCursor(arg1);
15314  resultobj = SWIG_From_int((int)(result));
15315  return resultobj;
15316 fail:
15317  return NULL;
15318 }
15319 
15320 
15321 static PyMethodDef SwigMethods[] = {
15322  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
15323  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15324  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15325  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15326  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15327  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
15328  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15329  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
15330  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15331  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
15332  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15333  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
15334  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15335  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
15336  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15337  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
15338  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15339  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
15340  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15341  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
15342  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15343  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
15344  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15345  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
15346  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15347  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
15348  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15349  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
15350  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
15351  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
15352  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
15353  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
15354  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
15355  "Set format of numerical label for contours\n"
15356  "\n"
15357  "DESCRIPTION:\n"
15358  "\n"
15359  " Set format of numerical label for contours.\n"
15360  "\n"
15361  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15362  "\n"
15363  " This function is used example 9.\n"
15364  "\n"
15365  "\n"
15366  "\n"
15367  "SYNOPSIS:\n"
15368  "\n"
15369  "pl_setcontlabelformat(lexp, sigdig)\n"
15370  "\n"
15371  "ARGUMENTS:\n"
15372  "\n"
15373  " lexp (PLINT, input) : If the contour numerical label is greater\n"
15374  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15375  " format is used. Default value of lexp is 4.\n"
15376  "\n"
15377  " sigdig (PLINT, input) : Number of significant digits. Default\n"
15378  " value is 2.\n"
15379  "\n"
15380  ""},
15381  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
15382  "Set parameters of contour labelling other than format of numerical label\n"
15383  "\n"
15384  "DESCRIPTION:\n"
15385  "\n"
15386  " Set parameters of contour labelling other than those handled by\n"
15387  " pl_setcontlabelformat.\n"
15388  "\n"
15389  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15390  "\n"
15391  " This function is used in example 9.\n"
15392  "\n"
15393  "\n"
15394  "\n"
15395  "SYNOPSIS:\n"
15396  "\n"
15397  "pl_setcontlabelparam(offset, size, spacing, active)\n"
15398  "\n"
15399  "ARGUMENTS:\n"
15400  "\n"
15401  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15402  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15403  "\n"
15404  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15405  " Default value is 0.3.\n"
15406  "\n"
15407  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15408  " Default value is 0.1.\n"
15409  "\n"
15410  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15411  " contour labels on. Default is off (0).\n"
15412  "\n"
15413  ""},
15414  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
15415  "Advance the (sub-)page\n"
15416  "\n"
15417  "DESCRIPTION:\n"
15418  "\n"
15419  " Advances to the next subpage if sub=0, performing a page advance if\n"
15420  " there are no remaining subpages on the current page. If subpages\n"
15421  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15422  " PLplot switches to the specified subpage. Note that this allows you\n"
15423  " to overwrite a plot on the specified subpage; if this is not what you\n"
15424  " intended, use pleop followed by plbop to first advance the page. This\n"
15425  " routine is called automatically (with page=0) by plenv, but if plenv\n"
15426  " is not used, pladv must be called after initializing PLplot but before\n"
15427  " defining the viewport.\n"
15428  "\n"
15429  " Redacted form: pladv(page)\n"
15430  "\n"
15431  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15432  " 29, and 31.\n"
15433  "\n"
15434  "\n"
15435  "\n"
15436  "SYNOPSIS:\n"
15437  "\n"
15438  "pladv(page)\n"
15439  "\n"
15440  "ARGUMENTS:\n"
15441  "\n"
15442  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15443  " in the top left corner and increasing along the rows) to which to\n"
15444  " advance. Set to zero to advance to the next subpage (or to the\n"
15445  " next page if subpages are not being used).\n"
15446  "\n"
15447  ""},
15448  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
15449  "Draw a circular or elliptical arc\n"
15450  "\n"
15451  "DESCRIPTION:\n"
15452  "\n"
15453  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15454  " semiminor axis b, starting at angle1 and ending at angle2.\n"
15455  "\n"
15456  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15457  " fill)\n"
15458  "\n"
15459  "\n"
15460  " This function is used in examples 3 and 27.\n"
15461  "\n"
15462  "\n"
15463  "\n"
15464  "SYNOPSIS:\n"
15465  "\n"
15466  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15467  "\n"
15468  "ARGUMENTS:\n"
15469  "\n"
15470  " x (PLFLT, input) : X coordinate of arc center.\n"
15471  "\n"
15472  " y (PLFLT, input) : Y coordinate of arc center.\n"
15473  "\n"
15474  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15475  "\n"
15476  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15477  "\n"
15478  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15479  " semimajor axis.\n"
15480  "\n"
15481  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15482  " semimajor axis.\n"
15483  "\n"
15484  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15485  " X-axis.\n"
15486  "\n"
15487  " fill (PLBOOL, input) : Draw a filled arc.\n"
15488  "\n"
15489  ""},
15490  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
15491  "Draw a box with axes, etc. with arbitrary origin\n"
15492  "\n"
15493  "DESCRIPTION:\n"
15494  "\n"
15495  " Draws a box around the currently defined viewport with arbitrary\n"
15496  " world-coordinate origin specified by x0 and y0 and labels it with\n"
15497  " world coordinate values appropriate to the window. Thus plaxes should\n"
15498  " only be called after defining both viewport and window. The ascii\n"
15499  " character strings xopt and yopt specify how the box should be drawn as\n"
15500  " described below. If ticks and/or subticks are to be drawn for a\n"
15501  " particular axis, the tick intervals and number of subintervals may be\n"
15502  " specified explicitly, or they may be defaulted by setting the\n"
15503  " appropriate arguments to zero.\n"
15504  "\n"
15505  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15506  " ytick, nysub)\n"
15507  "\n"
15508  "\n"
15509  " This function is not used in any examples.\n"
15510  "\n"
15511  "\n"
15512  "\n"
15513  "SYNOPSIS:\n"
15514  "\n"
15515  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15516  "\n"
15517  "ARGUMENTS:\n"
15518  "\n"
15519  " x0 (PLFLT, input) : World X coordinate of origin.\n"
15520  "\n"
15521  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15522  "\n"
15523  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15524  " options for the x axis. The string can include any combination of\n"
15525  " the following letters (upper or lower case) in any order: a: Draws\n"
15526  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15527  " (x=0).\n"
15528  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15529  " c: Draws top (X) or right (Y) edge of frame.\n"
15530  " d: Plot labels as date / time. Values are assumed to be\n"
15531  " seconds since the epoch (as used by gmtime).\n"
15532  " f: Always use fixed point numeric labels.\n"
15533  " g: Draws a grid at the major tick interval.\n"
15534  " h: Draws a grid at the minor tick interval.\n"
15535  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15536  " inwards.\n"
15537  " l: Labels axis logarithmically. This only affects the labels,\n"
15538  " not the data, and so it is necessary to compute the logarithms\n"
15539  " of data points before passing them to any of the drawing\n"
15540  " routines.\n"
15541  " m: Writes numeric labels at major tick intervals in the\n"
15542  " unconventional location (above box for X, right of box for Y).\n"
15543  " n: Writes numeric labels at major tick intervals in the\n"
15544  " conventional location (below box for X, left of box for Y).\n"
15545  " o: Use custom labelling function to generate axis label text.\n"
15546  " The custom labelling function can be defined with the\n"
15547  " plslabelfunc command.\n"
15548  " s: Enables subticks between major ticks, only valid if t is\n"
15549  " also specified.\n"
15550  " t: Draws major ticks.\n"
15551  " u: Exactly like \"b\" except don't draw edge line.\n"
15552  " w: Exactly like \"c\" except don't draw edge line.\n"
15553  " x: Exactly like \"t\" (including the side effect of the\n"
15554  " numerical labels for the major ticks) except exclude drawing\n"
15555  " the major and minor tick marks.\n"
15556  "\n"
15557  "\n"
15558  " xtick (PLFLT, input) : World coordinate interval between major\n"
15559  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15560  " generates a suitable tick interval.\n"
15561  "\n"
15562  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15563  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15564  " generates a suitable minor tick interval.\n"
15565  "\n"
15566  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15567  " options for the y axis. The string can include any combination of\n"
15568  " the letters defined above for xopt, and in addition may contain:\n"
15569  " v: Write numeric labels for the y axis parallel to the base of the\n"
15570  " graph, rather than parallel to the axis.\n"
15571  "\n"
15572  "\n"
15573  " ytick (PLFLT, input) : World coordinate interval between major\n"
15574  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15575  " generates a suitable tick interval.\n"
15576  "\n"
15577  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15578  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15579  " generates a suitable minor tick interval.\n"
15580  "\n"
15581  ""},
15582  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
15583  "Plot a histogram from binned data\n"
15584  "\n"
15585  "DESCRIPTION:\n"
15586  "\n"
15587  " Plots a histogram consisting of nbin bins. The value associated with\n"
15588  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15589  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15590  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15591  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15592  " placed midway between the values in the x vector. Also see plhist for\n"
15593  " drawing histograms from unbinned data.\n"
15594  "\n"
15595  " Redacted form: General: plbin(x, y, opt)\n"
15596  " Python: plbin(nbin, x, y, opt)\n"
15597  "\n"
15598  "\n"
15599  " This function is not used in any examples.\n"
15600  "\n"
15601  "\n"
15602  "\n"
15603  "SYNOPSIS:\n"
15604  "\n"
15605  "plbin(nbin, x, y, opt)\n"
15606  "\n"
15607  "ARGUMENTS:\n"
15608  "\n"
15609  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15610  " and y vectors.)\n"
15611  "\n"
15612  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15613  " with bins. These must form a strictly increasing sequence.\n"
15614  "\n"
15615  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15616  " proportional to the number of points in each bin. This is a PLFLT\n"
15617  " (instead of PLINT) vector so as to allow histograms of\n"
15618  " probabilities, etc.\n"
15619  "\n"
15620  " opt (PLINT, input) : Is a combination of several flags:\n"
15621  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15622  " outer bins are expanded to fill up the entire x-axis and bins of\n"
15623  " zero height are simply drawn.\n"
15624  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15625  " between the x values. If the values in x are equally spaced,\n"
15626  " the values are the center values of the bins.\n"
15627  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15628  " size as the ones inside.\n"
15629  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15630  " (there is a gap for such bins).\n"
15631  "\n"
15632  ""},
15633  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15634  "Calculate broken-down time from continuous time for the current stream\n"
15635  "\n"
15636  "DESCRIPTION:\n"
15637  "\n"
15638  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15639  " continuous time, ctime for the current stream. This function is the\n"
15640  " inverse of plctime.\n"
15641  "\n"
15642  " The PLplot definition of broken-down time is a calendar time that\n"
15643  " completely ignores all time zone offsets, i.e., it is the user's\n"
15644  " responsibility to apply those offsets (if so desired) before using the\n"
15645  " PLplot time API. By default broken-down time is defined using the\n"
15646  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15647  " continuous time is defined as the number of seconds since the Unix\n"
15648  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15649  " broken-down and continuous time are possible, see plconfigtime.\n"
15650  "\n"
15651  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15652  " ctime)\n"
15653  "\n"
15654  "\n"
15655  " This function is used in example 29.\n"
15656  "\n"
15657  "\n"
15658  "\n"
15659  "SYNOPSIS:\n"
15660  "\n"
15661  "plbtime(year, month, day, hour, min, sec, ctime)\n"
15662  "\n"
15663  "ARGUMENTS:\n"
15664  "\n"
15665  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15666  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15667  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15668  " BCE, etc.)\n"
15669  "\n"
15670  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15671  " the year in the range from 0 (January) to 11 (December).\n"
15672  "\n"
15673  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15674  " month in the range from 1 to 31.\n"
15675  "\n"
15676  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15677  " day in the range from 0 to 23.\n"
15678  "\n"
15679  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15680  " hour in the range from 0 to 59\n"
15681  "\n"
15682  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15683  " minute in range from 0. to 60.\n"
15684  "\n"
15685  " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15686  " time is calculated.\n"
15687  "\n"
15688  ""},
15689  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15690  "Begin a new page\n"
15691  "\n"
15692  "DESCRIPTION:\n"
15693  "\n"
15694  " Begins a new page. For a file driver, the output file is opened if\n"
15695  " necessary. Advancing the page via pleop and plbop is useful when a\n"
15696  " page break is desired at a particular point when plotting to subpages.\n"
15697  " Another use for pleop and plbop is when plotting pages to different\n"
15698  " files, since you can manually set the file name by calling plsfnam\n"
15699  " after the call to pleop. (In fact some drivers may only support a\n"
15700  " single page per file, making this a necessity.) One way to handle\n"
15701  " this case automatically is to page advance via pladv, but enable\n"
15702  " familying (see plsfam) with a small limit on the file size so that a\n"
15703  " new family member file will be created on each page break.\n"
15704  "\n"
15705  " Redacted form: plbop()\n"
15706  "\n"
15707  " This function is used in examples 2 and 20.\n"
15708  "\n"
15709  "\n"
15710  "\n"
15711  "SYNOPSIS:\n"
15712  "\n"
15713  "plbop()\n"
15714  "\n"
15715  ""},
15716  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15717  "Draw a box with axes, etc\n"
15718  "\n"
15719  "DESCRIPTION:\n"
15720  "\n"
15721  " Draws a box around the currently defined viewport, and labels it with\n"
15722  " world coordinate values appropriate to the window. Thus plbox should\n"
15723  " only be called after defining both viewport and window. The ascii\n"
15724  " character strings xopt and yopt specify how the box should be drawn as\n"
15725  " described below. If ticks and/or subticks are to be drawn for a\n"
15726  " particular axis, the tick intervals and number of subintervals may be\n"
15727  " specified explicitly, or they may be defaulted by setting the\n"
15728  " appropriate arguments to zero.\n"
15729  "\n"
15730  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15731  "\n"
15732  "\n"
15733  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15734  " and 29.\n"
15735  "\n"
15736  "\n"
15737  "\n"
15738  "SYNOPSIS:\n"
15739  "\n"
15740  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15741  "\n"
15742  "ARGUMENTS:\n"
15743  "\n"
15744  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15745  " options for the x axis. The string can include any combination of\n"
15746  " the following letters (upper or lower case) in any order: a: Draws\n"
15747  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15748  " (x=0).\n"
15749  " b: Draws bottom (X) or left (Y) edge of frame.\n"
15750  " c: Draws top (X) or right (Y) edge of frame.\n"
15751  " d: Plot labels as date / time. Values are assumed to be\n"
15752  " seconds since the epoch (as used by gmtime).\n"
15753  " f: Always use fixed point numeric labels.\n"
15754  " g: Draws a grid at the major tick interval.\n"
15755  " h: Draws a grid at the minor tick interval.\n"
15756  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15757  " inwards.\n"
15758  " l: Labels axis logarithmically. This only affects the labels,\n"
15759  " not the data, and so it is necessary to compute the logarithms\n"
15760  " of data points before passing them to any of the drawing\n"
15761  " routines.\n"
15762  " m: Writes numeric labels at major tick intervals in the\n"
15763  " unconventional location (above box for X, right of box for Y).\n"
15764  " n: Writes numeric labels at major tick intervals in the\n"
15765  " conventional location (below box for X, left of box for Y).\n"
15766  " o: Use custom labelling function to generate axis label text.\n"
15767  " The custom labelling function can be defined with the\n"
15768  " plslabelfunc command.\n"
15769  " s: Enables subticks between major ticks, only valid if t is\n"
15770  " also specified.\n"
15771  " t: Draws major ticks.\n"
15772  " u: Exactly like \"b\" except don't draw edge line.\n"
15773  " w: Exactly like \"c\" except don't draw edge line.\n"
15774  " x: Exactly like \"t\" (including the side effect of the\n"
15775  " numerical labels for the major ticks) except exclude drawing\n"
15776  " the major and minor tick marks.\n"
15777  "\n"
15778  "\n"
15779  " xtick (PLFLT, input) : World coordinate interval between major\n"
15780  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15781  " generates a suitable tick interval.\n"
15782  "\n"
15783  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15784  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15785  " generates a suitable minor tick interval.\n"
15786  "\n"
15787  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15788  " options for the y axis. The string can include any combination of\n"
15789  " the letters defined above for xopt, and in addition may contain:\n"
15790  " v: Write numeric labels for the y axis parallel to the base of the\n"
15791  " graph, rather than parallel to the axis.\n"
15792  "\n"
15793  "\n"
15794  " ytick (PLFLT, input) : World coordinate interval between major\n"
15795  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15796  " generates a suitable tick interval.\n"
15797  "\n"
15798  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15799  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15800  " generates a suitable minor tick interval.\n"
15801  "\n"
15802  ""},
15803  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15804  "Draw a box with axes, etc, in 3-d\n"
15805  "\n"
15806  "DESCRIPTION:\n"
15807  "\n"
15808  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15809  " plot. For a more complete description of three-dimensional plotting\n"
15810  " see the PLplot documentation.\n"
15811  "\n"
15812  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15813  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15814  "\n"
15815  "\n"
15816  " This function is used in examples 8, 11, 18, and 21.\n"
15817  "\n"
15818  "\n"
15819  "\n"
15820  "SYNOPSIS:\n"
15821  "\n"
15822  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15823  "\n"
15824  "ARGUMENTS:\n"
15825  "\n"
15826  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15827  " options for the x axis. The string can include any combination of\n"
15828  " the following letters (upper or lower case) in any order: b: Draws\n"
15829  " axis at base, at height z=\n"
15830  " zmin where zmin is defined by call to plw3d. This character must be\n"
15831  " specified in order to use any of the other options.\n"
15832  " d: Plot labels as date / time. Values are assumed to be\n"
15833  " seconds since the epoch (as used by gmtime).\n"
15834  " f: Always use fixed point numeric labels.\n"
15835  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15836  " than upwards.\n"
15837  " l: Labels axis logarithmically. This only affects the labels,\n"
15838  " not the data, and so it is necessary to compute the logarithms\n"
15839  " of data points before passing them to any of the drawing\n"
15840  " routines.\n"
15841  " n: Writes numeric labels at major tick intervals.\n"
15842  " o: Use custom labelling function to generate axis label text.\n"
15843  " The custom labelling function can be defined with the\n"
15844  " plslabelfunc command.\n"
15845  " s: Enables subticks between major ticks, only valid if t is\n"
15846  " also specified.\n"
15847  " t: Draws major ticks.\n"
15848  " u: If this is specified, the text label for the axis is\n"
15849  " written under the axis.\n"
15850  "\n"
15851  "\n"
15852  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15853  " the text label for the x axis. It is only drawn if u is in the\n"
15854  " xopt string.\n"
15855  "\n"
15856  " xtick (PLFLT, input) : World coordinate interval between major\n"
15857  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15858  " generates a suitable tick interval.\n"
15859  "\n"
15860  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15861  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15862  " generates a suitable minor tick interval.\n"
15863  "\n"
15864  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15865  " options for the y axis. The string is interpreted in the same way\n"
15866  " as xopt.\n"
15867  "\n"
15868  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15869  " the text label for the y axis. It is only drawn if u is in the\n"
15870  " yopt string.\n"
15871  "\n"
15872  " ytick (PLFLT, input) : World coordinate interval between major\n"
15873  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15874  " generates a suitable tick interval.\n"
15875  "\n"
15876  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15877  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15878  " generates a suitable minor tick interval.\n"
15879  "\n"
15880  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15881  " options for the z axis. The string can include any combination of\n"
15882  " the following letters (upper or lower case) in any order: b: Draws\n"
15883  " z axis to the left of the surface plot.\n"
15884  " c: Draws z axis to the right of the surface plot.\n"
15885  " d: Draws grid lines parallel to the x-y plane behind the\n"
15886  " figure. These lines are not drawn until after plot3d or\n"
15887  " plmesh are called because of the need for hidden line removal.\n"
15888  " e: Plot labels as date / time. Values are assumed to be\n"
15889  " seconds since the epoch (as used by gmtime). Note this\n"
15890  " suboption is interpreted the same as the d suboption for xopt\n"
15891  " and yopt, but it has to be identified as e for zopt since d\n"
15892  " has already been used for the different purpose above.\n"
15893  " f: Always use fixed point numeric labels.\n"
15894  " i: Inverts tick marks, so they are drawn away from the center.\n"
15895  " l: Labels axis logarithmically. This only affects the labels,\n"
15896  " not the data, and so it is necessary to compute the logarithms\n"
15897  " of data points before passing them to any of the drawing\n"
15898  " routines.\n"
15899  " m: Writes numeric labels at major tick intervals on the\n"
15900  " right-hand z axis.\n"
15901  " n: Writes numeric labels at major tick intervals on the\n"
15902  " left-hand z axis.\n"
15903  " o: Use custom labelling function to generate axis label text.\n"
15904  " The custom labelling function can be defined with the\n"
15905  " plslabelfunc command.\n"
15906  " s: Enables subticks between major ticks, only valid if t is\n"
15907  " also specified.\n"
15908  " t: Draws major ticks.\n"
15909  " u: If this is specified, the text label is written beside the\n"
15910  " left-hand axis.\n"
15911  " v: If this is specified, the text label is written beside the\n"
15912  " right-hand axis.\n"
15913  "\n"
15914  "\n"
15915  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15916  " the text label for the z axis. It is only drawn if u or v are in\n"
15917  " the zopt string.\n"
15918  "\n"
15919  " ztick (PLFLT, input) : World coordinate interval between major\n"
15920  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15921  " generates a suitable tick interval.\n"
15922  "\n"
15923  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15924  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15925  " generates a suitable minor tick interval.\n"
15926  "\n"
15927  ""},
15928  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15929  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15930  "\n"
15931  "DESCRIPTION:\n"
15932  "\n"
15933  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15934  " from relative device coordinates, rx and ry.\n"
15935  "\n"
15936  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15937  "\n"
15938  "\n"
15939  " This function is used in example 31.\n"
15940  "\n"
15941  "\n"
15942  "\n"
15943  "SYNOPSIS:\n"
15944  "\n"
15945  "plcalc_world(rx, ry, wx, wy, window)\n"
15946  "\n"
15947  "ARGUMENTS:\n"
15948  "\n"
15949  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15950  " the x coordinate.\n"
15951  "\n"
15952  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15953  " the y coordinate.\n"
15954  "\n"
15955  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15956  " coordinate corresponding to the relative device coordinates rx and\n"
15957  " ry.\n"
15958  "\n"
15959  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15960  " coordinate corresponding to the relative device coordinates rx and\n"
15961  " ry.\n"
15962  "\n"
15963  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15964  " defined window index that corresponds to the input relative device\n"
15965  " coordinates (and the returned world coordinates). To give some\n"
15966  " background on the window index, for each page the initial window\n"
15967  " index is set to zero, and each time plwind is called within the\n"
15968  " page, world and device coordinates are stored for the window and\n"
15969  " the window index is incremented. Thus, for a simple page layout\n"
15970  " with non-overlapping viewports and one window per viewport, window\n"
15971  " corresponds to the viewport index (in the order which the\n"
15972  " viewport/windows were created) of the only viewport/window\n"
15973  " corresponding to rx and ry. However, for more complicated layouts\n"
15974  " with potentially overlapping viewports and possibly more than one\n"
15975  " window (set of world coordinates) per viewport, window and the\n"
15976  " corresponding output world coordinates corresponds to the last\n"
15977  " window created that fulfills the criterion that the relative\n"
15978  " device coordinates are inside it. Finally, in all cases where the\n"
15979  " input relative device coordinates are not inside any\n"
15980  " viewport/window, then the returned value of the last defined\n"
15981  " window index is set to -1.\n"
15982  "\n"
15983  ""},
15984  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15985  "Clear current (sub)page\n"
15986  "\n"
15987  "DESCRIPTION:\n"
15988  "\n"
15989  " Clears the current page, effectively erasing everything that have been\n"
15990  " drawn. This command only works with interactive drivers; if the\n"
15991  " driver does not support this, the page is filled with the background\n"
15992  " color in use. If the current page is divided into subpages, only the\n"
15993  " current subpage is erased. The nth subpage can be selected with\n"
15994  " pladv(n).\n"
15995  "\n"
15996  " Redacted form: General: plclear()\n"
15997  "\n"
15998  "\n"
15999  " This function is not used in any examples.\n"
16000  "\n"
16001  "\n"
16002  "\n"
16003  "SYNOPSIS:\n"
16004  "\n"
16005  "plclear()\n"
16006  "\n"
16007  ""},
16008  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
16009  "Set color, cmap0\n"
16010  "\n"
16011  "DESCRIPTION:\n"
16012  "\n"
16013  " Sets the color index for cmap0 (see the PLplot documentation).\n"
16014  "\n"
16015  " Redacted form: plcol0(icol0)\n"
16016  "\n"
16017  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16018  "\n"
16019  "\n"
16020  "\n"
16021  "SYNOPSIS:\n"
16022  "\n"
16023  "plcol0(icol0)\n"
16024  "\n"
16025  "ARGUMENTS:\n"
16026  "\n"
16027  " icol0 (PLINT, input) : Integer representing the color. The\n"
16028  " defaults at present are (these may change):\n"
16029  " 0 black (default background)\n"
16030  " 1 red (default foreground)\n"
16031  " 2 yellow\n"
16032  " 3 green\n"
16033  " 4 aquamarine\n"
16034  " 5 pink\n"
16035  " 6 wheat\n"
16036  " 7 grey\n"
16037  " 8 brown\n"
16038  " 9 blue\n"
16039  " 10 BlueViolet\n"
16040  " 11 cyan\n"
16041  " 12 turquoise\n"
16042  " 13 magenta\n"
16043  " 14 salmon\n"
16044  " 15 white\n"
16045  "\n"
16046  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16047  " change an individual color in the cmap0 color palette.\n"
16048  "\n"
16049  ""},
16050  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
16051  "Set color, cmap1\n"
16052  "\n"
16053  "DESCRIPTION:\n"
16054  "\n"
16055  " Sets the color for cmap1 (see the PLplot documentation).\n"
16056  "\n"
16057  " Redacted form: plcol1(col1)\n"
16058  "\n"
16059  " This function is used in examples 12 and 21.\n"
16060  "\n"
16061  "\n"
16062  "\n"
16063  "SYNOPSIS:\n"
16064  "\n"
16065  "plcol1(col1)\n"
16066  "\n"
16067  "ARGUMENTS:\n"
16068  "\n"
16069  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16070  " is mapped to color using the continuous cmap1 palette which by\n"
16071  " default ranges from blue to the background color to red. The\n"
16072  " cmap1 palette can also be straightforwardly changed by the user\n"
16073  " with plscmap1 or plscmap1l.\n"
16074  "\n"
16075  ""},
16076  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
16077  "Configure the transformation between continuous and broken-down time for the current stream\n"
16078  "\n"
16079  "DESCRIPTION:\n"
16080  "\n"
16081  " Configure the transformation between continuous and broken-down time\n"
16082  " for the current stream. This transformation is used by both plbtime\n"
16083  " and plctime.\n"
16084  "\n"
16085  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16086  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16087  "\n"
16088  "\n"
16089  " This function is used in example 29.\n"
16090  "\n"
16091  "\n"
16092  "\n"
16093  "SYNOPSIS:\n"
16094  "\n"
16095  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16096  "\n"
16097  "ARGUMENTS:\n"
16098  "\n"
16099  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16100  " As a special case, if\n"
16101  " scale is 0., then all other arguments are ignored, and the result (the\n"
16102  " default used by PLplot) is the equivalent of a call to\n"
16103  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16104  " That is, for this special case broken-down time is calculated with\n"
16105  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16106  " and the continuous time is defined as the number of seconds since\n"
16107  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16108  "\n"
16109  " offset1 (PLFLT, input) : If\n"
16110  " ifbtime_offset is true, the parameters\n"
16111  " offset1 and\n"
16112  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16113  " (with units in days) specify the epoch of the continuous time\n"
16114  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16115  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16116  " are used to specify the origin to allow users (by specifying\n"
16117  " offset1 as an integer that can be exactly represented by a\n"
16118  " floating-point variable and specifying\n"
16119  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16120  " the numerical errors of the continuous time representation.\n"
16121  "\n"
16122  " offset2 (PLFLT, input) : See documentation of\n"
16123  " offset1.\n"
16124  "\n"
16125  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16126  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16127  " calendar is used for broken-down time rather than the proleptic\n"
16128  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16129  " have been historically used to define UTC are inserted into the\n"
16130  " broken-down time. Other possibilities for additional control bits\n"
16131  " for ccontrol exist such as making the historical time corrections\n"
16132  " in the broken-down time corresponding to ET (ephemeris time) or\n"
16133  " making the (slightly non-constant) corrections from international\n"
16134  " atomic time (TAI) to what astronomers define as terrestrial time\n"
16135  " (TT). But those additional possibilities have not been\n"
16136  " implemented yet in the qsastime library (one of the PLplot utility\n"
16137  " libraries).\n"
16138  "\n"
16139  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16140  " epoch of the continuous time scale is specified by the user. If\n"
16141  " ifbtime_offset is false, then\n"
16142  " offset1 and\n"
16143  " offset2 are used to specify the epoch, and the following broken-down\n"
16144  " time parameters are completely ignored. If\n"
16145  " ifbtime_offset is true, then\n"
16146  " offset1 and\n"
16147  " offset2 are completely ignored, and the following broken-down time\n"
16148  " parameters are used to specify the epoch.\n"
16149  "\n"
16150  " year (PLINT, input) : Year of epoch.\n"
16151  "\n"
16152  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16153  " 11 (December).\n"
16154  "\n"
16155  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16156  "\n"
16157  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16158  "\n"
16159  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16160  "\n"
16161  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16162  "\n"
16163  ""},
16164  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
16165  "Contour plot\n"
16166  "\n"
16167  "DESCRIPTION:\n"
16168  "\n"
16169  " Draws a contour plot of the data in f[\n"
16170  " nx][\n"
16171  " ny], using the nlevel contour levels specified by clevel. Only the\n"
16172  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16173  " where all these index ranges are interpreted as one-based for\n"
16174  " historical reasons. A transformation routine pointed to by pltr with\n"
16175  " a generic pointer pltr_data for additional data required by the\n"
16176  " transformation routine is used to map indices within the matrix to the\n"
16177  " world coordinates.\n"
16178  "\n"
16179  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16180  " where (see above discussion) the pltr, pltr_data callback arguments\n"
16181  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16182  " vectors; or xg and yg matrices.\n"
16183  "\n"
16184  " This function is used in examples 9, 14, 16, and 22.\n"
16185  "\n"
16186  "\n"
16187  "\n"
16188  "SYNOPSIS:\n"
16189  "\n"
16190  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16191  "\n"
16192  "ARGUMENTS:\n"
16193  "\n"
16194  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16195  "\n"
16196  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16197  "\n"
16198  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16199  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16200  " zero-based for historical backwards-compatibility reasons.\n"
16201  "\n"
16202  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16203  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16204  " zero-based for historical backwards-compatibility reasons.\n"
16205  "\n"
16206  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16207  " which to draw contours.\n"
16208  "\n"
16209  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16210  "\n"
16211  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16212  " defines the transformation between the zero-based indices of the\n"
16213  " matrix f and the world coordinates.For the C case, transformation\n"
16214  " functions are provided in the PLplot library: pltr0 for the\n"
16215  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16216  " respectively defined by vectors and matrices. In addition, C\n"
16217  " callback routines for the transformation can be supplied by the\n"
16218  " user such as the mypltr function in examples/c/x09c.c which\n"
16219  " provides a general linear transformation between index coordinates\n"
16220  " and world coordinates.For languages other than C you should\n"
16221  " consult the PLplot documentation for the details concerning how\n"
16222  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16223  " general, a particular pattern of callback-associated arguments\n"
16224  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16225  " yg matrices are respectively interfaced to a linear-transformation\n"
16226  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16227  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16228  " the PLplot documentation) support native language callbacks for\n"
16229  " handling index to world-coordinate transformations. Examples of\n"
16230  " these various approaches are given in examples/<language>x09*,\n"
16231  " examples/<language>x16*, examples/<language>x20*,\n"
16232  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16233  " supported languages.\n"
16234  "\n"
16235  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16236  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16237  " that is externally supplied.\n"
16238  "\n"
16239  ""},
16240  { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
16241  "Calculate continuous time from broken-down time for the current stream\n"
16242  "\n"
16243  "DESCRIPTION:\n"
16244  "\n"
16245  " Calculate continuous time, ctime, from broken-down time for the\n"
16246  " current stream. The broken-down\n"
16247  " time is specified by the following parameters: year, month, day, hour,\n"
16248  " min, and sec. This function is the inverse of plbtime.\n"
16249  "\n"
16250  " The PLplot definition of broken-down time is a calendar time that\n"
16251  " completely ignores all time zone offsets, i.e., it is the user's\n"
16252  " responsibility to apply those offsets (if so desired) before using the\n"
16253  " PLplot time API. By default broken-down time is defined using the\n"
16254  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16255  " continuous time is defined as the number of seconds since the Unix\n"
16256  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16257  " broken-down and continuous time are possible, see plconfigtime which\n"
16258  " specifies that transformation for the current stream.\n"
16259  "\n"
16260  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16261  " ctime)\n"
16262  "\n"
16263  "\n"
16264  " This function is used in example 29.\n"
16265  "\n"
16266  "\n"
16267  "\n"
16268  "SYNOPSIS:\n"
16269  "\n"
16270  "plctime(year, month, day, hour, min, sec, ctime)\n"
16271  "\n"
16272  "ARGUMENTS:\n"
16273  "\n"
16274  " year (PLINT, input) : Input year.\n"
16275  "\n"
16276  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16277  " (December).\n"
16278  "\n"
16279  " day (PLINT, input) : Input day in range from 1 to 31.\n"
16280  "\n"
16281  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16282  "\n"
16283  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16284  "\n"
16285  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16286  "\n"
16287  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16288  " time calculated from the broken-down time specified by the\n"
16289  " previous parameters.\n"
16290  "\n"
16291  ""},
16292  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
16293  "Copy state parameters from the reference stream to the current stream\n"
16294  "\n"
16295  "DESCRIPTION:\n"
16296  "\n"
16297  " Copies state parameters from the reference stream to the current\n"
16298  " stream. Tell driver interface to map device coordinates unless flags\n"
16299  " == 1.\n"
16300  "\n"
16301  " This function is used for making save files of selected plots (e.g.\n"
16302  " from the TK driver). After initializing, you can get a copy of the\n"
16303  " current plot to the specified device by switching to this stream and\n"
16304  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16305  " appropriate. The plot buffer must have previously been enabled (done\n"
16306  " automatically by some display drivers, such as X).\n"
16307  "\n"
16308  " Redacted form: plcpstrm(iplsr, flags)\n"
16309  "\n"
16310  " This function is used in example 1,20.\n"
16311  "\n"
16312  "\n"
16313  "\n"
16314  "SYNOPSIS:\n"
16315  "\n"
16316  "plcpstrm(iplsr, flags)\n"
16317  "\n"
16318  "ARGUMENTS:\n"
16319  "\n"
16320  " iplsr (PLINT, input) : Number of reference stream.\n"
16321  "\n"
16322  " flags (PLBOOL, input) : If flags is set to true the device\n"
16323  " coordinates are not copied from the reference to current stream.\n"
16324  "\n"
16325  ""},
16326  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
16327  "End plotting session\n"
16328  "\n"
16329  "DESCRIPTION:\n"
16330  "\n"
16331  " Ends a plotting session, tidies up all the output files, switches\n"
16332  " interactive devices back into text mode and frees up any memory that\n"
16333  " was allocated. Must be called before end of program.\n"
16334  "\n"
16335  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16336  " wait state after a call to plend or other functions which trigger the\n"
16337  " end of a plot page. To avoid this, use the plspause function.\n"
16338  "\n"
16339  " Redacted form: plend()\n"
16340  "\n"
16341  " This function is used in all of the examples.\n"
16342  "\n"
16343  "\n"
16344  "\n"
16345  "SYNOPSIS:\n"
16346  "\n"
16347  "plend()\n"
16348  "\n"
16349  ""},
16350  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
16351  "End plotting session for current stream\n"
16352  "\n"
16353  "DESCRIPTION:\n"
16354  "\n"
16355  " Ends a plotting session for the current output stream only. See\n"
16356  " plsstrm for more info.\n"
16357  "\n"
16358  " Redacted form: plend1()\n"
16359  "\n"
16360  " This function is used in examples 1 and 20.\n"
16361  "\n"
16362  "\n"
16363  "\n"
16364  "SYNOPSIS:\n"
16365  "\n"
16366  "plend1()\n"
16367  "\n"
16368  ""},
16369  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
16370  "Set up standard window and draw box\n"
16371  "\n"
16372  "DESCRIPTION:\n"
16373  "\n"
16374  " Sets up plotter environment for simple graphs by calling pladv and\n"
16375  " setting up viewport and window to sensible default values. plenv\n"
16376  " leaves a standard margin (left-hand margin of eight character heights,\n"
16377  " and a margin around the other three sides of five character heights)\n"
16378  " around most graphs for axis labels and a title. When these defaults\n"
16379  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16380  " plvasp for setting up the viewport, plwind for defining the window,\n"
16381  " and plbox for drawing the box.\n"
16382  "\n"
16383  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16384  "\n"
16385  " This function is used in example 1,3,9,13,14,19-22,29.\n"
16386  "\n"
16387  "\n"
16388  "\n"
16389  "SYNOPSIS:\n"
16390  "\n"
16391  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16392  "\n"
16393  "ARGUMENTS:\n"
16394  "\n"
16395  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16396  " world coordinates).\n"
16397  "\n"
16398  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16399  " world coordinates).\n"
16400  "\n"
16401  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16402  " coordinates).\n"
16403  "\n"
16404  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16405  " coordinates).\n"
16406  "\n"
16407  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16408  " scales will not be set, the user must set up the scale before\n"
16409  " calling plenv using plsvpa, plvasp or other.\n"
16410  " 0: the x and y axes are scaled independently to use as much of\n"
16411  " the screen as possible.\n"
16412  " 1: the scales of the x and y axes are made equal.\n"
16413  " 2: the axis of the x and y axes are made equal, and the plot\n"
16414  " box will be square.\n"
16415  "\n"
16416  "\n"
16417  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16418  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16419  " -1: draw box only.\n"
16420  " 0: draw box, ticks, and numeric tick labels.\n"
16421  " 1: also draw coordinate axes at x=0 and y=0.\n"
16422  " 2: also draw a grid at major tick positions in both\n"
16423  " coordinates.\n"
16424  " 3: also draw a grid at minor tick positions in both\n"
16425  " coordinates.\n"
16426  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16427  " have to be converted to logarithms separately.)\n"
16428  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16429  " have to be converted to logarithms separately.)\n"
16430  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16431  " have to be converted to logarithms separately.)\n"
16432  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16433  " have to be converted to logarithms separately.)\n"
16434  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16435  " have to be converted to logarithms separately.)\n"
16436  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16437  " have to be converted to logarithms separately.)\n"
16438  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16439  " have to be converted to logarithms separately.)\n"
16440  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16441  " have to be converted to logarithms separately.)\n"
16442  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16443  " and y data have to be converted to logarithms separately.)\n"
16444  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16445  " and y data have to be converted to logarithms separately.)\n"
16446  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16447  " and y data have to be converted to logarithms separately.)\n"
16448  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16449  " and y data have to be converted to logarithms separately.)\n"
16450  " 40: same as 0 except date / time x labels.\n"
16451  " 41: same as 1 except date / time x labels.\n"
16452  " 42: same as 2 except date / time x labels.\n"
16453  " 43: same as 3 except date / time x labels.\n"
16454  " 50: same as 0 except date / time y labels.\n"
16455  " 51: same as 1 except date / time y labels.\n"
16456  " 52: same as 2 except date / time y labels.\n"
16457  " 53: same as 3 except date / time y labels.\n"
16458  " 60: same as 0 except date / time x and y labels.\n"
16459  " 61: same as 1 except date / time x and y labels.\n"
16460  " 62: same as 2 except date / time x and y labels.\n"
16461  " 63: same as 3 except date / time x and y labels.\n"
16462  " 70: same as 0 except custom x and y labels.\n"
16463  " 71: same as 1 except custom x and y labels.\n"
16464  " 72: same as 2 except custom x and y labels.\n"
16465  " 73: same as 3 except custom x and y labels.\n"
16466  "\n"
16467  ""},
16468  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
16469  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16470  "\n"
16471  "DESCRIPTION:\n"
16472  "\n"
16473  " Sets up plotter environment for simple graphs by calling pladv and\n"
16474  " setting up viewport and window to sensible default values. plenv0\n"
16475  " leaves a standard margin (left-hand margin of eight character heights,\n"
16476  " and a margin around the other three sides of five character heights)\n"
16477  " around most graphs for axis labels and a title. When these defaults\n"
16478  " are not suitable, use the individual routines plvpas, plvpor, or\n"
16479  " plvasp for setting up the viewport, plwind for defining the window,\n"
16480  " and plbox for drawing the box.\n"
16481  "\n"
16482  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16483  "\n"
16484  " This function is used in example 21.\n"
16485  "\n"
16486  "\n"
16487  "\n"
16488  "SYNOPSIS:\n"
16489  "\n"
16490  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16491  "\n"
16492  "ARGUMENTS:\n"
16493  "\n"
16494  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16495  " world coordinates).\n"
16496  "\n"
16497  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16498  " world coordinates).\n"
16499  "\n"
16500  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16501  " coordinates).\n"
16502  "\n"
16503  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16504  " coordinates).\n"
16505  "\n"
16506  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16507  " scales will not be set, the user must set up the scale before\n"
16508  " calling plenv0 using plsvpa, plvasp or other.\n"
16509  " 0: the x and y axes are scaled independently to use as much of\n"
16510  " the screen as possible.\n"
16511  " 1: the scales of the x and y axes are made equal.\n"
16512  " 2: the axis of the x and y axes are made equal, and the plot\n"
16513  " box will be square.\n"
16514  "\n"
16515  "\n"
16516  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16517  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16518  " -1: draw box only.\n"
16519  " 0: draw box, ticks, and numeric tick labels.\n"
16520  " 1: also draw coordinate axes at x=0 and y=0.\n"
16521  " 2: also draw a grid at major tick positions in both\n"
16522  " coordinates.\n"
16523  " 3: also draw a grid at minor tick positions in both\n"
16524  " coordinates.\n"
16525  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16526  " have to be converted to logarithms separately.)\n"
16527  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16528  " have to be converted to logarithms separately.)\n"
16529  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16530  " have to be converted to logarithms separately.)\n"
16531  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16532  " have to be converted to logarithms separately.)\n"
16533  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16534  " have to be converted to logarithms separately.)\n"
16535  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16536  " have to be converted to logarithms separately.)\n"
16537  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16538  " have to be converted to logarithms separately.)\n"
16539  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16540  " have to be converted to logarithms separately.)\n"
16541  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16542  " and y data have to be converted to logarithms separately.)\n"
16543  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16544  " and y data have to be converted to logarithms separately.)\n"
16545  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16546  " and y data have to be converted to logarithms separately.)\n"
16547  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16548  " and y data have to be converted to logarithms separately.)\n"
16549  " 40: same as 0 except date / time x labels.\n"
16550  " 41: same as 1 except date / time x labels.\n"
16551  " 42: same as 2 except date / time x labels.\n"
16552  " 43: same as 3 except date / time x labels.\n"
16553  " 50: same as 0 except date / time y labels.\n"
16554  " 51: same as 1 except date / time y labels.\n"
16555  " 52: same as 2 except date / time y labels.\n"
16556  " 53: same as 3 except date / time y labels.\n"
16557  " 60: same as 0 except date / time x and y labels.\n"
16558  " 61: same as 1 except date / time x and y labels.\n"
16559  " 62: same as 2 except date / time x and y labels.\n"
16560  " 63: same as 3 except date / time x and y labels.\n"
16561  " 70: same as 0 except custom x and y labels.\n"
16562  " 71: same as 1 except custom x and y labels.\n"
16563  " 72: same as 2 except custom x and y labels.\n"
16564  " 73: same as 3 except custom x and y labels.\n"
16565  "\n"
16566  ""},
16567  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
16568  "Eject current page\n"
16569  "\n"
16570  "DESCRIPTION:\n"
16571  "\n"
16572  " Clears the graphics screen of an interactive device, or ejects a page\n"
16573  " on a plotter. See plbop for more information.\n"
16574  "\n"
16575  " Redacted form: pleop()\n"
16576  "\n"
16577  " This function is used in example 2,14.\n"
16578  "\n"
16579  "\n"
16580  "\n"
16581  "SYNOPSIS:\n"
16582  "\n"
16583  "pleop()\n"
16584  "\n"
16585  ""},
16586  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
16587  "Draw error bars in x direction\n"
16588  "\n"
16589  "DESCRIPTION:\n"
16590  "\n"
16591  " Draws a set of n error bars in x direction, the i'th error bar\n"
16592  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16593  " of the error bars are of length equal to the minor tick length\n"
16594  " (settable using plsmin).\n"
16595  "\n"
16596  " Redacted form: General: plerrx(xmin, ymax, y)\n"
16597  "\n"
16598  "\n"
16599  " This function is used in example 29.\n"
16600  "\n"
16601  "\n"
16602  "\n"
16603  "SYNOPSIS:\n"
16604  "\n"
16605  "plerrx(n, xmin, xmax, y)\n"
16606  "\n"
16607  "ARGUMENTS:\n"
16608  "\n"
16609  " n (PLINT, input) : Number of error bars to draw.\n"
16610  "\n"
16611  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16612  " of the left-hand endpoints of the error bars.\n"
16613  "\n"
16614  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16615  " of the right-hand endpoints of the error bars.\n"
16616  "\n"
16617  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16618  " the error bars.\n"
16619  "\n"
16620  ""},
16621  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
16622  "Draw error bars in the y direction\n"
16623  "\n"
16624  "DESCRIPTION:\n"
16625  "\n"
16626  " Draws a set of n error bars in the y direction, the i'th error bar\n"
16627  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16628  " of the error bars are of length equal to the minor tick length\n"
16629  " (settable using plsmin).\n"
16630  "\n"
16631  " Redacted form: General: plerry(x, ymin, ymax)\n"
16632  "\n"
16633  "\n"
16634  " This function is used in example 29.\n"
16635  "\n"
16636  "\n"
16637  "\n"
16638  "SYNOPSIS:\n"
16639  "\n"
16640  "plerry(n, x, ymin, ymax)\n"
16641  "\n"
16642  "ARGUMENTS:\n"
16643  "\n"
16644  " n (PLINT, input) : Number of error bars to draw.\n"
16645  "\n"
16646  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16647  " the error bars.\n"
16648  "\n"
16649  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16650  " of the lower endpoints of the error bars.\n"
16651  "\n"
16652  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16653  " of the upper endpoints of the error bars.\n"
16654  "\n"
16655  ""},
16656  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16657  "Advance to the next family file on the next new page\n"
16658  "\n"
16659  "DESCRIPTION:\n"
16660  "\n"
16661  " Advance to the next family file on the next new page.\n"
16662  "\n"
16663  " Redacted form: plfamadv()\n"
16664  "\n"
16665  " This function is not used in any examples.\n"
16666  "\n"
16667  "\n"
16668  "\n"
16669  "SYNOPSIS:\n"
16670  "\n"
16671  "plfamadv()\n"
16672  "\n"
16673  ""},
16674  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16675  "Draw filled polygon\n"
16676  "\n"
16677  "DESCRIPTION:\n"
16678  "\n"
16679  " Fills the polygon defined by the n points (\n"
16680  " x[i],\n"
16681  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16682  " style is a solid fill. The routine will automatically close the\n"
16683  " polygon between the last and first vertices. If multiple closed\n"
16684  " polygons are passed in x and y then plfill will fill in between them.\n"
16685  "\n"
16686  " Redacted form: plfill(x,y)\n"
16687  "\n"
16688  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16689  "\n"
16690  "\n"
16691  "\n"
16692  "SYNOPSIS:\n"
16693  "\n"
16694  "plfill(n, x, y)\n"
16695  "\n"
16696  "ARGUMENTS:\n"
16697  "\n"
16698  " n (PLINT, input) : Number of vertices in polygon.\n"
16699  "\n"
16700  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16701  " vertices.\n"
16702  "\n"
16703  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16704  " vertices.\n"
16705  "\n"
16706  ""},
16707  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16708  "Draw filled polygon in 3D\n"
16709  "\n"
16710  "DESCRIPTION:\n"
16711  "\n"
16712  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16713  " vectors using the pattern defined by plpsty or plpat. The routine\n"
16714  " will automatically close the polygon between the last and first\n"
16715  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16716  " plfill3 will fill in between them.\n"
16717  "\n"
16718  " Redacted form: General: plfill3(x, y, z)\n"
16719  "\n"
16720  "\n"
16721  " This function is used in example 15.\n"
16722  "\n"
16723  "\n"
16724  "\n"
16725  "SYNOPSIS:\n"
16726  "\n"
16727  "plfill3(n, x, y, z)\n"
16728  "\n"
16729  "ARGUMENTS:\n"
16730  "\n"
16731  " n (PLINT, input) : Number of vertices in polygon.\n"
16732  "\n"
16733  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16734  " vertices.\n"
16735  "\n"
16736  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16737  " vertices.\n"
16738  "\n"
16739  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16740  " vertices.\n"
16741  "\n"
16742  ""},
16743  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16744  "Draw linear gradient inside polygon\n"
16745  "\n"
16746  "DESCRIPTION:\n"
16747  "\n"
16748  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16749  " points (\n"
16750  " x[i],\n"
16751  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16752  " polygon coordinates and the gradient angle are all expressed in world\n"
16753  " coordinates. The angle from the x axis for both the rotated\n"
16754  " coordinate system and the gradient vector is specified by angle. The\n"
16755  " magnitude of the gradient vector is the difference between the maximum\n"
16756  " and minimum values of x for the vertices in the rotated coordinate\n"
16757  " system. The origin of the gradient vector can be interpreted as being\n"
16758  " anywhere on the line corresponding to the minimum x value for the\n"
16759  " vertices in the rotated coordinate system. The distance along the\n"
16760  " gradient vector is linearly transformed to the independent variable of\n"
16761  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16762  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16763  " color corresponding to the independent variable of cmap1. For more\n"
16764  " information about cmap1 (see the PLplot documentation).\n"
16765  "\n"
16766  " Redacted form: plgradient(x,y,angle)\n"
16767  "\n"
16768  " This function is used in examples 25 and 30.\n"
16769  "\n"
16770  "\n"
16771  "\n"
16772  "SYNOPSIS:\n"
16773  "\n"
16774  "plgradient(n, x, y, angle)\n"
16775  "\n"
16776  "ARGUMENTS:\n"
16777  "\n"
16778  " n (PLINT, input) : Number of vertices in polygon.\n"
16779  "\n"
16780  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16781  " vertices.\n"
16782  "\n"
16783  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16784  " vertices.\n"
16785  "\n"
16786  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16787  " axis.\n"
16788  "\n"
16789  ""},
16790  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16791  "Flushes the output stream\n"
16792  "\n"
16793  "DESCRIPTION:\n"
16794  "\n"
16795  " Flushes the output stream. Use sparingly, if at all.\n"
16796  "\n"
16797  " Redacted form: plflush()\n"
16798  "\n"
16799  " This function is used in examples 1 and 14.\n"
16800  "\n"
16801  "\n"
16802  "\n"
16803  "SYNOPSIS:\n"
16804  "\n"
16805  "plflush()\n"
16806  "\n"
16807  ""},
16808  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16809  "Set font\n"
16810  "\n"
16811  "DESCRIPTION:\n"
16812  "\n"
16813  " Sets the font used for subsequent text and symbols. For devices that\n"
16814  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16815  " fonts with extended character set are loaded (see plfontld). For\n"
16816  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16817  " this routine calls the plsfci routine with argument set up\n"
16818  " appropriately for the various cases below. However, this method of\n"
16819  " specifying the font for unicode-aware devices is deprecated, and the\n"
16820  " much more flexible method of calling plsfont directly is recommended\n"
16821  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16822  "\n"
16823  " Redacted form: plfont(ifont)\n"
16824  "\n"
16825  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16826  "\n"
16827  "\n"
16828  "\n"
16829  "SYNOPSIS:\n"
16830  "\n"
16831  "plfont(ifont)\n"
16832  "\n"
16833  "ARGUMENTS:\n"
16834  "\n"
16835  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16836  " (simplest and fastest)\n"
16837  " 2: Serif font\n"
16838  " 3: Italic font\n"
16839  " 4: Script font\n"
16840  "\n"
16841  ""},
16842  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16843  "Load Hershey fonts\n"
16844  "\n"
16845  "DESCRIPTION:\n"
16846  "\n"
16847  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16848  " be called before or after initializing PLplot. If not explicitly\n"
16849  " called before PLplot initialization, then by default that\n"
16850  " initialization loads Hershey fonts with the extended character set.\n"
16851  " This routine only has a practical effect for devices that still use\n"
16852  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16853  " system fonts instead of Hershey fonts).\n"
16854  "\n"
16855  " Redacted form: plfontld(fnt)\n"
16856  "\n"
16857  " This function is used in examples 1 and 7.\n"
16858  "\n"
16859  "\n"
16860  "\n"
16861  "SYNOPSIS:\n"
16862  "\n"
16863  "plfontld(fnt)\n"
16864  "\n"
16865  "ARGUMENTS:\n"
16866  "\n"
16867  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16868  " A zero value specifies Hershey fonts with the standard character\n"
16869  " set and a non-zero value (the default assumed if plfontld is never\n"
16870  " called) specifies Hershey fonts with the extended character set.\n"
16871  "\n"
16872  ""},
16873  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16874  "Get character default height and current (scaled) height\n"
16875  "\n"
16876  "DESCRIPTION:\n"
16877  "\n"
16878  " Get character default height and current (scaled) height.\n"
16879  "\n"
16880  " Redacted form: plgchr(p_def, p_ht)\n"
16881  "\n"
16882  " This function is used in example 23.\n"
16883  "\n"
16884  "\n"
16885  "\n"
16886  "SYNOPSIS:\n"
16887  "\n"
16888  "plgchr(p_def, p_ht)\n"
16889  "\n"
16890  "ARGUMENTS:\n"
16891  "\n"
16892  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16893  " character height (mm).\n"
16894  "\n"
16895  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16896  " character height (mm).\n"
16897  "\n"
16898  ""},
16899  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16900  "Returns 8-bit RGB values for given color index from cmap0\n"
16901  "\n"
16902  "DESCRIPTION:\n"
16903  "\n"
16904  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16905  " PLplot documentation). Values are negative if an invalid color id is\n"
16906  " given.\n"
16907  "\n"
16908  " Redacted form: plgcol0(icol0, r, g, b)\n"
16909  "\n"
16910  " This function is used in example 2.\n"
16911  "\n"
16912  "\n"
16913  "\n"
16914  "SYNOPSIS:\n"
16915  "\n"
16916  "plgcol0(icol0, r, g, b)\n"
16917  "\n"
16918  "ARGUMENTS:\n"
16919  "\n"
16920  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16921  "\n"
16922  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16923  " value.\n"
16924  "\n"
16925  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16926  " value.\n"
16927  "\n"
16928  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16929  " value.\n"
16930  "\n"
16931  ""},
16932  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16933  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16934  "\n"
16935  "DESCRIPTION:\n"
16936  "\n"
16937  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16938  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16939  " Values are negative if an invalid color id is given.\n"
16940  "\n"
16941  " Redacted form: plgcola(r, g, b)\n"
16942  "\n"
16943  " This function is used in example 30.\n"
16944  "\n"
16945  "\n"
16946  "\n"
16947  "SYNOPSIS:\n"
16948  "\n"
16949  "plgcol0a(icol0, r, g, b, alpha)\n"
16950  "\n"
16951  "ARGUMENTS:\n"
16952  "\n"
16953  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16954  "\n"
16955  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16956  " in the range from 0 to 255.\n"
16957  "\n"
16958  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16959  " in the range from 0 to 255.\n"
16960  "\n"
16961  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16962  " in the range from 0 to 255.\n"
16963  "\n"
16964  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16965  " transparency in the range from (0.0-1.0).\n"
16966  "\n"
16967  ""},
16968  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16969  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16970  "\n"
16971  "DESCRIPTION:\n"
16972  "\n"
16973  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16974  "\n"
16975  " Redacted form: plgcolbg(r, g, b)\n"
16976  "\n"
16977  " This function is used in example 31.\n"
16978  "\n"
16979  "\n"
16980  "\n"
16981  "SYNOPSIS:\n"
16982  "\n"
16983  "plgcolbg(r, g, b)\n"
16984  "\n"
16985  "ARGUMENTS:\n"
16986  "\n"
16987  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16988  " in the range from 0 to 255.\n"
16989  "\n"
16990  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16991  " in the range from 0 to 255.\n"
16992  "\n"
16993  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16994  " in the range from 0 to 255.\n"
16995  "\n"
16996  ""},
16997  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16998  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16999  "\n"
17000  "DESCRIPTION:\n"
17001  "\n"
17002  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17003  " alpha transparency value.\n"
17004  "\n"
17005  " This function is used in example 31.\n"
17006  "\n"
17007  "\n"
17008  "\n"
17009  "SYNOPSIS:\n"
17010  "\n"
17011  "plgcolbga(r, g, b, alpha)\n"
17012  "\n"
17013  "ARGUMENTS:\n"
17014  "\n"
17015  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17016  " in the range from 0 to 255.\n"
17017  "\n"
17018  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17019  " in the range from 0 to 255.\n"
17020  "\n"
17021  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17022  " in the range from 0 to 255.\n"
17023  "\n"
17024  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17025  " transparency in the range (0.0-1.0).\n"
17026  "\n"
17027  ""},
17028  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
17029  "Get the current device-compression setting\n"
17030  "\n"
17031  "DESCRIPTION:\n"
17032  "\n"
17033  " Get the current device-compression setting. This parameter is only\n"
17034  " used for drivers that provide compression.\n"
17035  "\n"
17036  " Redacted form: plgcompression(compression)\n"
17037  "\n"
17038  " This function is used in example 31.\n"
17039  "\n"
17040  "\n"
17041  "\n"
17042  "SYNOPSIS:\n"
17043  "\n"
17044  "plgcompression(compression)\n"
17045  "\n"
17046  "ARGUMENTS:\n"
17047  "\n"
17048  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17049  " compression setting for the current device.\n"
17050  "\n"
17051  ""},
17052  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
17053  "Get the current device (keyword) name\n"
17054  "\n"
17055  "DESCRIPTION:\n"
17056  "\n"
17057  " Get the current device (keyword) name. Note: you must have allocated\n"
17058  " space for this (80 characters is safe).\n"
17059  "\n"
17060  " Redacted form: plgdev(p_dev)\n"
17061  "\n"
17062  " This function is used in example 14.\n"
17063  "\n"
17064  "\n"
17065  "\n"
17066  "SYNOPSIS:\n"
17067  "\n"
17068  "plgdev(p_dev)\n"
17069  "\n"
17070  "ARGUMENTS:\n"
17071  "\n"
17072  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17073  " (with preallocated length of 80 characters or more) containing the\n"
17074  " device (keyword) name.\n"
17075  "\n"
17076  ""},
17077  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
17078  "Get parameters that define current device-space window\n"
17079  "\n"
17080  "DESCRIPTION:\n"
17081  "\n"
17082  " Get relative margin width, aspect ratio, and relative justification\n"
17083  " that define current device-space window. If plsdidev has not been\n"
17084  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17085  " p_jy will all be 0.\n"
17086  "\n"
17087  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17088  "\n"
17089  " This function is used in example 31.\n"
17090  "\n"
17091  "\n"
17092  "\n"
17093  "SYNOPSIS:\n"
17094  "\n"
17095  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17096  "\n"
17097  "ARGUMENTS:\n"
17098  "\n"
17099  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17100  " margin width.\n"
17101  "\n"
17102  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17103  " ratio.\n"
17104  "\n"
17105  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17106  " justification in x.\n"
17107  "\n"
17108  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17109  " justification in y.\n"
17110  "\n"
17111  ""},
17112  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
17113  "Get plot orientation\n"
17114  "\n"
17115  "DESCRIPTION:\n"
17116  "\n"
17117  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17118  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17119  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17120  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17121  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17122  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17123  " not been called the default value pointed to by p_rot will be 0.\n"
17124  "\n"
17125  " Redacted form: plgdiori(p_rot)\n"
17126  "\n"
17127  " This function is not used in any examples.\n"
17128  "\n"
17129  "\n"
17130  "\n"
17131  "SYNOPSIS:\n"
17132  "\n"
17133  "plgdiori(p_rot)\n"
17134  "\n"
17135  "ARGUMENTS:\n"
17136  "\n"
17137  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17138  " parameter.\n"
17139  "\n"
17140  ""},
17141  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
17142  "Get parameters that define current plot-space window\n"
17143  "\n"
17144  "DESCRIPTION:\n"
17145  "\n"
17146  " Get relative minima and maxima that define current plot-space window.\n"
17147  " If plsdiplt has not been called the default values pointed to by\n"
17148  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17149  "\n"
17150  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17151  "\n"
17152  " This function is used in example 31.\n"
17153  "\n"
17154  "\n"
17155  "\n"
17156  "SYNOPSIS:\n"
17157  "\n"
17158  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17159  "\n"
17160  "ARGUMENTS:\n"
17161  "\n"
17162  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17163  " minimum in x.\n"
17164  "\n"
17165  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17166  " minimum in y.\n"
17167  "\n"
17168  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17169  " maximum in x.\n"
17170  "\n"
17171  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17172  " maximum in y.\n"
17173  "\n"
17174  ""},
17175  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
17176  "Get family file parameters\n"
17177  "\n"
17178  "DESCRIPTION:\n"
17179  "\n"
17180  " Gets information about current family file, if familying is enabled.\n"
17181  " See the PLplot documentation for more information.\n"
17182  "\n"
17183  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17184  "\n"
17185  " This function is used in examples 14 and 31.\n"
17186  "\n"
17187  "\n"
17188  "\n"
17189  "SYNOPSIS:\n"
17190  "\n"
17191  "plgfam(p_fam, p_num, p_bmax)\n"
17192  "\n"
17193  "ARGUMENTS:\n"
17194  "\n"
17195  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17196  " family flag value. If nonzero, familying is enabled for the\n"
17197  " current device.\n"
17198  "\n"
17199  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17200  " family file number.\n"
17201  "\n"
17202  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17203  " file size (in bytes) for a family file.\n"
17204  "\n"
17205  ""},
17206  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
17207  "Get FCI (font characterization integer)\n"
17208  "\n"
17209  "DESCRIPTION:\n"
17210  "\n"
17211  " Gets information about the current font using the FCI approach. See\n"
17212  " the PLplot documentation for more information.\n"
17213  "\n"
17214  " Redacted form: plgfci(p_fci)\n"
17215  "\n"
17216  " This function is used in example 23.\n"
17217  "\n"
17218  "\n"
17219  "\n"
17220  "SYNOPSIS:\n"
17221  "\n"
17222  "plgfci(p_fci)\n"
17223  "\n"
17224  "ARGUMENTS:\n"
17225  "\n"
17226  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17227  " FCI value.\n"
17228  "\n"
17229  ""},
17230  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
17231  "Get output file name\n"
17232  "\n"
17233  "DESCRIPTION:\n"
17234  "\n"
17235  " Gets the current output file name, if applicable.\n"
17236  "\n"
17237  " Redacted form: plgfnam(fnam)\n"
17238  "\n"
17239  " This function is used in example 31.\n"
17240  "\n"
17241  "\n"
17242  "\n"
17243  "SYNOPSIS:\n"
17244  "\n"
17245  "plgfnam(fnam)\n"
17246  "\n"
17247  "ARGUMENTS:\n"
17248  "\n"
17249  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17250  " (with preallocated length of 80 characters or more) containing the\n"
17251  " file name.\n"
17252  "\n"
17253  ""},
17254  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
17255  "Get family, style and weight of the current font\n"
17256  "\n"
17257  "DESCRIPTION:\n"
17258  "\n"
17259  " Gets information about current font. See the PLplot documentation for\n"
17260  " more information on font selection.\n"
17261  "\n"
17262  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17263  "\n"
17264  " This function is used in example 23.\n"
17265  "\n"
17266  "\n"
17267  "\n"
17268  "SYNOPSIS:\n"
17269  "\n"
17270  "plgfont(p_family, p_style, p_weight)\n"
17271  "\n"
17272  "ARGUMENTS:\n"
17273  "\n"
17274  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17275  " font family. The available values are given by the PL_FCI_*\n"
17276  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17277  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17278  " p_family is NULL then the font family is not returned.\n"
17279  "\n"
17280  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17281  " font style. The available values are given by the PL_FCI_*\n"
17282  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17283  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17284  " style is not returned.\n"
17285  "\n"
17286  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17287  " font weight. The available values are given by the PL_FCI_*\n"
17288  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17289  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17290  " returned.\n"
17291  "\n"
17292  ""},
17293  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
17294  "Get the (current) run level\n"
17295  "\n"
17296  "DESCRIPTION:\n"
17297  "\n"
17298  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17299  " 1, initialized\n"
17300  " 2, viewport defined\n"
17301  " 3, world coordinates defined\n"
17302  "\n"
17303  "\n"
17304  " Redacted form: plglevel(p_level)\n"
17305  "\n"
17306  " This function is used in example 31.\n"
17307  "\n"
17308  "\n"
17309  "\n"
17310  "SYNOPSIS:\n"
17311  "\n"
17312  "plglevel(p_level)\n"
17313  "\n"
17314  "ARGUMENTS:\n"
17315  "\n"
17316  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17317  " level.\n"
17318  "\n"
17319  ""},
17320  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
17321  "Get page parameters\n"
17322  "\n"
17323  "DESCRIPTION:\n"
17324  "\n"
17325  " Gets the current page configuration. The length and offset values are\n"
17326  " expressed in units that are specific to the current driver. For\n"
17327  " instance: screen drivers will usually interpret them as number of\n"
17328  " pixels, whereas printer drivers will usually use mm.\n"
17329  "\n"
17330  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17331  "\n"
17332  " This function is used in examples 14 and 31.\n"
17333  "\n"
17334  "\n"
17335  "\n"
17336  "SYNOPSIS:\n"
17337  "\n"
17338  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17339  "\n"
17340  "ARGUMENTS:\n"
17341  "\n"
17342  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17343  " pixels/inch (DPI) in x.\n"
17344  "\n"
17345  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17346  " pixels/inch (DPI) in y.\n"
17347  "\n"
17348  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17349  " length.\n"
17350  "\n"
17351  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17352  " length.\n"
17353  "\n"
17354  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17355  " offset.\n"
17356  "\n"
17357  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17358  " offset.\n"
17359  "\n"
17360  ""},
17361  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
17362  "Switch to graphics screen\n"
17363  "\n"
17364  "DESCRIPTION:\n"
17365  "\n"
17366  " Sets an interactive device to graphics mode, used in conjunction with\n"
17367  " pltext to allow graphics and text to be interspersed. On a device\n"
17368  " which supports separate text and graphics windows, this command causes\n"
17369  " control to be switched to the graphics window. If already in graphics\n"
17370  " mode, this command is ignored. It is also ignored on devices which\n"
17371  " only support a single window or use a different method for shifting\n"
17372  " focus. See also pltext.\n"
17373  "\n"
17374  " Redacted form: plgra()\n"
17375  "\n"
17376  " This function is used in example 1.\n"
17377  "\n"
17378  "\n"
17379  "\n"
17380  "SYNOPSIS:\n"
17381  "\n"
17382  "plgra()\n"
17383  "\n"
17384  ""},
17385  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
17386  "Grid data from irregularly sampled data\n"
17387  "\n"
17388  "DESCRIPTION:\n"
17389  "\n"
17390  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17391  " require data organized as a grid, i.e., with x sample point values\n"
17392  " independent of y coordinate and vice versa. This function takes\n"
17393  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17394  " vectors; reads the desired grid location from the input vectors\n"
17395  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17396  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17397  " interpolate the data to the grid is specified with the argument type\n"
17398  " which can have one parameter specified in argument data.\n"
17399  "\n"
17400  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17401  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17402  "\n"
17403  "\n"
17404  " This function is used in example 21.\n"
17405  "\n"
17406  "\n"
17407  "\n"
17408  "SYNOPSIS:\n"
17409  "\n"
17410  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17411  "\n"
17412  "ARGUMENTS:\n"
17413  "\n"
17414  " x (PLFLT_VECTOR, input) : The input x vector.\n"
17415  "\n"
17416  " y (PLFLT_VECTOR, input) : The input y vector.\n"
17417  "\n"
17418  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17419  " y[i], z[i] represents one data sample coordinate.\n"
17420  "\n"
17421  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17422  " vectors.\n"
17423  "\n"
17424  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17425  " in the x direction. Usually xg has nptsx equally spaced values\n"
17426  " from the minimum to the maximum values of the x input vector.\n"
17427  "\n"
17428  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17429  "\n"
17430  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17431  " in the y direction. Similar to the xg parameter.\n"
17432  "\n"
17433  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17434  "\n"
17435  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17436  " where data lies in the grid specified by xg and yg. Therefore the\n"
17437  " zg matrix must be dimensioned\n"
17438  " nptsx by\n"
17439  " nptsy.\n"
17440  "\n"
17441  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17442  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17443  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17444  " GRID_NNI: Natural Neighbors Interpolation\n"
17445  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17446  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17447  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17448  " Weighted\n"
17449  " For details of the algorithms read the source file plgridd.c.\n"
17450  "\n"
17451  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17452  " which can be specified through this argument. Currently, for\n"
17453  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17454  " use, the lower the value, the noisier (more local) the\n"
17455  " approximation is.\n"
17456  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17457  " range [1. .. 2.]. High values enable the usage of very thin\n"
17458  " triangles for interpolation, possibly resulting in error in\n"
17459  " the approximation.\n"
17460  " GRID_NNI, only weights greater than data will be accepted. If\n"
17461  " 0, all weights will be accepted.\n"
17462  "\n"
17463  ""},
17464  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
17465  "Get current subpage parameters\n"
17466  "\n"
17467  "DESCRIPTION:\n"
17468  "\n"
17469  " Gets the size of the current subpage in millimeters measured from the\n"
17470  " bottom left hand corner of the output device page or screen. Can be\n"
17471  " used in conjunction with plsvpa for setting the size of a viewport in\n"
17472  " absolute coordinates (millimeters).\n"
17473  "\n"
17474  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17475  "\n"
17476  " This function is used in example 23.\n"
17477  "\n"
17478  "\n"
17479  "\n"
17480  "SYNOPSIS:\n"
17481  "\n"
17482  "plgspa(xmin, xmax, ymin, ymax)\n"
17483  "\n"
17484  "ARGUMENTS:\n"
17485  "\n"
17486  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17487  " the left hand edge of the subpage in millimeters.\n"
17488  "\n"
17489  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17490  " the right hand edge of the subpage in millimeters.\n"
17491  "\n"
17492  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17493  " the bottom edge of the subpage in millimeters.\n"
17494  "\n"
17495  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17496  " the top edge of the subpage in millimeters.\n"
17497  "\n"
17498  ""},
17499  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
17500  "Get current stream number\n"
17501  "\n"
17502  "DESCRIPTION:\n"
17503  "\n"
17504  " Gets the number of the current output stream. See also plsstrm.\n"
17505  "\n"
17506  " Redacted form: plgstrm(p_strm)\n"
17507  "\n"
17508  " This function is used in example 1,20.\n"
17509  "\n"
17510  "\n"
17511  "\n"
17512  "SYNOPSIS:\n"
17513  "\n"
17514  "plgstrm(p_strm)\n"
17515  "\n"
17516  "ARGUMENTS:\n"
17517  "\n"
17518  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17519  " stream value.\n"
17520  "\n"
17521  ""},
17522  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
17523  "Get the current library version number\n"
17524  "\n"
17525  "DESCRIPTION:\n"
17526  "\n"
17527  " Get the current library version number. Note: you must have allocated\n"
17528  " space for this (80 characters is safe).\n"
17529  "\n"
17530  " Redacted form: plgver(p_ver)\n"
17531  "\n"
17532  " This function is used in example 1.\n"
17533  "\n"
17534  "\n"
17535  "\n"
17536  "SYNOPSIS:\n"
17537  "\n"
17538  "plgver(p_ver)\n"
17539  "\n"
17540  "ARGUMENTS:\n"
17541  "\n"
17542  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17543  " (with preallocated length of 80 characters or more) containing the\n"
17544  " PLplot version number.\n"
17545  "\n"
17546  ""},
17547  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
17548  "Get viewport limits in normalized device coordinates\n"
17549  "\n"
17550  "DESCRIPTION:\n"
17551  "\n"
17552  " Get viewport limits in normalized device coordinates.\n"
17553  "\n"
17554  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17555  "\n"
17556  "\n"
17557  " This function is used in example 31.\n"
17558  "\n"
17559  "\n"
17560  "\n"
17561  "SYNOPSIS:\n"
17562  "\n"
17563  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17564  "\n"
17565  "ARGUMENTS:\n"
17566  "\n"
17567  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17568  " viewport limit of the normalized device coordinate in x.\n"
17569  "\n"
17570  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17571  " viewport limit of the normalized device coordinate in x.\n"
17572  "\n"
17573  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17574  " viewport limit of the normalized device coordinate in y.\n"
17575  "\n"
17576  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17577  " viewport limit of the normalized device coordinate in y.\n"
17578  "\n"
17579  ""},
17580  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
17581  "Get viewport limits in world coordinates\n"
17582  "\n"
17583  "DESCRIPTION:\n"
17584  "\n"
17585  " Get viewport limits in world coordinates.\n"
17586  "\n"
17587  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17588  "\n"
17589  "\n"
17590  " This function is used in example 31.\n"
17591  "\n"
17592  "\n"
17593  "\n"
17594  "SYNOPSIS:\n"
17595  "\n"
17596  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17597  "\n"
17598  "ARGUMENTS:\n"
17599  "\n"
17600  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17601  " viewport limit of the world coordinate in x.\n"
17602  "\n"
17603  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17604  " viewport limit of the world coordinate in x.\n"
17605  "\n"
17606  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17607  " viewport limit of the world coordinate in y.\n"
17608  "\n"
17609  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17610  " viewport limit of the world coordinate in y.\n"
17611  "\n"
17612  ""},
17613  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
17614  "Get x axis parameters\n"
17615  "\n"
17616  "DESCRIPTION:\n"
17617  "\n"
17618  " Returns current values of the p_digmax and p_digits flags for the x\n"
17619  " axis. p_digits is updated after the plot is drawn, so this routine\n"
17620  " should only be called after the call to plbox (or plbox3) is complete.\n"
17621  " See the PLplot documentation for more information.\n"
17622  "\n"
17623  " Redacted form: plgxax(p_digmax, p_digits)\n"
17624  "\n"
17625  " This function is used in example 31.\n"
17626  "\n"
17627  "\n"
17628  "\n"
17629  "SYNOPSIS:\n"
17630  "\n"
17631  "plgxax(p_digmax, p_digits)\n"
17632  "\n"
17633  "ARGUMENTS:\n"
17634  "\n"
17635  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17636  " number of digits for the x axis. If nonzero, the printed label\n"
17637  " has been switched to a floating-point representation when the\n"
17638  " number of digits exceeds this value.\n"
17639  "\n"
17640  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17641  " number of digits for the numeric labels (x axis) from the last\n"
17642  " plot.\n"
17643  "\n"
17644  ""},
17645  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
17646  "Get y axis parameters\n"
17647  "\n"
17648  "DESCRIPTION:\n"
17649  "\n"
17650  " Identical to plgxax, except that arguments are flags for y axis. See\n"
17651  " the description of plgxax for more detail.\n"
17652  "\n"
17653  " Redacted form: plgyax(p_digmax, p_digits)\n"
17654  "\n"
17655  " This function is used in example 31.\n"
17656  "\n"
17657  "\n"
17658  "\n"
17659  "SYNOPSIS:\n"
17660  "\n"
17661  "plgyax(p_digmax, p_digits)\n"
17662  "\n"
17663  "ARGUMENTS:\n"
17664  "\n"
17665  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17666  " number of digits for the y axis. If nonzero, the printed label\n"
17667  " has been switched to a floating-point representation when the\n"
17668  " number of digits exceeds this value.\n"
17669  "\n"
17670  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17671  " number of digits for the numeric labels (y axis) from the last\n"
17672  " plot.\n"
17673  "\n"
17674  ""},
17675  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
17676  "Get z axis parameters\n"
17677  "\n"
17678  "DESCRIPTION:\n"
17679  "\n"
17680  " Identical to plgxax, except that arguments are flags for z axis. See\n"
17681  " the description of plgxax for more detail.\n"
17682  "\n"
17683  " Redacted form: plgzax(p_digmax, p_digits)\n"
17684  "\n"
17685  " This function is used in example 31.\n"
17686  "\n"
17687  "\n"
17688  "\n"
17689  "SYNOPSIS:\n"
17690  "\n"
17691  "plgzax(p_digmax, p_digits)\n"
17692  "\n"
17693  "ARGUMENTS:\n"
17694  "\n"
17695  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17696  " number of digits for the z axis. If nonzero, the printed label\n"
17697  " has been switched to a floating-point representation when the\n"
17698  " number of digits exceeds this value.\n"
17699  "\n"
17700  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17701  " number of digits for the numeric labels (z axis) from the last\n"
17702  " plot.\n"
17703  "\n"
17704  ""},
17705  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17706  "Plot a histogram from unbinned data\n"
17707  "\n"
17708  "DESCRIPTION:\n"
17709  "\n"
17710  " Plots a histogram from n data points stored in the data vector. This\n"
17711  " routine bins the data into nbin bins equally spaced between datmin and\n"
17712  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17713  " opt allows, among other things, the histogram either to be plotted in\n"
17714  " an existing window or causes plhist to call plenv with suitable limits\n"
17715  " before plotting the histogram.\n"
17716  "\n"
17717  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17718  "\n"
17719  " This function is used in example 5.\n"
17720  "\n"
17721  "\n"
17722  "\n"
17723  "SYNOPSIS:\n"
17724  "\n"
17725  "plhist(n, data, datmin, datmax, nbin, opt)\n"
17726  "\n"
17727  "ARGUMENTS:\n"
17728  "\n"
17729  " n (PLINT, input) : Number of data points.\n"
17730  "\n"
17731  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17732  " n data points.\n"
17733  "\n"
17734  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17735  "\n"
17736  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17737  "\n"
17738  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17739  " divide the interval xmin to xmax.\n"
17740  "\n"
17741  " opt (PLINT, input) : Is a combination of several flags:\n"
17742  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17743  " the histogram data, the outer bins are expanded to fill up the\n"
17744  " entire x-axis, data outside the given extremes are assigned to the\n"
17745  " outer bins and bins of zero height are simply drawn.\n"
17746  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17747  " to fit the histogram data, without this flag, plenv is called\n"
17748  " to set the world coordinates.\n"
17749  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17750  " extremes are not taken into account. This option should\n"
17751  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17752  " properly present the data.\n"
17753  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17754  " size as the ones inside.\n"
17755  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17756  " (there is a gap for such bins).\n"
17757  "\n"
17758  ""},
17759  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17760  "Convert HLS color to RGB\n"
17761  "\n"
17762  "DESCRIPTION:\n"
17763  "\n"
17764  " Convert HLS color coordinates to RGB.\n"
17765  "\n"
17766  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17767  "\n"
17768  "\n"
17769  " This function is used in example 2.\n"
17770  "\n"
17771  "\n"
17772  "\n"
17773  "SYNOPSIS:\n"
17774  "\n"
17775  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17776  "\n"
17777  "ARGUMENTS:\n"
17778  "\n"
17779  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17780  " cylinder.\n"
17781  "\n"
17782  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17783  " the axis of the color cylinder.\n"
17784  "\n"
17785  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17786  " the radius of the color cylinder.\n"
17787  "\n"
17788  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17789  " (0.0-1.0) of the color.\n"
17790  "\n"
17791  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17792  " intensity (0.0-1.0) of the color.\n"
17793  "\n"
17794  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17795  " intensity (0.0-1.0) of the color.\n"
17796  "\n"
17797  ""},
17798  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17799  "Initialize PLplot\n"
17800  "\n"
17801  "DESCRIPTION:\n"
17802  "\n"
17803  " Initializing the plotting package. The program prompts for the device\n"
17804  " keyword or number of the desired output device. Hitting a RETURN in\n"
17805  " response to the prompt is the same as selecting the first device.\n"
17806  " plinit will issue no prompt if either the device was specified\n"
17807  " previously (via command line flag, the plsetopt function, or the\n"
17808  " plsdev function), or if only one device is enabled when PLplot is\n"
17809  " installed. If subpages have been specified, the output device is\n"
17810  " divided into nx by ny subpages, each of which may be used\n"
17811  " independently. If plinit is called again during a program, the\n"
17812  " previously opened file will be closed. The subroutine pladv is used\n"
17813  " to advance from one subpage to the next.\n"
17814  "\n"
17815  " Redacted form: plinit()\n"
17816  "\n"
17817  " This function is used in all of the examples.\n"
17818  "\n"
17819  "\n"
17820  "\n"
17821  "SYNOPSIS:\n"
17822  "\n"
17823  "plinit()\n"
17824  "\n"
17825  ""},
17826  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17827  "Draw a line between two points\n"
17828  "\n"
17829  "DESCRIPTION:\n"
17830  "\n"
17831  " Joins the point (\n"
17832  " x1,\n"
17833  " y1) to (\n"
17834  " x2,\n"
17835  " y2).\n"
17836  "\n"
17837  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17838  "\n"
17839  " This function is used in examples 3 and 14.\n"
17840  "\n"
17841  "\n"
17842  "\n"
17843  "SYNOPSIS:\n"
17844  "\n"
17845  "pljoin(x1, y1, x2, y2)\n"
17846  "\n"
17847  "ARGUMENTS:\n"
17848  "\n"
17849  " x1 (PLFLT, input) : x coordinate of first point.\n"
17850  "\n"
17851  " y1 (PLFLT, input) : y coordinate of first point.\n"
17852  "\n"
17853  " x2 (PLFLT, input) : x coordinate of second point.\n"
17854  "\n"
17855  " y2 (PLFLT, input) : y coordinate of second point.\n"
17856  "\n"
17857  ""},
17858  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17859  "Simple routine to write labels\n"
17860  "\n"
17861  "DESCRIPTION:\n"
17862  "\n"
17863  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17864  "\n"
17865  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17866  "\n"
17867  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17868  "\n"
17869  "\n"
17870  "\n"
17871  "SYNOPSIS:\n"
17872  "\n"
17873  "pllab(xlabel, ylabel, tlabel)\n"
17874  "\n"
17875  "ARGUMENTS:\n"
17876  "\n"
17877  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17878  " the label for the x axis.\n"
17879  "\n"
17880  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17881  " the label for the y axis.\n"
17882  "\n"
17883  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17884  " the title of the plot.\n"
17885  "\n"
17886  ""},
17887  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17888  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17889  "\n"
17890  "DESCRIPTION:\n"
17891  "\n"
17892  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17893  " line, and/or line of symbols for each annotated legend entry. (See\n"
17894  " plcolorbar for similar functionality for creating continuous color\n"
17895  " bars.) The arguments of pllegend provide control over the location\n"
17896  " and size of the legend as well as the location and characteristics of\n"
17897  " the elements (most of which are optional) within that legend. The\n"
17898  " resulting legend is clipped at the boundaries of the current subpage.\n"
17899  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17900  " defined in the documentation of the position parameter.)\n"
17901  "\n"
17902  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17903  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17904  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17905  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17906  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17907  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17908  "\n"
17909  " This function is used in examples 4, 26, and 33.\n"
17910  "\n"
17911  "\n"
17912  "\n"
17913  "SYNOPSIS:\n"
17914  "\n"
17915  "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"
17916  "\n"
17917  "ARGUMENTS:\n"
17918  "\n"
17919  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17920  " legend width in adopted coordinates. This quantity is calculated\n"
17921  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17922  " the routine depending on nlegend and nrow), and the length\n"
17923  " (calculated internally) of the longest text string.\n"
17924  "\n"
17925  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17926  " legend height in adopted coordinates. This quantity is calculated\n"
17927  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17928  " the routine depending on nlegend and nrow).\n"
17929  "\n"
17930  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17931  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17932  " on the left of the legend and the plotted area on the right.\n"
17933  " Otherwise, put the text area on the right of the legend and the\n"
17934  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17935  " plot a (semitransparent) background for the legend. If the\n"
17936  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17937  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17938  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17939  " plot the resulting array of legend entries in row-major order.\n"
17940  " Otherwise, plot the legend entries in column-major order.\n"
17941  "\n"
17942  " position (PLINT, input) : position contains bits which control the\n"
17943  " overall position of the legend and the definition of the adopted\n"
17944  " coordinates used for positions just like what is done for the\n"
17945  " position argument for plcolorbar. However, note that the defaults\n"
17946  " for the position bits (see below) are different than the\n"
17947  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17948  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17949  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17950  " the 16 possible standard positions (the 4 corners and centers of\n"
17951  " the 4 sides for both the inside and outside cases) of the legend\n"
17952  " relative to the adopted coordinate system. The corner positions\n"
17953  " are specified by the appropriate combination of two of the\n"
17954  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17955  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17956  " value of one of those bits. The adopted coordinates are\n"
17957  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17958  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17959  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17960  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17961  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17962  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17963  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17964  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17965  "\n"
17966  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17967  " coordinates from the specified standard position of the legend.\n"
17968  " For positive x, the direction of motion away from the standard\n"
17969  " position is inward/outward from the standard corner positions or\n"
17970  " standard left or right positions if the\n"
17971  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17972  " For the standard top or bottom positions, the direction of motion\n"
17973  " is toward positive X.\n"
17974  "\n"
17975  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17976  " coordinates from the specified standard position of the legend.\n"
17977  " For positive y, the direction of motion away from the standard\n"
17978  " position is inward/outward from the standard corner positions or\n"
17979  " standard top or bottom positions if the\n"
17980  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17981  " the standard left or right positions, the direction of motion is\n"
17982  " toward positive Y.\n"
17983  "\n"
17984  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17985  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17986  " symbols are drawn) of the legend.\n"
17987  "\n"
17988  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17989  " legend (PL_LEGEND_BACKGROUND).\n"
17990  "\n"
17991  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17992  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17993  "\n"
17994  " bb_style (PLINT, input) : The pllsty style number for the\n"
17995  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17996  "\n"
17997  " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17998  " render the\n"
17999  " nlegend legend entries. For internal transformations of\n"
18000  " nrow, see further remarks under\n"
18001  " nlegend.\n"
18002  "\n"
18003  " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18004  " to render the\n"
18005  " nlegend legend entries. For internal transformations of\n"
18006  " ncolumn, see further remarks under\n"
18007  " nlegend.\n"
18008  "\n"
18009  " nlegend (PLINT, input) : Number of legend entries. The above\n"
18010  " nrow and\n"
18011  " ncolumn values are transformed internally to be consistent with\n"
18012  " nlegend. If either\n"
18013  " nrow or\n"
18014  " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18015  " of\n"
18016  " nrow and\n"
18017  " ncolumn is less than\n"
18018  " nlegend, the smaller of the two (or\n"
18019  " nrow, if\n"
18020  " nrow ==\n"
18021  " ncolumn) is increased so the product is >=\n"
18022  " nlegend. Thus, for example, the common\n"
18023  " nrow = 0,\n"
18024  " ncolumn = 0 case is transformed internally to\n"
18025  " nrow =\n"
18026  " nlegend,\n"
18027  " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18028  " column.\n"
18029  "\n"
18030  " opt_array (PLINT_VECTOR, input) : A vector of\n"
18031  " nlegend values of options to control each individual plotted area\n"
18032  " corresponding to a legend entry. If the\n"
18033  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18034  " area. If the\n"
18035  " PL_LEGEND_COLOR_BOX,\n"
18036  " PL_LEGEND_LINE, and/or\n"
18037  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18038  " entry is plotted with a colored box; a line; and/or a line of\n"
18039  " symbols.\n"
18040  "\n"
18041  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18042  " area in units of character width.\n"
18043  "\n"
18044  " text_scale (PLFLT, input) : Character height scale for text\n"
18045  " annotations.\n"
18046  "\n"
18047  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18048  " character height from one legend entry to the next.\n"
18049  "\n"
18050  " text_justification (PLFLT, input) : Justification parameter used\n"
18051  " for text justification. The most common values of\n"
18052  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18053  " is left justified, centred, or right justified within the text\n"
18054  " area, but other values are allowed as well.\n"
18055  "\n"
18056  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18057  " nlegend cmap0 text colors.\n"
18058  "\n"
18059  " text (PLCHAR_MATRIX, input) : A vector of\n"
18060  " nlegend UTF-8 character strings containing the legend annotations.\n"
18061  "\n"
18062  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18063  " nlegend cmap0 colors for the discrete colored boxes (\n"
18064  " PL_LEGEND_COLOR_BOX).\n"
18065  "\n"
18066  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18067  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18068  " PL_LEGEND_COLOR_BOX).\n"
18069  "\n"
18070  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18071  " nlegend scales (units of fraction of character height) for the height\n"
18072  " of the discrete colored boxes (\n"
18073  " PL_LEGEND_COLOR_BOX).\n"
18074  "\n"
18075  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18076  " nlegend line widths for the patterns specified by box_patterns (\n"
18077  " PL_LEGEND_COLOR_BOX).\n"
18078  "\n"
18079  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18080  " nlegend cmap0 line colors (\n"
18081  " PL_LEGEND_LINE).\n"
18082  "\n"
18083  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18084  " nlegend line styles (plsty indices) (\n"
18085  " PL_LEGEND_LINE).\n"
18086  "\n"
18087  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18088  " nlegend line widths (\n"
18089  " PL_LEGEND_LINE).\n"
18090  "\n"
18091  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18092  " nlegend cmap0 symbol colors (\n"
18093  " PL_LEGEND_SYMBOL).\n"
18094  "\n"
18095  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18096  " nlegend scale values for the symbol height (\n"
18097  " PL_LEGEND_SYMBOL).\n"
18098  "\n"
18099  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18100  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18101  " area (\n"
18102  " PL_LEGEND_SYMBOL).\n"
18103  "\n"
18104  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18105  " nlegend UTF-8 character strings containing the legend symbols. (\n"
18106  " PL_LEGEND_SYMBOL).\n"
18107  "\n"
18108  ""},
18109  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
18110  "Plot color bar for image, shade or gradient plots\n"
18111  "\n"
18112  "DESCRIPTION:\n"
18113  "\n"
18114  " Routine for creating a continuous color bar for image, shade, or\n"
18115  " gradient plots. (See pllegend for similar functionality for creating\n"
18116  " legends with discrete elements). The arguments of plcolorbar provide\n"
18117  " control over the location and size of the color bar as well as the\n"
18118  " location and characteristics of the elements (most of which are\n"
18119  " optional) within that color bar. The resulting color bar is clipped\n"
18120  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18121  " system used for some of the parameters is defined in the documentation\n"
18122  " of the position parameter.)\n"
18123  "\n"
18124  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18125  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18126  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18127  " labels, axis_opts, ticks, sub_ticks, values)\n"
18128  "\n"
18129  " This function is used in examples 16 and 33.\n"
18130  "\n"
18131  "\n"
18132  "\n"
18133  "SYNOPSIS:\n"
18134  "\n"
18135  "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"
18136  "\n"
18137  "ARGUMENTS:\n"
18138  "\n"
18139  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18140  " labelled and decorated color bar width in adopted coordinates.\n"
18141  "\n"
18142  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18143  " labelled and decorated color bar height in adopted coordinates.\n"
18144  "\n"
18145  " opt (PLINT, input) : opt contains bits controlling the overall\n"
18146  " color bar. The orientation (direction of the maximum value) of\n"
18147  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18148  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18149  " specified, the default orientation is toward the top if the\n"
18150  " colorbar is placed on the left or right of the viewport or toward\n"
18151  " the right if the colorbar is placed on the top or bottom of the\n"
18152  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18153  " (semitransparent) background for the color bar. If the\n"
18154  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18155  " color bar. The type of color bar must be specified with one of\n"
18156  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18157  " more than one of those bits is set only the first one in the above\n"
18158  " list is honored. The position of the (optional) label/title can be\n"
18159  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18160  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18161  " will be drawn. If more than one of this list of bits is specified,\n"
18162  " only the first one on the list is honored. End-caps for the color\n"
18163  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18164  " If a particular color bar cap option is not specified then no cap\n"
18165  " will be drawn for that end. As a special case for\n"
18166  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18167  " specified. If this option is provided then any tick marks and tick\n"
18168  " labels will be placed at the breaks between shaded segments. TODO:\n"
18169  " This should be expanded to support custom placement of tick marks\n"
18170  " and tick labels at custom value locations for any color bar type.\n"
18171  "\n"
18172  " position (PLINT, input) : position contains bits which control the\n"
18173  " overall position of the color bar and the definition of the\n"
18174  " adopted coordinates used for positions just like what is done for\n"
18175  " the position argument for pllegend. However, note that the\n"
18176  " defaults for the position bits (see below) are different than the\n"
18177  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18178  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18179  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18180  " the 16 possible standard positions (the 4 corners and centers of\n"
18181  " the 4 sides for both the inside and outside cases) of the color\n"
18182  " bar relative to the adopted coordinate system. The corner\n"
18183  " positions are specified by the appropriate combination of two of\n"
18184  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18185  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18186  " value of one of those bits. The adopted coordinates are\n"
18187  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18188  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18189  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18190  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18191  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18192  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18193  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18194  " PL_POSITION_VIEWPORT.\n"
18195  "\n"
18196  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18197  " coordinates from the specified standard position of the color bar.\n"
18198  " For positive x, the direction of motion away from the standard\n"
18199  " position is inward/outward from the standard corner positions or\n"
18200  " standard left or right positions if the\n"
18201  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18202  " For the standard top or bottom positions, the direction of motion\n"
18203  " is toward positive X.\n"
18204  "\n"
18205  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18206  " coordinates from the specified standard position of the color bar.\n"
18207  " For positive y, the direction of motion away from the standard\n"
18208  " position is inward/outward from the standard corner positions or\n"
18209  " standard top or bottom positions if the\n"
18210  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18211  " For the standard left or right positions, the direction of motion\n"
18212  " is toward positive Y.\n"
18213  "\n"
18214  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18215  " the X direction in adopted coordinates.\n"
18216  "\n"
18217  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18218  " the Y direction in adopted coordinates.\n"
18219  "\n"
18220  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18221  " color bar (PL_COLORBAR_BACKGROUND).\n"
18222  "\n"
18223  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18224  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18225  "\n"
18226  " bb_style (PLINT, input) : The pllsty style number for the\n"
18227  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18228  "\n"
18229  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18230  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18231  "\n"
18232  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18233  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18234  "\n"
18235  " cont_color (PLINT, input) : The cmap0 contour color for\n"
18236  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18237  " it will be interpreted according to the design of plshades.\n"
18238  "\n"
18239  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18240  " plots. This is passed directly to plshades, so it will be\n"
18241  " interpreted according to the design of plshades.\n"
18242  "\n"
18243  " n_labels (PLINT, input) : Number of labels to place around the\n"
18244  " color bar.\n"
18245  "\n"
18246  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18247  " n_labels labels.\n"
18248  "\n"
18249  " labels (PLCHAR_MATRIX, input) : A vector of\n"
18250  " n_labels UTF-8 character strings containing the labels for the color\n"
18251  " bar. Ignored if no label position is specified with one of the\n"
18252  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18253  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18254  " corresponding label_opts field.\n"
18255  "\n"
18256  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18257  " value must be greater than 0. It is typically 1 (numerical axis\n"
18258  " labels are provided for one of the long edges of the color bar),\n"
18259  " but it can be larger if multiple numerical axis labels for the\n"
18260  " long edges of the color bar are desired.\n"
18261  "\n"
18262  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18263  " n_axes ascii character strings containing options (interpreted as for\n"
18264  " plbox) for the color bar's axis definitions.\n"
18265  "\n"
18266  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18267  " spacing of the major tick marks (interpreted as for plbox) for the\n"
18268  " color bar's axis definitions.\n"
18269  "\n"
18270  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18271  " number of subticks (interpreted as for plbox) for the color bar's\n"
18272  " axis definitions.\n"
18273  "\n"
18274  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18275  " elements in each of the n_axes rows of the values matrix.\n"
18276  "\n"
18277  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18278  " values for the data range represented by the color bar. For a row\n"
18279  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18280  " elements in the row is specified by n_values[i_axis]. For\n"
18281  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18282  " is 2, and the corresponding row elements of the values matrix are\n"
18283  " the minimum and maximum value represented by the colorbar. For\n"
18284  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18285  " of the values matrix is interpreted the same as the nlevel and\n"
18286  " clevel arguments of plshades.\n"
18287  "\n"
18288  ""},
18289  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
18290  "Sets the 3D position of the light source\n"
18291  "\n"
18292  "DESCRIPTION:\n"
18293  "\n"
18294  " Sets the 3D position of the light source for use with plsurf3d and\n"
18295  " plsurf3dl\n"
18296  "\n"
18297  " Redacted form: pllightsource(x, y, z)\n"
18298  "\n"
18299  " This function is used in example 8.\n"
18300  "\n"
18301  "\n"
18302  "\n"
18303  "SYNOPSIS:\n"
18304  "\n"
18305  "pllightsource(x, y, z)\n"
18306  "\n"
18307  "ARGUMENTS:\n"
18308  "\n"
18309  " x (PLFLT, input) : X-coordinate of the light source.\n"
18310  "\n"
18311  " y (PLFLT, input) : Y-coordinate of the light source.\n"
18312  "\n"
18313  " z (PLFLT, input) : Z-coordinate of the light source.\n"
18314  "\n"
18315  ""},
18316  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
18317  "Draw a line\n"
18318  "\n"
18319  "DESCRIPTION:\n"
18320  "\n"
18321  " Draws line defined by n points in x and y.\n"
18322  "\n"
18323  " Redacted form: plline(x, y)\n"
18324  "\n"
18325  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18326  " 25-27, and 29.\n"
18327  "\n"
18328  "\n"
18329  "\n"
18330  "SYNOPSIS:\n"
18331  "\n"
18332  "plline(n, x, y)\n"
18333  "\n"
18334  "ARGUMENTS:\n"
18335  "\n"
18336  " n (PLINT, input) : Number of points defining line.\n"
18337  "\n"
18338  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18339  " points.\n"
18340  "\n"
18341  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18342  " points.\n"
18343  "\n"
18344  ""},
18345  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
18346  "Draw a line in 3 space\n"
18347  "\n"
18348  "DESCRIPTION:\n"
18349  "\n"
18350  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18351  " first set up the viewport, the 2d viewing window (in world\n"
18352  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18353  " more info.\n"
18354  "\n"
18355  " Redacted form: plline3(x, y, z)\n"
18356  "\n"
18357  " This function is used in example 18.\n"
18358  "\n"
18359  "\n"
18360  "\n"
18361  "SYNOPSIS:\n"
18362  "\n"
18363  "plline3(n, x, y, z)\n"
18364  "\n"
18365  "ARGUMENTS:\n"
18366  "\n"
18367  " n (PLINT, input) : Number of points defining line.\n"
18368  "\n"
18369  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18370  " points.\n"
18371  "\n"
18372  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18373  " points.\n"
18374  "\n"
18375  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18376  " points.\n"
18377  "\n"
18378  ""},
18379  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
18380  "Select line style\n"
18381  "\n"
18382  "DESCRIPTION:\n"
18383  "\n"
18384  " This sets the line style according to one of eight predefined patterns\n"
18385  " (also see plstyl).\n"
18386  "\n"
18387  " Redacted form: pllsty(lin)\n"
18388  "\n"
18389  " This function is used in examples 9, 12, 22, and 25.\n"
18390  "\n"
18391  "\n"
18392  "\n"
18393  "SYNOPSIS:\n"
18394  "\n"
18395  "pllsty(lin)\n"
18396  "\n"
18397  "ARGUMENTS:\n"
18398  "\n"
18399  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18400  " a continuous line, line style 2 is a line with short dashes and\n"
18401  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18402  " 4 has long dashes and short gaps and so on.\n"
18403  "\n"
18404  ""},
18405  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
18406  "Plot surface mesh\n"
18407  "\n"
18408  "DESCRIPTION:\n"
18409  "\n"
18410  " Plots a surface mesh within the environment set up by plw3d. The\n"
18411  " surface is defined by the matrix z[\n"
18412  " nx][\n"
18413  " ny] , the point z[i][j] being the value of the function at (\n"
18414  " x[i],\n"
18415  " y[j]). Note that the points in vectors x and y do not need to be\n"
18416  " equally spaced, but must be stored in ascending order. The parameter\n"
18417  " opt controls the way in which the surface is displayed. For further\n"
18418  " details see the PLplot documentation.\n"
18419  "\n"
18420  " Redacted form: plmesh(x, y, z, opt)\n"
18421  "\n"
18422  " This function is used in example 11.\n"
18423  "\n"
18424  "\n"
18425  "\n"
18426  "SYNOPSIS:\n"
18427  "\n"
18428  "plmesh(x, y, z, nx, ny, opt)\n"
18429  "\n"
18430  "ARGUMENTS:\n"
18431  "\n"
18432  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18433  " which the function is evaluated.\n"
18434  "\n"
18435  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18436  " which the function is evaluated.\n"
18437  "\n"
18438  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18439  " plot. Should have dimensions of\n"
18440  " nx by\n"
18441  " ny.\n"
18442  "\n"
18443  " nx (PLINT, input) : Number of x values at which function has been\n"
18444  " evaluated.\n"
18445  "\n"
18446  " ny (PLINT, input) : Number of y values at which function has been\n"
18447  " evaluated.\n"
18448  "\n"
18449  " opt (PLINT, input) : Determines the way in which the surface is\n"
18450  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18451  " function of x for each value of y[j] .\n"
18452  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18453  " for each value of x[i] .\n"
18454  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18455  " at which function is defined.\n"
18456  "\n"
18457  ""},
18458  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
18459  "Magnitude colored plot surface mesh with contour\n"
18460  "\n"
18461  "DESCRIPTION:\n"
18462  "\n"
18463  " A more powerful form of plmesh: the surface mesh can be colored\n"
18464  " accordingly to the current z value being plotted, a contour plot can\n"
18465  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18466  " plotted function border and the base XY plane.\n"
18467  "\n"
18468  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18469  "\n"
18470  " This function is used in example 11.\n"
18471  "\n"
18472  "\n"
18473  "\n"
18474  "SYNOPSIS:\n"
18475  "\n"
18476  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18477  "\n"
18478  "ARGUMENTS:\n"
18479  "\n"
18480  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18481  " which the function is evaluated.\n"
18482  "\n"
18483  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18484  " which the function is evaluated.\n"
18485  "\n"
18486  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18487  " plot. Should have dimensions of\n"
18488  " nx by\n"
18489  " ny.\n"
18490  "\n"
18491  " nx (PLINT, input) : Number of x values at which function is\n"
18492  " evaluated.\n"
18493  "\n"
18494  " ny (PLINT, input) : Number of y values at which function is\n"
18495  " evaluated.\n"
18496  "\n"
18497  " opt (PLINT, input) : Determines the way in which the surface is\n"
18498  " represented. To specify more than one option just add the options,\n"
18499  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18500  " showing z as a function of x for each value of y[j] .\n"
18501  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18502  " for each value of x[i] .\n"
18503  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18504  " at which function is defined.\n"
18505  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18506  " the z value being plotted. The color is used from the current\n"
18507  " cmap1.\n"
18508  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18509  " using parameters\n"
18510  " nlevel and\n"
18511  " clevel.\n"
18512  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18513  " the borders of the plotted function.\n"
18514  "\n"
18515  "\n"
18516  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18517  " levels.\n"
18518  "\n"
18519  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18520  "\n"
18521  ""},
18522  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
18523  "Creates a new stream and makes it the default\n"
18524  "\n"
18525  "DESCRIPTION:\n"
18526  "\n"
18527  " Creates a new stream and makes it the default. Differs from using\n"
18528  " plsstrm, in that a free stream number is found, and returned.\n"
18529  " Unfortunately, I have to start at stream 1 and work upward, since\n"
18530  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18531  " that no initial, library-opening call is required. So stream 0 must\n"
18532  " be preallocated, and there is no simple way of determining whether it\n"
18533  " is already in use or not.\n"
18534  "\n"
18535  " Redacted form: plmkstrm(p_strm)\n"
18536  "\n"
18537  " This function is used in examples 1 and 20.\n"
18538  "\n"
18539  "\n"
18540  "\n"
18541  "SYNOPSIS:\n"
18542  "\n"
18543  "plmkstrm(p_strm)\n"
18544  "\n"
18545  "ARGUMENTS:\n"
18546  "\n"
18547  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18548  " number of the created stream.\n"
18549  "\n"
18550  ""},
18551  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
18552  "Write text relative to viewport boundaries\n"
18553  "\n"
18554  "DESCRIPTION:\n"
18555  "\n"
18556  " Writes text at a specified position relative to the viewport\n"
18557  " boundaries. Text may be written inside or outside the viewport, but\n"
18558  " is clipped at the subpage boundaries. The reference point of a string\n"
18559  " lies along a line passing through the string at half the height of a\n"
18560  " capital letter. The position of the reference point along this line\n"
18561  " is determined by just, and the position of the reference point\n"
18562  " relative to the viewport is set by disp and pos.\n"
18563  "\n"
18564  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18565  "\n"
18566  "\n"
18567  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18568  " 26.\n"
18569  "\n"
18570  "\n"
18571  "\n"
18572  "SYNOPSIS:\n"
18573  "\n"
18574  "plmtex(side, disp, pos, just, text)\n"
18575  "\n"
18576  "ARGUMENTS:\n"
18577  "\n"
18578  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18579  " the side of the viewport along which the text is to be written.\n"
18580  " The string must be one of: b: Bottom of viewport, text written\n"
18581  " parallel to edge.\n"
18582  " bv: Bottom of viewport, text written at right angles to edge.\n"
18583  " l: Left of viewport, text written parallel to edge.\n"
18584  " lv: Left of viewport, text written at right angles to edge.\n"
18585  " r: Right of viewport, text written parallel to edge.\n"
18586  " rv: Right of viewport, text written at right angles to edge.\n"
18587  " t: Top of viewport, text written parallel to edge.\n"
18588  " tv: Top of viewport, text written at right angles to edge.\n"
18589  "\n"
18590  "\n"
18591  " disp (PLFLT, input) : Position of the reference point of string,\n"
18592  " measured outwards from the specified viewport edge in units of the\n"
18593  " current character height. Use negative disp to write within the\n"
18594  " viewport.\n"
18595  "\n"
18596  " pos (PLFLT, input) : Position of the reference point of string\n"
18597  " along the specified edge, expressed as a fraction of the length of\n"
18598  " the edge.\n"
18599  "\n"
18600  " just (PLFLT, input) : Specifies the position of the string relative\n"
18601  " to its reference point. If just=0. , the reference point is at\n"
18602  " the left and if just=1. , it is at the right of the string. Other\n"
18603  " values of just give intermediate justifications.\n"
18604  "\n"
18605  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18606  " written out.\n"
18607  "\n"
18608  ""},
18609  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
18610  "Write text relative to viewport boundaries in 3D plots\n"
18611  "\n"
18612  "DESCRIPTION:\n"
18613  "\n"
18614  " Writes text at a specified position relative to the viewport\n"
18615  " boundaries. Text may be written inside or outside the viewport, but\n"
18616  " is clipped at the subpage boundaries. The reference point of a string\n"
18617  " lies along a line passing through the string at half the height of a\n"
18618  " capital letter. The position of the reference point along this line\n"
18619  " is determined by just, and the position of the reference point\n"
18620  " relative to the viewport is set by disp and pos.\n"
18621  "\n"
18622  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18623  "\n"
18624  " This function is used in example 28.\n"
18625  "\n"
18626  "\n"
18627  "\n"
18628  "SYNOPSIS:\n"
18629  "\n"
18630  "plmtex3(side, disp, pos, just, text)\n"
18631  "\n"
18632  "ARGUMENTS:\n"
18633  "\n"
18634  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18635  " the side of the viewport along which the text is to be written.\n"
18636  " The string should contain one or more of the following characters:\n"
18637  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18638  " only label the X axis, not both the X and Y axes. x: Label the X\n"
18639  " axis.\n"
18640  " y: Label the Y axis.\n"
18641  " z: Label the Z axis.\n"
18642  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18643  " For X it is the axis that starts at y-min. For Y it is the\n"
18644  " axis that starts at x-min.\n"
18645  " s: Label the secondary axis.\n"
18646  " v: Draw the text perpendicular to the axis.\n"
18647  "\n"
18648  "\n"
18649  " disp (PLFLT, input) : Position of the reference point of string,\n"
18650  " measured outwards from the specified viewport edge in units of the\n"
18651  " current character height. Use negative disp to write within the\n"
18652  " viewport.\n"
18653  "\n"
18654  " pos (PLFLT, input) : Position of the reference point of string\n"
18655  " along the specified edge, expressed as a fraction of the length of\n"
18656  " the edge.\n"
18657  "\n"
18658  " just (PLFLT, input) : Specifies the position of the string relative\n"
18659  " to its reference point. If just=0. , the reference point is at\n"
18660  " the left and if just=1. , it is at the right of the string. Other\n"
18661  " values of just give intermediate justifications.\n"
18662  "\n"
18663  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18664  " written out.\n"
18665  "\n"
18666  ""},
18667  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
18668  "Plot 3-d surface plot\n"
18669  "\n"
18670  "DESCRIPTION:\n"
18671  "\n"
18672  " Plots a three-dimensional surface plot within the environment set up\n"
18673  " by plw3d. The surface is defined by the matrix z[\n"
18674  " nx][\n"
18675  " ny] , the point z[i][j] being the value of the function at (\n"
18676  " x[i],\n"
18677  " y[j]). Note that the points in vectors x and y do not need to be\n"
18678  " equally spaced, but must be stored in ascending order. The parameter\n"
18679  " opt controls the way in which the surface is displayed. For further\n"
18680  " details see the PLplot documentation. The only difference between\n"
18681  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18682  " while plot3d only draws the surface as viewed from the top.\n"
18683  "\n"
18684  " Redacted form: plot3d(x, y, z, opt, side)\n"
18685  "\n"
18686  " This function is used in examples 11 and 21.\n"
18687  "\n"
18688  "\n"
18689  "\n"
18690  "SYNOPSIS:\n"
18691  "\n"
18692  "plot3d(x, y, z, nx, ny, opt, side)\n"
18693  "\n"
18694  "ARGUMENTS:\n"
18695  "\n"
18696  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18697  " which the function is evaluated.\n"
18698  "\n"
18699  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18700  " which the function is evaluated.\n"
18701  "\n"
18702  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18703  " plot. Should have dimensions of\n"
18704  " nx by\n"
18705  " ny.\n"
18706  "\n"
18707  " nx (PLINT, input) : Number of x values at which function is\n"
18708  " evaluated.\n"
18709  "\n"
18710  " ny (PLINT, input) : Number of y values at which function is\n"
18711  " evaluated.\n"
18712  "\n"
18713  " opt (PLINT, input) : Determines the way in which the surface is\n"
18714  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18715  " function of x for each value of y[j] .\n"
18716  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18717  " for each value of x[i] .\n"
18718  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18719  " at which function is defined.\n"
18720  "\n"
18721  "\n"
18722  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18723  " should be draw on the figure. If side is true sides are drawn,\n"
18724  " otherwise no sides are drawn.\n"
18725  "\n"
18726  ""},
18727  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18728  "Magnitude colored plot surface with contour\n"
18729  "\n"
18730  "DESCRIPTION:\n"
18731  "\n"
18732  " Aside from dropping the\n"
18733  " side functionality this is a more powerful form of plot3d: the surface\n"
18734  " mesh can be colored accordingly to the current z value being plotted,\n"
18735  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18736  " drawn between the plotted function border and the base XY plane. The\n"
18737  " arguments are identical to those of plmeshc. The only difference\n"
18738  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18739  " the surface, while plot3dc only draws the surface as viewed from the\n"
18740  " top.\n"
18741  "\n"
18742  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18743  "\n"
18744  "\n"
18745  " This function is used in example 21.\n"
18746  "\n"
18747  "\n"
18748  "\n"
18749  "SYNOPSIS:\n"
18750  "\n"
18751  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18752  "\n"
18753  "ARGUMENTS:\n"
18754  "\n"
18755  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18756  " which the function is evaluated.\n"
18757  "\n"
18758  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18759  " which the function is evaluated.\n"
18760  "\n"
18761  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18762  " plot. Should have dimensions of\n"
18763  " nx by\n"
18764  " ny.\n"
18765  "\n"
18766  " nx (PLINT, input) : Number of x values at which function is\n"
18767  " evaluated.\n"
18768  "\n"
18769  " ny (PLINT, input) : Number of y values at which function is\n"
18770  " evaluated.\n"
18771  "\n"
18772  " opt (PLINT, input) : Determines the way in which the surface is\n"
18773  " represented. To specify more than one option just add the options,\n"
18774  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18775  " showing z as a function of x for each value of y[j] .\n"
18776  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18777  " for each value of x[i] .\n"
18778  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18779  " at which function is defined.\n"
18780  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18781  " the z value being plotted. The color is used from the current\n"
18782  " cmap1.\n"
18783  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18784  " using parameters\n"
18785  " nlevel and\n"
18786  " clevel.\n"
18787  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18788  " the borders of the plotted function.\n"
18789  "\n"
18790  "\n"
18791  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18792  " levels.\n"
18793  "\n"
18794  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18795  "\n"
18796  ""},
18797  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18798  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18799  "\n"
18800  "DESCRIPTION:\n"
18801  "\n"
18802  " When the implementation is completed this variant of plot3dc (see that\n"
18803  " function's documentation for more details) should be suitable for the\n"
18804  " case where the area of the x, y coordinate grid where z is defined can\n"
18805  " be non-rectangular. The implementation is incomplete so the last 4\n"
18806  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18807  " indexymax; are currently ignored and the functionality is otherwise\n"
18808  " identical to that of plot3dc.\n"
18809  "\n"
18810  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18811  " indexymin, indexymax)\n"
18812  "\n"
18813  "\n"
18814  " This function is not used in any example.\n"
18815  "\n"
18816  "\n"
18817  "\n"
18818  "SYNOPSIS:\n"
18819  "\n"
18820  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18821  "\n"
18822  "ARGUMENTS:\n"
18823  "\n"
18824  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18825  " which the function is evaluated.\n"
18826  "\n"
18827  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18828  " which the function is evaluated.\n"
18829  "\n"
18830  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18831  " plot. Should have dimensions of\n"
18832  " nx by\n"
18833  " ny.\n"
18834  "\n"
18835  " nx (PLINT, input) : Number of x values at which the function is\n"
18836  " evaluated.\n"
18837  "\n"
18838  " ny (PLINT, input) : Number of y values at which the function is\n"
18839  " evaluated.\n"
18840  "\n"
18841  " opt (PLINT, input) : Determines the way in which the surface is\n"
18842  " represented. To specify more than one option just add the options,\n"
18843  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18844  " showing z as a function of x for each value of y[j] .\n"
18845  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18846  " for each value of x[i] .\n"
18847  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18848  " at which function is defined.\n"
18849  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18850  " the z value being plotted. The color is used from the current\n"
18851  " cmap1.\n"
18852  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18853  " using parameters\n"
18854  " nlevel and\n"
18855  " clevel.\n"
18856  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18857  " the borders of the plotted function.\n"
18858  "\n"
18859  "\n"
18860  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18861  " levels.\n"
18862  "\n"
18863  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18864  "\n"
18865  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18866  " corresponds to the first x index where z is defined.\n"
18867  "\n"
18868  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18869  " which corresponds (by convention) to one more than the last x\n"
18870  " index value where z is defined.\n"
18871  "\n"
18872  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18873  " values which all must be ≥ 0. These values are the first y index\n"
18874  " where z is defined for a particular x index in the range from\n"
18875  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18876  " indexxmax.\n"
18877  "\n"
18878  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18879  " values which all must be ≤ ny. These values correspond (by\n"
18880  " convention) to one more than the last y index where z is defined\n"
18881  " for a particular x index in the range from indexxmin to indexxmax\n"
18882  " - 1. The dimension of indexymax is indexxmax.\n"
18883  "\n"
18884  ""},
18885  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18886  "Plot shaded 3-d surface plot\n"
18887  "\n"
18888  "DESCRIPTION:\n"
18889  "\n"
18890  " Plots a three-dimensional shaded surface plot within the environment\n"
18891  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18892  " z[\n"
18893  " nx][\n"
18894  " ny], the point z[i][j] being the value of the function at (\n"
18895  " x[i],\n"
18896  " y[j]). Note that the points in vectors x and y do not need to be\n"
18897  " equally spaced, but must be stored in ascending order. For further\n"
18898  " details see the PLplot documentation.\n"
18899  "\n"
18900  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18901  "\n"
18902  " This function is not used in any examples.\n"
18903  "\n"
18904  "\n"
18905  "\n"
18906  "SYNOPSIS:\n"
18907  "\n"
18908  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18909  "\n"
18910  "ARGUMENTS:\n"
18911  "\n"
18912  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18913  " which the function is evaluated.\n"
18914  "\n"
18915  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18916  " which the function is evaluated.\n"
18917  "\n"
18918  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18919  " plot. Should have dimensions of\n"
18920  " nx by\n"
18921  " ny.\n"
18922  "\n"
18923  " nx (PLINT, input) : Number of x values at which function is\n"
18924  " evaluated.\n"
18925  "\n"
18926  " ny (PLINT, input) : Number of y values at which function is\n"
18927  " evaluated.\n"
18928  "\n"
18929  " opt (PLINT, input) : Determines the way in which the surface is\n"
18930  " represented. To specify more than one option just add the options,\n"
18931  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18932  " connecting points at which function is defined.\n"
18933  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18934  " using parameters\n"
18935  " nlevel and\n"
18936  " clevel.\n"
18937  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18938  " using parameters\n"
18939  " nlevel and\n"
18940  " clevel.\n"
18941  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18942  " the borders of the plotted function.\n"
18943  " opt=MAG_COLOR : the surface is colored according to the value\n"
18944  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18945  " according to the intensity of the reflected light in the\n"
18946  " surface from a light source whose position is set using\n"
18947  " pllightsource.\n"
18948  "\n"
18949  "\n"
18950  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18951  " levels.\n"
18952  "\n"
18953  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18954  "\n"
18955  ""},
18956  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18957  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18958  "\n"
18959  "DESCRIPTION:\n"
18960  "\n"
18961  " This variant of plsurf3d (see that function's documentation for more\n"
18962  " details) should be suitable for the case where the area of the x, y\n"
18963  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18964  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18965  " indexymin, and indexymax.\n"
18966  "\n"
18967  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18968  " indexymax)\n"
18969  "\n"
18970  " This function is used in example 8.\n"
18971  "\n"
18972  "\n"
18973  "\n"
18974  "SYNOPSIS:\n"
18975  "\n"
18976  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18977  "\n"
18978  "ARGUMENTS:\n"
18979  "\n"
18980  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18981  " which the function is evaluated.\n"
18982  "\n"
18983  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18984  " which the function is evaluated.\n"
18985  "\n"
18986  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18987  " plot. Should have dimensions of\n"
18988  " nx by\n"
18989  " ny.\n"
18990  "\n"
18991  " nx (PLINT, input) : Number of x values at which function is\n"
18992  " evaluated.\n"
18993  "\n"
18994  " ny (PLINT, input) : Number of y values at which function is\n"
18995  " evaluated.\n"
18996  "\n"
18997  " opt (PLINT, input) : Determines the way in which the surface is\n"
18998  " represented. To specify more than one option just add the options,\n"
18999  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19000  " connecting points at which function is defined.\n"
19001  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19002  " using parameters\n"
19003  " nlevel and\n"
19004  " clevel.\n"
19005  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19006  " using parameters\n"
19007  " nlevel and\n"
19008  " clevel.\n"
19009  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19010  " the borders of the plotted function.\n"
19011  " opt=MAG_COLOR : the surface is colored according to the value\n"
19012  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19013  " according to the intensity of the reflected light in the\n"
19014  " surface from a light source whose position is set using\n"
19015  " pllightsource.\n"
19016  "\n"
19017  "\n"
19018  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19019  " levels.\n"
19020  "\n"
19021  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19022  "\n"
19023  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19024  " corresponds to the first x index where z is defined.\n"
19025  "\n"
19026  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19027  " which corresponds (by convention) to one more than the last x\n"
19028  " index value where z is defined.\n"
19029  "\n"
19030  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19031  " values which all must be ≥ 0. These values are the first y index\n"
19032  " where z is defined for a particular x index in the range from\n"
19033  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19034  " indexxmax.\n"
19035  "\n"
19036  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19037  " values which all must be ≤ ny. These values correspond (by\n"
19038  " convention) to one more than the last y index where z is defined\n"
19039  " for a particular x index in the range from indexxmin to indexxmax\n"
19040  " - 1. The dimension of indexymax is indexxmax.\n"
19041  "\n"
19042  ""},
19043  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
19044  "Parse command-line arguments\n"
19045  "\n"
19046  "DESCRIPTION:\n"
19047  "\n"
19048  " Parse command-line arguments.\n"
19049  "\n"
19050  " plparseopts removes all recognized flags (decreasing argc\n"
19051  " accordingly), so that invalid input may be readily detected. It can\n"
19052  " also be used to process user command line flags. The user can merge\n"
19053  " an option table of type PLOptionTable into the internal option table\n"
19054  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19055  " the external table(s) be parsed by calling plClearOpts before\n"
19056  " plMergeOpts.\n"
19057  "\n"
19058  " The default action taken by plparseopts is as follows:\n"
19059  " Returns with an error if an unrecognized option or badly formed\n"
19060  " option-value pair are encountered.\n"
19061  " Returns immediately (return code 0) when the first non-option command\n"
19062  " line argument is found.\n"
19063  " Returns with the return code of the option handler, if one was called.\n"
19064  "\n"
19065  " Deletes command line arguments from argv list as they are found, and\n"
19066  " decrements argc accordingly.\n"
19067  " Does not show \"invisible\" options in usage or help messages.\n"
19068  " Assumes the program name is contained in argv[0].\n"
19069  "\n"
19070  " These behaviors may be controlled through the\n"
19071  " mode argument.\n"
19072  "\n"
19073  " Redacted form: General: plparseopts(argv, mode)\n"
19074  "\n"
19075  "\n"
19076  " This function is used in all of the examples.\n"
19077  "\n"
19078  "\n"
19079  "\n"
19080  "SYNOPSIS:\n"
19081  "\n"
19082  "PLINT plparseopts(p_argc, argv, mode)\n"
19083  "\n"
19084  "ARGUMENTS:\n"
19085  "\n"
19086  " p_argc (int *, input/output) : Number of arguments.\n"
19087  "\n"
19088  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19089  " strings containing *p_argc command-line arguments.\n"
19090  "\n"
19091  " mode (PLINT, input) : Parsing mode with the following\n"
19092  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19093  " and all error messages enabled, including program exit when an\n"
19094  " error occurs. Anything on the command line that isn't recognized\n"
19095  " as a valid option or option argument is flagged as an error.\n"
19096  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19097  " of errors.\n"
19098  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19099  " arguments.\n"
19100  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19101  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19102  " pointer to the program name.\n"
19103  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19104  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19105  " unrecognized arguments.\n"
19106  "\n"
19107  ""},
19108  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
19109  "Set area line fill pattern\n"
19110  "\n"
19111  "DESCRIPTION:\n"
19112  "\n"
19113  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19114  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19115  " inclinations and spacings. The arguments to this routine are the\n"
19116  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19117  " elements) specifying the inclinations in tenths of a degree and the\n"
19118  " spacing in micrometers. (See also plpsty)\n"
19119  "\n"
19120  " Redacted form: General: plpat(inc, del)\n"
19121  "\n"
19122  "\n"
19123  " This function is used in example 15.\n"
19124  "\n"
19125  "\n"
19126  "\n"
19127  "SYNOPSIS:\n"
19128  "\n"
19129  "plpat(nlin, inc, del)\n"
19130  "\n"
19131  "ARGUMENTS:\n"
19132  "\n"
19133  " nlin (PLINT, input) : Number of sets of lines making up the\n"
19134  " pattern, either 1 or 2.\n"
19135  "\n"
19136  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19137  " inclination in tenths of a degree. (Should be between -900 and\n"
19138  " 900).\n"
19139  "\n"
19140  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19141  " spacing in micrometers between the lines making up the pattern.\n"
19142  "\n"
19143  ""},
19144  { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
19145  "Draw a line between two points, accounting for coordinate transforms\n"
19146  "\n"
19147  "DESCRIPTION:\n"
19148  "\n"
19149  " Joins the point (\n"
19150  " x1,\n"
19151  " y1) to (\n"
19152  " x2,\n"
19153  " y2) . If a global coordinate transform is defined then the line is\n"
19154  " broken in to n segments to approximate the path. If no transform is\n"
19155  " defined then this simply acts like a call to pljoin.\n"
19156  "\n"
19157  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19158  "\n"
19159  " This function is used in example 22.\n"
19160  "\n"
19161  "\n"
19162  "\n"
19163  "SYNOPSIS:\n"
19164  "\n"
19165  "plpath(n, x1, y1, x2, y2)\n"
19166  "\n"
19167  "ARGUMENTS:\n"
19168  "\n"
19169  " n (PLINT, input) : number of points to use to approximate the path.\n"
19170  "\n"
19171  " x1 (PLFLT, input) : x coordinate of first point.\n"
19172  "\n"
19173  " y1 (PLFLT, input) : y coordinate of first point.\n"
19174  "\n"
19175  " x2 (PLFLT, input) : x coordinate of second point.\n"
19176  "\n"
19177  " y2 (PLFLT, input) : y coordinate of second point.\n"
19178  "\n"
19179  ""},
19180  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
19181  "Plot a glyph at the specified points\n"
19182  "\n"
19183  "DESCRIPTION:\n"
19184  "\n"
19185  " Plot a glyph at the specified points. (This function is largely\n"
19186  " superseded by plstring which gives access to many[!] more glyphs.)\n"
19187  " code=-1 means try to just draw a point. Right now it's just a move\n"
19188  " and a draw at the same place. Not ideal, since a sufficiently\n"
19189  " intelligent output device may optimize it away, or there may be faster\n"
19190  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19191  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19192  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19193  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19194  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19195  "\n"
19196  " Redacted form: plpoin(x, y, code)\n"
19197  "\n"
19198  " This function is used in examples 1, 6, 14, and 29.\n"
19199  "\n"
19200  "\n"
19201  "\n"
19202  "SYNOPSIS:\n"
19203  "\n"
19204  "plpoin(n, x, y, code)\n"
19205  "\n"
19206  "ARGUMENTS:\n"
19207  "\n"
19208  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19209  "\n"
19210  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19211  " points.\n"
19212  "\n"
19213  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19214  " points.\n"
19215  "\n"
19216  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19217  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19218  " each of the n points.\n"
19219  "\n"
19220  ""},
19221  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
19222  "Plot a glyph at the specified 3D points\n"
19223  "\n"
19224  "DESCRIPTION:\n"
19225  "\n"
19226  " Plot a glyph at the specified 3D points. (This function is largely\n"
19227  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19228  " Set up the call to this function similar to what is done for plline3.\n"
19229  " code=-1 means try to just draw a point. Right now it's just a move\n"
19230  " and a draw at the same place. Not ideal, since a sufficiently\n"
19231  " intelligent output device may optimize it away, or there may be faster\n"
19232  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19233  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19234  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19235  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19236  " code <= 127 the corresponding printable ASCII character is plotted.\n"
19237  "\n"
19238  " Redacted form: plpoin3(x, y, z, code)\n"
19239  "\n"
19240  " This function is not used in any example.\n"
19241  "\n"
19242  "\n"
19243  "\n"
19244  "SYNOPSIS:\n"
19245  "\n"
19246  "plpoin3(n, x, y, z, code)\n"
19247  "\n"
19248  "ARGUMENTS:\n"
19249  "\n"
19250  " n (PLINT, input) : Number of points in the x and y vectors.\n"
19251  "\n"
19252  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19253  " points.\n"
19254  "\n"
19255  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19256  " points.\n"
19257  "\n"
19258  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19259  " points.\n"
19260  "\n"
19261  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19262  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19263  " each of the n points.\n"
19264  "\n"
19265  ""},
19266  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
19267  "Draw a polygon in 3 space\n"
19268  "\n"
19269  "DESCRIPTION:\n"
19270  "\n"
19271  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19272  " like plline3, but differs from that function in that plpoly3 attempts\n"
19273  " to determine if the polygon is viewable depending on the order of the\n"
19274  " points within the vector and the value of ifcc. If the back of\n"
19275  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19276  " you want, then use plline3 instead.\n"
19277  "\n"
19278  " The points are assumed to be in a plane, and the directionality of the\n"
19279  " plane is determined from the first three points. Additional points do\n"
19280  " not have to lie on the plane defined by the first three, but if they\n"
19281  " do not, then the determination of visibility obviously can't be 100%\n"
19282  " accurate... So if you're 3 space polygons are too far from planar,\n"
19283  " consider breaking them into smaller polygons. 3 points define a plane\n"
19284  " :-).\n"
19285  "\n"
19286  " Bugs: If one of the first two segments is of zero length, or if they\n"
19287  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19288  " being correct. Avoid such situations :-). See x18c.c for an example\n"
19289  " of this problem. (Search for 20.1).\n"
19290  "\n"
19291  " Redacted form: plpoly3(x, y, z, code)\n"
19292  "\n"
19293  " This function is used in example 18.\n"
19294  "\n"
19295  "\n"
19296  "\n"
19297  "SYNOPSIS:\n"
19298  "\n"
19299  "plpoly3(n, x, y, z, draw, ifcc)\n"
19300  "\n"
19301  "ARGUMENTS:\n"
19302  "\n"
19303  " n (PLINT, input) : Number of points defining line.\n"
19304  "\n"
19305  " x (PLFLT_VECTOR, input) : A vector containing\n"
19306  " n x coordinates of points.\n"
19307  "\n"
19308  " y (PLFLT_VECTOR, input) : A vector containing\n"
19309  " n y coordinates of points.\n"
19310  "\n"
19311  " z (PLFLT_VECTOR, input) : A vector containing\n"
19312  " n z coordinates of points.\n"
19313  "\n"
19314  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19315  " n-1 Boolean values which control drawing the segments of the polygon.\n"
19316  " If draw[i] is true, then the polygon segment from index [i] to\n"
19317  " [i+1] is drawn, otherwise, not.\n"
19318  "\n"
19319  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19320  " polygon is determined by assuming the points are laid out in a\n"
19321  " counter-clockwise order. Otherwise, the directionality of the\n"
19322  " polygon is determined by assuming the points are laid out in a\n"
19323  " clockwise order.\n"
19324  "\n"
19325  ""},
19326  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
19327  "Set precision in numeric labels\n"
19328  "\n"
19329  "DESCRIPTION:\n"
19330  "\n"
19331  " Sets the number of places after the decimal point in numeric labels.\n"
19332  "\n"
19333  " Redacted form: plprec(setp, prec)\n"
19334  "\n"
19335  " This function is used in example 29.\n"
19336  "\n"
19337  "\n"
19338  "\n"
19339  "SYNOPSIS:\n"
19340  "\n"
19341  "plprec(setp, prec)\n"
19342  "\n"
19343  "ARGUMENTS:\n"
19344  "\n"
19345  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19346  " automatically determines the number of places to use after the\n"
19347  " decimal point in numeric labels (like those used to label axes).\n"
19348  " If setp is 1 then prec sets the number of places.\n"
19349  "\n"
19350  " prec (PLINT, input) : The number of characters to draw after the\n"
19351  " decimal point in numeric labels.\n"
19352  "\n"
19353  ""},
19354  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
19355  "Select area fill pattern\n"
19356  "\n"
19357  "DESCRIPTION:\n"
19358  "\n"
19359  " If\n"
19360  " patt is zero or less use either a hardware solid fill if the drivers\n"
19361  " have that capability (virtually all do) or fall back to a software\n"
19362  " emulation of a solid fill using the eighth area line fill pattern. If\n"
19363  " 0 <\n"
19364  " patt <= 8, then select one of eight predefined area line fill patterns\n"
19365  " to use (see plpat if you desire other patterns).\n"
19366  "\n"
19367  " Redacted form: plpsty(patt)\n"
19368  "\n"
19369  " This function is used in examples 12, 13, 15, 16, and 25.\n"
19370  "\n"
19371  "\n"
19372  "\n"
19373  "SYNOPSIS:\n"
19374  "\n"
19375  "plpsty(patt)\n"
19376  "\n"
19377  "ARGUMENTS:\n"
19378  "\n"
19379  " patt (PLINT, input) : The desired pattern index. If\n"
19380  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19381  " above) used. For\n"
19382  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19383  " line fill capability itself (most deliberately do not so that line\n"
19384  " fill patterns look identical for those drivers), the patterns\n"
19385  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19386  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19387  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19388  " (8) lines at both 45 degrees and -45 degrees.\n"
19389  "\n"
19390  ""},
19391  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
19392  "Write text inside the viewport\n"
19393  "\n"
19394  "DESCRIPTION:\n"
19395  "\n"
19396  " Writes text at a specified position and inclination within the\n"
19397  " viewport. Text is clipped at the viewport boundaries. The reference\n"
19398  " point of a string lies along a line passing through the string at half\n"
19399  " the height of a capital letter. The position of the reference point\n"
19400  " along this line is determined by just, the reference point is placed\n"
19401  " at world coordinates (\n"
19402  " x,\n"
19403  " y) within the viewport. The inclination of the string is specified\n"
19404  " in terms of differences of world coordinates making it easy to write\n"
19405  " text parallel to a line in a graph.\n"
19406  "\n"
19407  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19408  "\n"
19409  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19410  "\n"
19411  "\n"
19412  "\n"
19413  "SYNOPSIS:\n"
19414  "\n"
19415  "plptex(x, y, dx, dy, just, text)\n"
19416  "\n"
19417  "ARGUMENTS:\n"
19418  "\n"
19419  " x (PLFLT, input) : x coordinate of reference point of string.\n"
19420  "\n"
19421  " y (PLFLT, input) : y coordinate of reference point of string.\n"
19422  "\n"
19423  " dx (PLFLT, input) : Together with dy, this specifies the\n"
19424  " inclination of the string. The baseline of the string is parallel\n"
19425  " to a line joining (\n"
19426  " x,\n"
19427  " y) to (\n"
19428  " x+\n"
19429  " dx,\n"
19430  " y+\n"
19431  " dy) .\n"
19432  "\n"
19433  " dy (PLFLT, input) : Together with dx, this specifies the\n"
19434  " inclination of the string.\n"
19435  "\n"
19436  " just (PLFLT, input) : Specifies the position of the string relative\n"
19437  " to its reference point. If just=0. , the reference point is at\n"
19438  " the left and if just=1. , it is at the right of the string. Other\n"
19439  " values of just give intermediate justifications.\n"
19440  "\n"
19441  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19442  " written out.\n"
19443  "\n"
19444  ""},
19445  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
19446  "Write text inside the viewport of a 3D plot\n"
19447  "\n"
19448  "DESCRIPTION:\n"
19449  "\n"
19450  " Writes text at a specified position and inclination and with a\n"
19451  " specified shear within the viewport. Text is clipped at the viewport\n"
19452  " boundaries. The reference point of a string lies along a line passing\n"
19453  " through the string at half the height of a capital letter. The\n"
19454  " position of the reference point along this line is determined by just,\n"
19455  " and the reference point is placed at world coordinates (\n"
19456  " wx,\n"
19457  " wy,\n"
19458  " wz) within the viewport. The inclination and shear of the string is\n"
19459  " specified in terms of differences of world coordinates making it easy\n"
19460  " to write text parallel to a line in a graph.\n"
19461  "\n"
19462  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19463  "\n"
19464  " This function is used in example 28.\n"
19465  "\n"
19466  "\n"
19467  "\n"
19468  "SYNOPSIS:\n"
19469  "\n"
19470  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19471  "\n"
19472  "ARGUMENTS:\n"
19473  "\n"
19474  " wx (PLFLT, input) : x world coordinate of reference point of\n"
19475  " string.\n"
19476  "\n"
19477  " wy (PLFLT, input) : y world coordinate of reference point of\n"
19478  " string.\n"
19479  "\n"
19480  " wz (PLFLT, input) : z world coordinate of reference point of\n"
19481  " string.\n"
19482  "\n"
19483  " dx (PLFLT, input) : Together with dy and\n"
19484  " dz , this specifies the inclination of the string. The baseline of\n"
19485  " the string is parallel to a line joining (\n"
19486  " x,\n"
19487  " y,\n"
19488  " z) to (\n"
19489  " x+\n"
19490  " dx,\n"
19491  " y+\n"
19492  " dy,\n"
19493  " z+\n"
19494  " dz) .\n"
19495  "\n"
19496  " dy (PLFLT, input) : Together with dx and\n"
19497  " dz, this specifies the inclination of the string.\n"
19498  "\n"
19499  " dz (PLFLT, input) : Together with dx and\n"
19500  " dy, this specifies the inclination of the string.\n"
19501  "\n"
19502  " sx (PLFLT, input) : Together with sy and\n"
19503  " sz , this specifies the shear of the string. The string is sheared so\n"
19504  " that the characters are vertically parallel to a line joining (\n"
19505  " x,\n"
19506  " y,\n"
19507  " z) to (\n"
19508  " x+\n"
19509  " sx,\n"
19510  " y+\n"
19511  " sy,\n"
19512  " z+\n"
19513  " sz) . If sx =\n"
19514  " sy =\n"
19515  " sz = 0.) then the text is not sheared.\n"
19516  "\n"
19517  " sy (PLFLT, input) : Together with sx and\n"
19518  " sz, this specifies shear of the string.\n"
19519  "\n"
19520  " sz (PLFLT, input) : Together with sx and\n"
19521  " sy, this specifies shear of the string.\n"
19522  "\n"
19523  " just (PLFLT, input) : Specifies the position of the string relative\n"
19524  " to its reference point. If just=0. , the reference point is at\n"
19525  " the left and if just=1. , it is at the right of the string. Other\n"
19526  " values of just give intermediate justifications.\n"
19527  "\n"
19528  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19529  " written out.\n"
19530  "\n"
19531  ""},
19532  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
19533  "Random number generator returning a real random number in the range [0,1]\n"
19534  "\n"
19535  "DESCRIPTION:\n"
19536  "\n"
19537  " Random number generator returning a real random number in the range\n"
19538  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19539  " / compilers provide their own random number generator, and so this is\n"
19540  " provided purely for convenience and to give a consistent random number\n"
19541  " generator across all languages supported by PLplot. This is\n"
19542  " particularly useful for comparing results from the test suite of\n"
19543  " examples.\n"
19544  "\n"
19545  " Redacted form: plrandd()\n"
19546  "\n"
19547  " This function is used in examples 17 and 21.\n"
19548  "\n"
19549  "\n"
19550  "\n"
19551  "SYNOPSIS:\n"
19552  "\n"
19553  "plrandd()\n"
19554  "\n"
19555  ""},
19556  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
19557  "Replays contents of plot buffer to current device/file\n"
19558  "\n"
19559  "DESCRIPTION:\n"
19560  "\n"
19561  " Replays contents of plot buffer to current device/file.\n"
19562  "\n"
19563  " Redacted form: plreplot()\n"
19564  "\n"
19565  " This function is used in example 1,20.\n"
19566  "\n"
19567  "\n"
19568  "\n"
19569  "SYNOPSIS:\n"
19570  "\n"
19571  "plreplot()\n"
19572  "\n"
19573  ""},
19574  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
19575  "Convert RGB color to HLS\n"
19576  "\n"
19577  "DESCRIPTION:\n"
19578  "\n"
19579  " Convert RGB color coordinates to HLS\n"
19580  "\n"
19581  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19582  "\n"
19583  "\n"
19584  " This function is used in example 2.\n"
19585  "\n"
19586  "\n"
19587  "\n"
19588  "SYNOPSIS:\n"
19589  "\n"
19590  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19591  "\n"
19592  "ARGUMENTS:\n"
19593  "\n"
19594  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19595  "\n"
19596  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19597  "\n"
19598  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19599  "\n"
19600  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19601  " degrees (0.0-360.0) on the color cylinder.\n"
19602  "\n"
19603  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19604  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19605  " cylinder.\n"
19606  "\n"
19607  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19608  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19609  " cylinder.\n"
19610  "\n"
19611  ""},
19612  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
19613  "Set character size\n"
19614  "\n"
19615  "DESCRIPTION:\n"
19616  "\n"
19617  " This sets up the size of all subsequent characters drawn. The actual\n"
19618  " height of a character is the product of the default character size and\n"
19619  " a scaling factor.\n"
19620  "\n"
19621  " Redacted form: plschr(def, scale)\n"
19622  "\n"
19623  " This function is used in examples 2, 13, 23, and 24.\n"
19624  "\n"
19625  "\n"
19626  "\n"
19627  "SYNOPSIS:\n"
19628  "\n"
19629  "plschr(def, scale)\n"
19630  "\n"
19631  "ARGUMENTS:\n"
19632  "\n"
19633  " def (PLFLT, input) : The default height of a character in\n"
19634  " millimeters, should be set to zero if the default height is to\n"
19635  " remain unchanged. For rasterized drivers the dx and dy values\n"
19636  " specified in plspage are used to convert from mm to pixels (note\n"
19637  " the different unit systems used). This dpi aware scaling is not\n"
19638  " implemented for all drivers yet.\n"
19639  "\n"
19640  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19641  " actual character height.\n"
19642  "\n"
19643  ""},
19644  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
19645  "Set cmap0 colors by 8-bit RGB values\n"
19646  "\n"
19647  "DESCRIPTION:\n"
19648  "\n"
19649  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19650  " documentation). This sets the entire color map -- only as many colors\n"
19651  " as specified will be allocated.\n"
19652  "\n"
19653  " Redacted form: plscmap0(r, g, b)\n"
19654  "\n"
19655  " This function is used in examples 2 and 24.\n"
19656  "\n"
19657  "\n"
19658  "\n"
19659  "SYNOPSIS:\n"
19660  "\n"
19661  "plscmap0(r, g, b, ncol0)\n"
19662  "\n"
19663  "ARGUMENTS:\n"
19664  "\n"
19665  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19666  " integers (0-255) representing the degree of red in the color.\n"
19667  "\n"
19668  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19669  " integers (0-255) representing the degree of green in the color.\n"
19670  "\n"
19671  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19672  " integers (0-255) representing the degree of blue in the color.\n"
19673  "\n"
19674  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19675  "\n"
19676  ""},
19677  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
19678  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19679  "\n"
19680  "DESCRIPTION:\n"
19681  "\n"
19682  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19683  " and PLFLT alpha transparency value. This sets the entire color map --\n"
19684  " only as many colors as specified will be allocated.\n"
19685  "\n"
19686  " Redacted form: plscmap0a(r, g, b, alpha)\n"
19687  "\n"
19688  " This function is used in examples 30.\n"
19689  "\n"
19690  "\n"
19691  "\n"
19692  "SYNOPSIS:\n"
19693  "\n"
19694  "plscmap0a(r, g, b, alpha, ncol0)\n"
19695  "\n"
19696  "ARGUMENTS:\n"
19697  "\n"
19698  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19699  " integers (0-255) representing the degree of red in the color.\n"
19700  "\n"
19701  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19702  " integers (0-255) representing the degree of green in the color.\n"
19703  "\n"
19704  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19705  " integers (0-255) representing the degree of blue in the color.\n"
19706  "\n"
19707  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19708  " representing the alpha transparency of the color.\n"
19709  "\n"
19710  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19711  " vectors.\n"
19712  "\n"
19713  ""},
19714  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
19715  "Set number of colors in cmap0\n"
19716  "\n"
19717  "DESCRIPTION:\n"
19718  "\n"
19719  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19720  " (or reallocate) cmap0, and fill with default values for those colors\n"
19721  " not previously allocated. The first 16 default colors are given in\n"
19722  " the plcol0 documentation. For larger indices the default color is\n"
19723  " red.\n"
19724  "\n"
19725  " The drivers are not guaranteed to support more than 16 colors.\n"
19726  "\n"
19727  " Redacted form: plscmap0n(ncol0)\n"
19728  "\n"
19729  " This function is used in examples 15, 16, and 24.\n"
19730  "\n"
19731  "\n"
19732  "\n"
19733  "SYNOPSIS:\n"
19734  "\n"
19735  "plscmap0n(ncol0)\n"
19736  "\n"
19737  "ARGUMENTS:\n"
19738  "\n"
19739  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19740  " the cmap0 palette. If this number is zero or less, then the value\n"
19741  " from the previous call to plscmap0n is used and if there is no\n"
19742  " previous call, then a default value is used.\n"
19743  "\n"
19744  ""},
19745  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19746  "Set opaque RGB cmap1 colors values\n"
19747  "\n"
19748  "DESCRIPTION:\n"
19749  "\n"
19750  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19751  " vector values. This function also sets the number of cmap1 colors.\n"
19752  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19753  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19754  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19755  " to\n"
19756  " ncol1-1. So in order for this continuous color model to work\n"
19757  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19758  " that these RGB vectors are continuous functions of their integer\n"
19759  " indices.\n"
19760  "\n"
19761  " Redacted form: plscmap1(r, g, b)\n"
19762  "\n"
19763  " This function is used in example 31.\n"
19764  "\n"
19765  "\n"
19766  "\n"
19767  "SYNOPSIS:\n"
19768  "\n"
19769  "plscmap1(r, g, b, ncol1)\n"
19770  "\n"
19771  "ARGUMENTS:\n"
19772  "\n"
19773  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19774  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19775  " color as a continuous function of the integer index of the vector.\n"
19776  "\n"
19777  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19778  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19779  " color as a continuous function of the integer index of the vector.\n"
19780  "\n"
19781  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19782  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19783  " color as a continuous function of the integer index of the vector.\n"
19784  "\n"
19785  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19786  "\n"
19787  ""},
19788  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19789  "Set semitransparent cmap1 RGBA colors.\n"
19790  "\n"
19791  "DESCRIPTION:\n"
19792  "\n"
19793  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19794  " RGBA vector values. This function also sets the number of cmap1\n"
19795  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19796  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19797  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19798  " vectors in the range from 0 to\n"
19799  " ncol1-1. So in order for this continuous color model to work\n"
19800  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19801  " that these RGBA vectors are continuous functions of their integer\n"
19802  " indices.\n"
19803  "\n"
19804  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19805  "\n"
19806  " This function is used in example 31.\n"
19807  "\n"
19808  "\n"
19809  "\n"
19810  "SYNOPSIS:\n"
19811  "\n"
19812  "plscmap1a(r, g, b, alpha, ncol1)\n"
19813  "\n"
19814  "ARGUMENTS:\n"
19815  "\n"
19816  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19817  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19818  " color as a continuous function of the integer index of the vector.\n"
19819  "\n"
19820  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19821  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19822  " color as a continuous function of the integer index of the vector.\n"
19823  "\n"
19824  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19825  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19826  " color as a continuous function of the integer index of the vector.\n"
19827  "\n"
19828  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19829  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19830  " completely transparent and 1.0 corresponds to completely opaque)\n"
19831  " the alpha transparency of the color as a continuous function of\n"
19832  " the integer index of the vector.\n"
19833  "\n"
19834  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19835  " vectors.\n"
19836  "\n"
19837  ""},
19838  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19839  "Set cmap1 colors using a piece-wise linear relationship\n"
19840  "\n"
19841  "DESCRIPTION:\n"
19842  "\n"
19843  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19844  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19845  " (see the PLplot documentation). May be called at any time.\n"
19846  "\n"
19847  " The idea here is to specify a number of control points that define the\n"
19848  " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19849  " these points, linear interpolation is used which gives a smooth\n"
19850  " variation of color with intensity index. Any number of control points\n"
19851  " may be specified, located at arbitrary positions, although typically 2\n"
19852  " - 4 are enough. Another way of stating this is that we are traversing\n"
19853  " a given number of lines through HLS or RGB space as we move through\n"
19854  " cmap1 intensity indices. The control points at the minimum and\n"
19855  " maximum position (0 and 1) must always be specified. By adding more\n"
19856  " control points you can get more variation. One good technique for\n"
19857  " plotting functions that vary about some expected average is to use an\n"
19858  " additional 2 control points in the center (position ~= 0.5) that are\n"
19859  " the same lightness as the background (typically white for paper\n"
19860  " output, black for crt), and same hue as the boundary control points.\n"
19861  " This allows the highs and lows to be very easily distinguished.\n"
19862  "\n"
19863  " Each control point must specify the cmap1 intensity index and the\n"
19864  " associated three coordinates in HLS or RGB space. The first point\n"
19865  " must correspond to position = 0, and the last to position = 1.\n"
19866  "\n"
19867  " If RGB colors are provided then the interpolation takes place in RGB\n"
19868  " space and is trivial. However if HLS colors are provided then, because\n"
19869  " of the circular nature of the color wheel for the hue coordinate, the\n"
19870  " interpolation could be performed in either direction around the color\n"
19871  " wheel. The default behaviour is for the hue to be linearly\n"
19872  " interpolated ignoring this circular property of hue. So for example,\n"
19873  " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19874  " green and cyan. If instead you wish to interpolate the other way\n"
19875  " around the color wheel you have two options. You may provide hues\n"
19876  " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19877  " for red the interpolation will proceed via magenta. Alternatively you\n"
19878  " can utilise the alt_hue_path variable to reverse the direction of\n"
19879  " interpolation if you need to provide hues within the [0-360) range.\n"
19880  "\n"
19881  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19882  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19883  " -120]falsegreen-yellow-red-magenta-blue[240\n"
19884  " 480]falseblue-magenta-red-yellow-green[120\n"
19885  " 240]truegreen-yellow-red-magenta-blue[240\n"
19886  " 120]trueblue-magenta-red-yellow-green\n"
19887  "\n"
19888  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19889  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19890  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19891  "\n"
19892  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19893  " alt_hue_path)\n"
19894  "\n"
19895  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19896  "\n"
19897  "\n"
19898  "\n"
19899  "SYNOPSIS:\n"
19900  "\n"
19901  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19902  "\n"
19903  "ARGUMENTS:\n"
19904  "\n"
19905  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19906  "\n"
19907  " npts (PLINT, input) : number of control points\n"
19908  "\n"
19909  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19910  " intensity index (0.0-1.0) in ascending order for each control\n"
19911  " point.\n"
19912  "\n"
19913  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19914  " coordinate (H or R) for each control point.\n"
19915  "\n"
19916  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19917  " coordinate (L or G) for each control point.\n"
19918  "\n"
19919  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19920  " coordinate (S or B) for each control point.\n"
19921  "\n"
19922  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19923  " npts - 1 elements), each containing either true to use the reversed\n"
19924  " HLS interpolation or false to use the regular HLS interpolation.\n"
19925  " (alt_hue_path[i] refers to the interpolation interval between the\n"
19926  " i and i + 1 control points). This parameter is not used for RGB\n"
19927  " colors (\n"
19928  " itype = true).\n"
19929  "\n"
19930  ""},
19931  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19932  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19933  "\n"
19934  "DESCRIPTION:\n"
19935  "\n"
19936  " This is a variant of plscmap1l that supports alpha channel\n"
19937  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19938  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19939  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19940  " transparency value (0.0-1.0). It may be called at any time.\n"
19941  "\n"
19942  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19943  " alpha, alt_hue_path)\n"
19944  "\n"
19945  " This function is used in example 30.\n"
19946  "\n"
19947  "\n"
19948  "\n"
19949  "SYNOPSIS:\n"
19950  "\n"
19951  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19952  "\n"
19953  "ARGUMENTS:\n"
19954  "\n"
19955  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19956  "\n"
19957  " npts (PLINT, input) : number of control points.\n"
19958  "\n"
19959  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19960  " intensity index (0.0-1.0) in ascending order for each control\n"
19961  " point.\n"
19962  "\n"
19963  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19964  " coordinate (H or R) for each control point.\n"
19965  "\n"
19966  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19967  " coordinate (L or G) for each control point.\n"
19968  "\n"
19969  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19970  " coordinate (S or B) for each control point.\n"
19971  "\n"
19972  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19973  " transparency value (0.0-1.0) for each control point.\n"
19974  "\n"
19975  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19976  " npts - 1 elements) containing the alternative interpolation method\n"
19977  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19978  " refers to the interpolation interval between the i and i + 1\n"
19979  " control points).\n"
19980  "\n"
19981  ""},
19982  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19983  "Set number of colors in cmap1\n"
19984  "\n"
19985  "DESCRIPTION:\n"
19986  "\n"
19987  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19988  " values if this is the first allocation (see the PLplot documentation).\n"
19989  "\n"
19990  " Redacted form: plscmap1n(ncol1)\n"
19991  "\n"
19992  " This function is used in examples 8, 11, 20, and 21.\n"
19993  "\n"
19994  "\n"
19995  "\n"
19996  "SYNOPSIS:\n"
19997  "\n"
19998  "plscmap1n(ncol1)\n"
19999  "\n"
20000  "ARGUMENTS:\n"
20001  "\n"
20002  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20003  " the cmap1 palette. If this number is zero or less, then the value\n"
20004  " from the previous call to plscmap1n is used and if there is no\n"
20005  " previous call, then a default value is used.\n"
20006  "\n"
20007  ""},
20008  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
20009  "Set the cmap1 argument range for continuous color plots\n"
20010  "\n"
20011  "DESCRIPTION:\n"
20012  "\n"
20013  " Set the cmap1 argument range for continuous color plots that\n"
20014  " corresponds to the range of data values. The maximum range\n"
20015  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20016  " the cmap1 argument range that is specified with this routine, the\n"
20017  " smaller the subset of the cmap1 color palette that is used to\n"
20018  " represent the continuous data being plotted. If\n"
20019  " min_color is greater than\n"
20020  " max_color or\n"
20021  " max_color is greater than 1.0 or\n"
20022  " min_color is less than 0.0 then no change is made to the cmap1\n"
20023  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20024  "\n"
20025  " Redacted form: plscmap1_range(min_color, max_color)\n"
20026  "\n"
20027  " This function is currently used in example 33.\n"
20028  "\n"
20029  "\n"
20030  "\n"
20031  "SYNOPSIS:\n"
20032  "\n"
20033  "plscmap1_range(min_color, max_color)\n"
20034  "\n"
20035  "ARGUMENTS:\n"
20036  "\n"
20037  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20038  " than 0.0, then 0.0 is used instead.\n"
20039  "\n"
20040  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20041  " than 1.0, then 1.0 is used instead.\n"
20042  "\n"
20043  ""},
20044  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
20045  "Get the cmap1 argument range for continuous color plots\n"
20046  "\n"
20047  "DESCRIPTION:\n"
20048  "\n"
20049  " Get the cmap1 argument range for continuous color plots. (Use\n"
20050  " plscmap1_range to set the cmap1 argument range.)\n"
20051  "\n"
20052  " Redacted form: plgcmap1_range(min_color, max_color)\n"
20053  "\n"
20054  " This function is currently not used in any example.\n"
20055  "\n"
20056  "\n"
20057  "\n"
20058  "SYNOPSIS:\n"
20059  "\n"
20060  "plgcmap1_range(min_color, max_color)\n"
20061  "\n"
20062  "ARGUMENTS:\n"
20063  "\n"
20064  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20065  " minimum cmap1 argument.\n"
20066  "\n"
20067  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20068  " maximum cmap1 argument.\n"
20069  "\n"
20070  ""},
20071  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
20072  "Set 8-bit RGB values for given cmap0 color index\n"
20073  "\n"
20074  "DESCRIPTION:\n"
20075  "\n"
20076  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20077  " index. Overwrites the previous color value for the given index and,\n"
20078  " thus, does not result in any additional allocation of space for\n"
20079  " colors.\n"
20080  "\n"
20081  " Redacted form: plscol0(icol0, r, g, b)\n"
20082  "\n"
20083  " This function is used in any example 31.\n"
20084  "\n"
20085  "\n"
20086  "\n"
20087  "SYNOPSIS:\n"
20088  "\n"
20089  "plscol0(icol0, r, g, b)\n"
20090  "\n"
20091  "ARGUMENTS:\n"
20092  "\n"
20093  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20094  " number of colors (which is set by default, by plscmap0n, or even\n"
20095  " by plscmap0).\n"
20096  "\n"
20097  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20098  " degree of red in the color.\n"
20099  "\n"
20100  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20101  " degree of green in the color.\n"
20102  "\n"
20103  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20104  " degree of blue in the color.\n"
20105  "\n"
20106  ""},
20107  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
20108  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20109  "\n"
20110  "DESCRIPTION:\n"
20111  "\n"
20112  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20113  " (see the PLplot documentation) index. Overwrites the previous color\n"
20114  " value for the given index and, thus, does not result in any additional\n"
20115  " allocation of space for colors.\n"
20116  "\n"
20117  " This function is used in example 30.\n"
20118  "\n"
20119  "\n"
20120  "\n"
20121  "SYNOPSIS:\n"
20122  "\n"
20123  "plscol0a(icol0, r, g, b, alpha)\n"
20124  "\n"
20125  "ARGUMENTS:\n"
20126  "\n"
20127  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20128  " number of colors (which is set by default, by plscmap0n, or even\n"
20129  " by plscmap0).\n"
20130  "\n"
20131  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20132  " degree of red in the color.\n"
20133  "\n"
20134  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20135  " degree of green in the color.\n"
20136  "\n"
20137  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20138  " degree of blue in the color.\n"
20139  "\n"
20140  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20141  " (0.0-1.0).\n"
20142  "\n"
20143  ""},
20144  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
20145  "Set the background color by 8-bit RGB value\n"
20146  "\n"
20147  "DESCRIPTION:\n"
20148  "\n"
20149  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20150  " the PLplot documentation).\n"
20151  "\n"
20152  " Redacted form: plscolbg(r, g, b)\n"
20153  "\n"
20154  " This function is used in examples 15 and 31.\n"
20155  "\n"
20156  "\n"
20157  "\n"
20158  "SYNOPSIS:\n"
20159  "\n"
20160  "plscolbg(r, g, b)\n"
20161  "\n"
20162  "ARGUMENTS:\n"
20163  "\n"
20164  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20165  " degree of red in the color.\n"
20166  "\n"
20167  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20168  " degree of green in the color.\n"
20169  "\n"
20170  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20171  " degree of blue in the color.\n"
20172  "\n"
20173  ""},
20174  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
20175  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20176  "\n"
20177  "DESCRIPTION:\n"
20178  "\n"
20179  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20180  " PLFLT alpha transparency value (see the PLplot documentation).\n"
20181  "\n"
20182  " This function is used in example 31.\n"
20183  "\n"
20184  "\n"
20185  "\n"
20186  "SYNOPSIS:\n"
20187  "\n"
20188  "plscolbga(r, g, b, alpha)\n"
20189  "\n"
20190  "ARGUMENTS:\n"
20191  "\n"
20192  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20193  " degree of red in the color.\n"
20194  "\n"
20195  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20196  " degree of green in the color.\n"
20197  "\n"
20198  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20199  " degree of blue in the color.\n"
20200  "\n"
20201  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20202  " (0.0-1.0).\n"
20203  "\n"
20204  ""},
20205  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
20206  "Used to globally turn color output on/off\n"
20207  "\n"
20208  "DESCRIPTION:\n"
20209  "\n"
20210  " Used to globally turn color output on/off for those drivers/devices\n"
20211  " that support it.\n"
20212  "\n"
20213  " Redacted form: plscolor(color)\n"
20214  "\n"
20215  " This function is used in example 31.\n"
20216  "\n"
20217  "\n"
20218  "\n"
20219  "SYNOPSIS:\n"
20220  "\n"
20221  "plscolor(color)\n"
20222  "\n"
20223  "ARGUMENTS:\n"
20224  "\n"
20225  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20226  " turned off. If non-zero, color is turned on.\n"
20227  "\n"
20228  ""},
20229  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
20230  "Set device-compression level\n"
20231  "\n"
20232  "DESCRIPTION:\n"
20233  "\n"
20234  " Set device-compression level. Only used for drivers that provide\n"
20235  " compression. This function, if used, should be invoked before a call\n"
20236  " to plinit.\n"
20237  "\n"
20238  " Redacted form: plscompression(compression)\n"
20239  "\n"
20240  " This function is used in example 31.\n"
20241  "\n"
20242  "\n"
20243  "\n"
20244  "SYNOPSIS:\n"
20245  "\n"
20246  "plscompression(compression)\n"
20247  "\n"
20248  "ARGUMENTS:\n"
20249  "\n"
20250  " compression (PLINT, input) : The desired compression level. This is\n"
20251  " a device-dependent value. Currently only the jpeg and png devices\n"
20252  " use these values. For jpeg value is the jpeg quality which should\n"
20253  " normally be in the range 0-95. Higher values denote higher quality\n"
20254  " and hence larger image sizes. For png values are in the range -1\n"
20255  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20256  " A value of -1 denotes the default zlib compression level. Values\n"
20257  " in the range 10-99 are divided by 10 and then used as the zlib\n"
20258  " compression level. Higher compression levels correspond to greater\n"
20259  " compression and small file sizes at the expense of more\n"
20260  " computation.\n"
20261  "\n"
20262  ""},
20263  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
20264  "Set the device (keyword) name\n"
20265  "\n"
20266  "DESCRIPTION:\n"
20267  "\n"
20268  " Set the device (keyword) name.\n"
20269  "\n"
20270  " Redacted form: plsdev(devname)\n"
20271  "\n"
20272  " This function is used in examples 1, 14, and 20.\n"
20273  "\n"
20274  "\n"
20275  "\n"
20276  "SYNOPSIS:\n"
20277  "\n"
20278  "plsdev(devname)\n"
20279  "\n"
20280  "ARGUMENTS:\n"
20281  "\n"
20282  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20283  " containing the device name keyword of the required output device.\n"
20284  " If\n"
20285  " devname is NULL or if the first character of the string is a ``?'',\n"
20286  " the normal (prompted) start up is used.\n"
20287  "\n"
20288  ""},
20289  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
20290  "Set parameters that define current device-space window\n"
20291  "\n"
20292  "DESCRIPTION:\n"
20293  "\n"
20294  " Set relative margin width, aspect ratio, and relative justification\n"
20295  " that define current device-space window. If you want to just use the\n"
20296  " previous value for any of these, just pass in the magic value\n"
20297  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20298  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20299  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20300  " to a device-specific value.\n"
20301  "\n"
20302  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20303  "\n"
20304  " This function is used in example 31.\n"
20305  "\n"
20306  "\n"
20307  "\n"
20308  "SYNOPSIS:\n"
20309  "\n"
20310  "plsdidev(mar, aspect, jx, jy)\n"
20311  "\n"
20312  "ARGUMENTS:\n"
20313  "\n"
20314  " mar (PLFLT, input) : Relative margin width.\n"
20315  "\n"
20316  " aspect (PLFLT, input) : Aspect ratio.\n"
20317  "\n"
20318  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20319  " the range -0.5 to 0.5.\n"
20320  "\n"
20321  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20322  " the range -0.5 to 0.5.\n"
20323  "\n"
20324  ""},
20325  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
20326  "Set up transformation from metafile coordinates\n"
20327  "\n"
20328  "DESCRIPTION:\n"
20329  "\n"
20330  " Set up transformation from metafile coordinates. The size of the plot\n"
20331  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20332  " general-purpose facility just yet (not sure why the user would need\n"
20333  " it, for one).\n"
20334  "\n"
20335  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20336  " dimypmm)\n"
20337  "\n"
20338  " This function is not used in any examples.\n"
20339  "\n"
20340  "\n"
20341  "\n"
20342  "SYNOPSIS:\n"
20343  "\n"
20344  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20345  "\n"
20346  "ARGUMENTS:\n"
20347  "\n"
20348  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20349  "\n"
20350  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20351  "\n"
20352  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20353  "\n"
20354  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20355  "\n"
20356  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20357  "\n"
20358  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20359  "\n"
20360  ""},
20361  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
20362  "Set plot orientation\n"
20363  "\n"
20364  "DESCRIPTION:\n"
20365  "\n"
20366  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20367  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20368  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20369  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20370  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20371  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20372  " not called the default value of rot is 0.\n"
20373  "\n"
20374  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20375  " probably want to change the aspect ratio to a value suitable for the\n"
20376  " plot orientation using a call to plsdidev or the command-line options\n"
20377  " -a or -freeaspect. For more documentation of those options see the\n"
20378  " PLplot documentation. Such command-line options can be set internally\n"
20379  " using plsetopt or set directly using the command line and parsed using\n"
20380  " a call to plparseopts.\n"
20381  "\n"
20382  " Redacted form: plsdiori(rot)\n"
20383  "\n"
20384  " This function is not used in any examples.\n"
20385  "\n"
20386  "\n"
20387  "\n"
20388  "SYNOPSIS:\n"
20389  "\n"
20390  "plsdiori(rot)\n"
20391  "\n"
20392  "ARGUMENTS:\n"
20393  "\n"
20394  " rot (PLFLT, input) : Plot orientation parameter.\n"
20395  "\n"
20396  ""},
20397  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
20398  "Set parameters that define current plot-space window\n"
20399  "\n"
20400  "DESCRIPTION:\n"
20401  "\n"
20402  " Set relative minima and maxima that define the current plot-space\n"
20403  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20404  " xmax, and ymax are 0., 0., 1., and 1.\n"
20405  "\n"
20406  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20407  "\n"
20408  " This function is used in example 31.\n"
20409  "\n"
20410  "\n"
20411  "\n"
20412  "SYNOPSIS:\n"
20413  "\n"
20414  "plsdiplt(xmin, ymin, xmax, ymax)\n"
20415  "\n"
20416  "ARGUMENTS:\n"
20417  "\n"
20418  " xmin (PLFLT, input) : Relative minimum in x.\n"
20419  "\n"
20420  " ymin (PLFLT, input) : Relative minimum in y.\n"
20421  "\n"
20422  " xmax (PLFLT, input) : Relative maximum in x.\n"
20423  "\n"
20424  " ymax (PLFLT, input) : Relative maximum in y.\n"
20425  "\n"
20426  ""},
20427  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
20428  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20429  "\n"
20430  "DESCRIPTION:\n"
20431  "\n"
20432  " Set relative minima and maxima incrementally (zoom mode) that define\n"
20433  " the current plot-space window. This function has the same effect as\n"
20434  " plsdiplt if that function has not been previously called. Otherwise,\n"
20435  " this function implements zoom mode using the transformation min_used =\n"
20436  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20437  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20438  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20439  "\n"
20440  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20441  "\n"
20442  " This function is used in example 31.\n"
20443  "\n"
20444  "\n"
20445  "\n"
20446  "SYNOPSIS:\n"
20447  "\n"
20448  "plsdiplz(xmin, ymin, xmax, ymax)\n"
20449  "\n"
20450  "ARGUMENTS:\n"
20451  "\n"
20452  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20453  "\n"
20454  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20455  "\n"
20456  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20457  "\n"
20458  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20459  "\n"
20460  ""},
20461  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
20462  "Set seed for internal random number generator.\n"
20463  "\n"
20464  "DESCRIPTION:\n"
20465  "\n"
20466  " Set the seed for the internal random number generator. See plrandd for\n"
20467  " further details.\n"
20468  "\n"
20469  " Redacted form: plseed(seed)\n"
20470  "\n"
20471  " This function is used in example 21.\n"
20472  "\n"
20473  "\n"
20474  "\n"
20475  "SYNOPSIS:\n"
20476  "\n"
20477  "plseed(seed)\n"
20478  "\n"
20479  "ARGUMENTS:\n"
20480  "\n"
20481  " seed (unsigned int, input) : Seed for random number generator.\n"
20482  "\n"
20483  ""},
20484  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
20485  "Set the escape character for text strings\n"
20486  "\n"
20487  "DESCRIPTION:\n"
20488  "\n"
20489  " Set the escape character for text strings. From C (in contrast to\n"
20490  " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20491  " characters are allowed to prevent the user from shooting himself in\n"
20492  " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20493  " use of backslash as a character escape). Here are the allowed escape\n"
20494  " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20495  " #, ASCII 35\n"
20496  " $, ASCII 36\n"
20497  " %, ASCII 37\n"
20498  " &, ASCII 38\n"
20499  " *, ASCII 42\n"
20500  " @, ASCII 64\n"
20501  " ^, ASCII 94\n"
20502  " ~, ASCII 126\n"
20503  "\n"
20504  "\n"
20505  " Redacted form: General: plsesc(esc)\n"
20506  "\n"
20507  "\n"
20508  " This function is used in example 29.\n"
20509  "\n"
20510  "\n"
20511  "\n"
20512  "SYNOPSIS:\n"
20513  "\n"
20514  "plsesc(esc)\n"
20515  "\n"
20516  "ARGUMENTS:\n"
20517  "\n"
20518  " esc (char, input) : Escape character.\n"
20519  "\n"
20520  ""},
20521  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
20522  "Set any command-line option\n"
20523  "\n"
20524  "DESCRIPTION:\n"
20525  "\n"
20526  " Set any command-line option internally from a program before it\n"
20527  " invokes plinit. opt is the name of the command-line option and optarg\n"
20528  " is the corresponding command-line option argument.\n"
20529  "\n"
20530  " This function returns 0 on success.\n"
20531  "\n"
20532  " Redacted form: plsetopt(opt, optarg)\n"
20533  "\n"
20534  " This function is used in example 14.\n"
20535  "\n"
20536  "\n"
20537  "\n"
20538  "SYNOPSIS:\n"
20539  "\n"
20540  "PLINT plsetopt(opt, optarg)\n"
20541  "\n"
20542  "ARGUMENTS:\n"
20543  "\n"
20544  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20545  " the command-line option.\n"
20546  "\n"
20547  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20548  " containing the argument of the command-line option.\n"
20549  "\n"
20550  ""},
20551  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
20552  "Set family file parameters\n"
20553  "\n"
20554  "DESCRIPTION:\n"
20555  "\n"
20556  " Sets variables dealing with output file familying. Does nothing if\n"
20557  " familying not supported by the driver. This routine, if used, must be\n"
20558  " called before initializing PLplot. See the PLplot documentation for\n"
20559  " more information.\n"
20560  "\n"
20561  " Redacted form: plsfam(fam, num, bmax)\n"
20562  "\n"
20563  " This function is used in examples 14 and 31.\n"
20564  "\n"
20565  "\n"
20566  "\n"
20567  "SYNOPSIS:\n"
20568  "\n"
20569  "plsfam(fam, num, bmax)\n"
20570  "\n"
20571  "ARGUMENTS:\n"
20572  "\n"
20573  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20574  " is enabled.\n"
20575  "\n"
20576  " num (PLINT, input) : Current family file number.\n"
20577  "\n"
20578  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20579  " file.\n"
20580  "\n"
20581  ""},
20582  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
20583  "Set FCI (font characterization integer)\n"
20584  "\n"
20585  "DESCRIPTION:\n"
20586  "\n"
20587  " Sets font characteristics to be used at the start of the next string\n"
20588  " using the FCI approach. See the PLplot documentation for more\n"
20589  " information. Note, plsfont (which calls plsfci internally) provides a\n"
20590  " more user-friendly API for setting the font characterisitics.\n"
20591  "\n"
20592  " Redacted form: General: plsfci(fci)\n"
20593  "\n"
20594  "\n"
20595  " This function is used in example 23.\n"
20596  "\n"
20597  "\n"
20598  "\n"
20599  "SYNOPSIS:\n"
20600  "\n"
20601  "plsfci(fci)\n"
20602  "\n"
20603  "ARGUMENTS:\n"
20604  "\n"
20605  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20606  " of FCI.\n"
20607  "\n"
20608  ""},
20609  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
20610  "Set output file name\n"
20611  "\n"
20612  "DESCRIPTION:\n"
20613  "\n"
20614  " Sets the current output file name, if applicable. If the file name\n"
20615  " has not been specified and is required by the driver, the user will be\n"
20616  " prompted for it. If using the X-windows output driver, this sets the\n"
20617  " display name. This routine, if used, must be called before\n"
20618  " initializing PLplot.\n"
20619  "\n"
20620  " Redacted form: plsfnam(fnam)\n"
20621  "\n"
20622  " This function is used in examples 1 and 20.\n"
20623  "\n"
20624  "\n"
20625  "\n"
20626  "SYNOPSIS:\n"
20627  "\n"
20628  "plsfnam(fnam)\n"
20629  "\n"
20630  "ARGUMENTS:\n"
20631  "\n"
20632  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20633  " the file name.\n"
20634  "\n"
20635  ""},
20636  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
20637  "Set family, style and weight of the current font\n"
20638  "\n"
20639  "DESCRIPTION:\n"
20640  "\n"
20641  " Sets the current font. See the PLplot documentation for more\n"
20642  " information on font selection.\n"
20643  "\n"
20644  " Redacted form: plsfont(family, style, weight)\n"
20645  "\n"
20646  " This function is used in example 23.\n"
20647  "\n"
20648  "\n"
20649  "\n"
20650  "SYNOPSIS:\n"
20651  "\n"
20652  "plsfont(family, style, weight)\n"
20653  "\n"
20654  "ARGUMENTS:\n"
20655  "\n"
20656  " family (PLINT, input) : Font family to select for the current font.\n"
20657  " The available values are given by the PL_FCI_* constants in\n"
20658  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20659  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20660  " signifies that the font family should not be altered.\n"
20661  "\n"
20662  " style (PLINT, input) : Font style to select for the current font.\n"
20663  " The available values are given by the PL_FCI_* constants in\n"
20664  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20665  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20666  " should not be altered.\n"
20667  "\n"
20668  " weight (PLINT, input) : Font weight to select for the current font.\n"
20669  " The available values are given by the PL_FCI_* constants in\n"
20670  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20671  " negative value signifies that the font weight should not be\n"
20672  " altered.\n"
20673  "\n"
20674  ""},
20675  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
20676  "Shade regions on the basis of value\n"
20677  "\n"
20678  "DESCRIPTION:\n"
20679  "\n"
20680  " Shade regions on the basis of value. This is the high-level routine\n"
20681  " for making continuous color shaded plots with cmap1 while plshade\n"
20682  " should be used to plot individual shaded regions using either cmap0 or\n"
20683  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20684  " our supported languages.\n"
20685  "\n"
20686  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20687  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20688  " pltr_data)\n"
20689  "\n"
20690  "\n"
20691  " This function is used in examples 16, 21, and 22.\n"
20692  "\n"
20693  "\n"
20694  "\n"
20695  "SYNOPSIS:\n"
20696  "\n"
20697  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20698  "\n"
20699  "ARGUMENTS:\n"
20700  "\n"
20701  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20702  " plot. Should have dimensions of\n"
20703  " nx by\n"
20704  " ny.\n"
20705  "\n"
20706  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20707  "\n"
20708  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20709  "\n"
20710  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20711  " the region that should be plotted in the shade plot. This\n"
20712  " function accepts x and y coordinates as input arguments and must\n"
20713  " return 1 if the point is to be included in the shade plot and 0\n"
20714  " otherwise. If you want to plot the entire shade plot (the usual\n"
20715  " case), this argument should be set to NULL.\n"
20716  "\n"
20717  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20718  " pltr below for how these arguments are used (only for the special case\n"
20719  " when the callback function\n"
20720  " pltr is not supplied).\n"
20721  "\n"
20722  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20723  " corresponding to the edges of each shaded region that will be\n"
20724  " plotted by this function. To work properly the levels should be\n"
20725  " monotonic.\n"
20726  "\n"
20727  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20728  " of shade edge values in clevel).\n"
20729  "\n"
20730  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20731  " pattern.\n"
20732  "\n"
20733  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20734  " contours defining edges of shaded regions. The pen color is only\n"
20735  " temporary set for the contour drawing. Set this value to zero or\n"
20736  " less if no shade edge contours are wanted.\n"
20737  "\n"
20738  " cont_width (PLFLT, input) : Defines line width used for contours\n"
20739  " defining edges of shaded regions. This value may not be honored\n"
20740  " by all drivers. The pen width is only temporary set for the\n"
20741  " contour drawing. Set this value to zero or less if no shade edge\n"
20742  " contours are wanted.\n"
20743  "\n"
20744  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20745  " region. Use plfill for this purpose.\n"
20746  "\n"
20747  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20748  " map to rectangles after coordinate transformation with pltrl.\n"
20749  " Otherwise, set rectangular to false. If rectangular is set to\n"
20750  " true, plshade tries to save time by filling large rectangles.\n"
20751  " This optimization fails if the coordinate transformation distorts\n"
20752  " the shape of rectangles. For example a plot in polar coordinates\n"
20753  " has to have rectangular set to false.\n"
20754  "\n"
20755  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20756  " defines the transformation between the zero-based indices of the\n"
20757  " matrix a and world coordinates. If\n"
20758  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20759  " indices of a are mapped to the range\n"
20760  " xmin through\n"
20761  " xmax and the y indices of a are mapped to the range\n"
20762  " ymin through\n"
20763  " ymax.For the C case, transformation functions are provided in the\n"
20764  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20765  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20766  " matrices. In addition, C callback routines for the transformation\n"
20767  " can be supplied by the user such as the mypltr function in\n"
20768  " examples/c/x09c.c which provides a general linear transformation\n"
20769  " between index coordinates and world coordinates.For languages\n"
20770  " other than C you should consult the PLplot documentation for the\n"
20771  " details concerning how PLTRANSFORM_callback arguments are\n"
20772  " interfaced. However, in general, a particular pattern of\n"
20773  " callback-associated arguments such as a tr vector with 6 elements;\n"
20774  " xg and yg vectors; or xg and yg matrices are respectively\n"
20775  " interfaced to a linear-transformation routine similar to the above\n"
20776  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20777  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20778  " support native language callbacks for handling index to\n"
20779  " world-coordinate transformations. Examples of these various\n"
20780  " approaches are given in examples/<language>x09*,\n"
20781  " examples/<language>x16*, examples/<language>x20*,\n"
20782  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20783  " supported languages.\n"
20784  "\n"
20785  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20786  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20787  " externally supplied.\n"
20788  "\n"
20789  ""},
20790  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20791  "Shade individual region on the basis of value\n"
20792  "\n"
20793  "DESCRIPTION:\n"
20794  "\n"
20795  " Shade individual region on the basis of value. Use plshades if you\n"
20796  " want to shade a number of contiguous regions using continuous colors.\n"
20797  " In particular the edge contours are treated properly in plshades. If\n"
20798  " you attempt to do contiguous regions with plshade the contours at the\n"
20799  " edge of the shade are partially obliterated by subsequent plots of\n"
20800  " contiguous shaded regions.\n"
20801  "\n"
20802  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20803  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20804  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20805  "\n"
20806  "\n"
20807  " This function is used in example 15.\n"
20808  "\n"
20809  "\n"
20810  "\n"
20811  "SYNOPSIS:\n"
20812  "\n"
20813  "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"
20814  "\n"
20815  "ARGUMENTS:\n"
20816  "\n"
20817  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20818  " plot. Should have dimensions of\n"
20819  " nx by\n"
20820  " ny.\n"
20821  "\n"
20822  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20823  "\n"
20824  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20825  "\n"
20826  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20827  " the region that should be plotted in the shade plot. This\n"
20828  " function accepts x and y coordinates as input arguments and must\n"
20829  " return 1 if the point is to be included in the shade plot and 0\n"
20830  " otherwise. If you want to plot the entire shade plot (the usual\n"
20831  " case), this argument should be set to NULL.\n"
20832  "\n"
20833  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20834  " pltr below for how these arguments are used (only for the special case\n"
20835  " when the callback function\n"
20836  " pltr is not supplied).\n"
20837  "\n"
20838  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20839  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20840  "\n"
20841  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20842  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20843  "\n"
20844  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20845  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20846  " then sh_color is interpreted as a cmap1 argument in the range\n"
20847  " (0.0-1.0).\n"
20848  "\n"
20849  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20850  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20851  "\n"
20852  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20853  "\n"
20854  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20855  " boundary of shaded region. The min values are used for the\n"
20856  " shade_min boundary, and the max values are used on the shade_max\n"
20857  " boundary. Set color and width to zero for no plotted boundaries.\n"
20858  "\n"
20859  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20860  " boundary of shaded region. The min values are used for the\n"
20861  " shade_min boundary, and the max values are used on the shade_max\n"
20862  " boundary. Set color and width to zero for no plotted boundaries.\n"
20863  "\n"
20864  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20865  " boundary of shaded region. The min values are used for the\n"
20866  " shade_min boundary, and the max values are used on the shade_max\n"
20867  " boundary. Set color and width to zero for no plotted boundaries.\n"
20868  "\n"
20869  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20870  " boundary of shaded region. The min values are used for the\n"
20871  " shade_min boundary, and the max values are used on the shade_max\n"
20872  " boundary. Set color and width to zero for no plotted boundaries.\n"
20873  "\n"
20874  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20875  " Use plfill. Future version of PLplot may have other fill\n"
20876  " routines.\n"
20877  "\n"
20878  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20879  " map to rectangles after coordinate transformation with pltrl.\n"
20880  " Otherwise, set rectangular to false. If rectangular is set to\n"
20881  " true, plshade tries to save time by filling large rectangles.\n"
20882  " This optimization fails if the coordinate transformation distorts\n"
20883  " the shape of rectangles. For example a plot in polar coordinates\n"
20884  " has to have rectangular set to false.\n"
20885  "\n"
20886  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20887  " defines the transformation between the zero-based indices of the\n"
20888  " matrix a and world coordinates. If\n"
20889  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20890  " indices of a are mapped to the range\n"
20891  " xmin through\n"
20892  " xmax and the y indices of a are mapped to the range\n"
20893  " ymin through\n"
20894  " ymax.For the C case, transformation functions are provided in the\n"
20895  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20896  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20897  " matrices. In addition, C callback routines for the transformation\n"
20898  " can be supplied by the user such as the mypltr function in\n"
20899  " examples/c/x09c.c which provides a general linear transformation\n"
20900  " between index coordinates and world coordinates.For languages\n"
20901  " other than C you should consult the PLplot documentation for the\n"
20902  " details concerning how PLTRANSFORM_callback arguments are\n"
20903  " interfaced. However, in general, a particular pattern of\n"
20904  " callback-associated arguments such as a tr vector with 6 elements;\n"
20905  " xg and yg vectors; or xg and yg matrices are respectively\n"
20906  " interfaced to a linear-transformation routine similar to the above\n"
20907  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20908  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20909  " support native language callbacks for handling index to\n"
20910  " world-coordinate transformations. Examples of these various\n"
20911  " approaches are given in examples/<language>x09*,\n"
20912  " examples/<language>x16*, examples/<language>x20*,\n"
20913  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20914  " supported languages.\n"
20915  "\n"
20916  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20917  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20918  " externally supplied.\n"
20919  "\n"
20920  ""},
20921  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20922  "Assign a function to use for generating custom axis labels\n"
20923  "\n"
20924  "DESCRIPTION:\n"
20925  "\n"
20926  " This function allows a user to provide their own function to provide\n"
20927  " axis label text. The user function is given the numeric value for a\n"
20928  " point on an axis and returns a string label to correspond with that\n"
20929  " value. Custom axis labels can be enabled by passing appropriate\n"
20930  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20931  "\n"
20932  " This function is used in example 19.\n"
20933  "\n"
20934  "\n"
20935  "\n"
20936  "SYNOPSIS:\n"
20937  "\n"
20938  "plslabelfunc(label_func, label_data)\n"
20939  "\n"
20940  "ARGUMENTS:\n"
20941  "\n"
20942  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20943  " label function. In order to reset to the default labelling, set\n"
20944  " this to NULL. The labelling function parameters are, in order:\n"
20945  " axis: This indicates which axis a label is being requested for.\n"
20946  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20947  "\n"
20948  " value: This is the value along the axis which is being labelled.\n"
20949  "\n"
20950  " label_text: The string representation of the label value.\n"
20951  "\n"
20952  " length: The maximum length in characters allowed for label_text.\n"
20953  "\n"
20954  "\n"
20955  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20956  " data to the label_func function.\n"
20957  "\n"
20958  ""},
20959  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20960  "Set length of major ticks\n"
20961  "\n"
20962  "DESCRIPTION:\n"
20963  "\n"
20964  " This sets up the length of the major ticks. The actual length is the\n"
20965  " product of the default length and a scaling factor as for character\n"
20966  " height.\n"
20967  "\n"
20968  " Redacted form: plsmaj(def, scale)\n"
20969  "\n"
20970  " This function is used in example 29.\n"
20971  "\n"
20972  "\n"
20973  "\n"
20974  "SYNOPSIS:\n"
20975  "\n"
20976  "plsmaj(def, scale)\n"
20977  "\n"
20978  "ARGUMENTS:\n"
20979  "\n"
20980  " def (PLFLT, input) : The default length of a major tick in\n"
20981  " millimeters, should be set to zero if the default length is to\n"
20982  " remain unchanged.\n"
20983  "\n"
20984  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20985  " actual tick length.\n"
20986  "\n"
20987  ""},
20988  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20989  "Set the memory area to be plotted (RGB)\n"
20990  "\n"
20991  "DESCRIPTION:\n"
20992  "\n"
20993  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20994  " the dev member of the stream structure. Also set the number of pixels\n"
20995  " in the memory passed in\n"
20996  " plotmem, which is a block of memory\n"
20997  " maxy by\n"
20998  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20999  "\n"
21000  " This memory will have to be freed by the user!\n"
21001  "\n"
21002  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21003  "\n"
21004  " This function is not used in any examples.\n"
21005  "\n"
21006  "\n"
21007  "\n"
21008  "SYNOPSIS:\n"
21009  "\n"
21010  "plsmem(maxx, maxy, plotmem)\n"
21011  "\n"
21012  "ARGUMENTS:\n"
21013  "\n"
21014  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21015  "\n"
21016  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21017  "\n"
21018  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21019  " user-supplied writeable memory area.\n"
21020  "\n"
21021  ""},
21022  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
21023  "Set the memory area to be plotted (RGBA)\n"
21024  "\n"
21025  "DESCRIPTION:\n"
21026  "\n"
21027  " Set the memory area to be plotted (with the memcairo driver) as the\n"
21028  " dev member of the stream structure. Also set the number of pixels in\n"
21029  " the memory passed in\n"
21030  " plotmem, which is a block of memory\n"
21031  " maxy by\n"
21032  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21033  "\n"
21034  " This memory will have to be freed by the user!\n"
21035  "\n"
21036  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21037  "\n"
21038  " This function is not used in any examples.\n"
21039  "\n"
21040  "\n"
21041  "\n"
21042  "SYNOPSIS:\n"
21043  "\n"
21044  "plsmema(maxx, maxy, plotmem)\n"
21045  "\n"
21046  "ARGUMENTS:\n"
21047  "\n"
21048  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21049  "\n"
21050  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21051  "\n"
21052  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21053  " user-supplied writeable memory area.\n"
21054  "\n"
21055  ""},
21056  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
21057  "Set length of minor ticks\n"
21058  "\n"
21059  "DESCRIPTION:\n"
21060  "\n"
21061  " This sets up the length of the minor ticks and the length of the\n"
21062  " terminals on error bars. The actual length is the product of the\n"
21063  " default length and a scaling factor as for character height.\n"
21064  "\n"
21065  " Redacted form: plsmin(def, scale)\n"
21066  "\n"
21067  " This function is used in example 29.\n"
21068  "\n"
21069  "\n"
21070  "\n"
21071  "SYNOPSIS:\n"
21072  "\n"
21073  "plsmin(def, scale)\n"
21074  "\n"
21075  "ARGUMENTS:\n"
21076  "\n"
21077  " def (PLFLT, input) : The default length of a minor tick in\n"
21078  " millimeters, should be set to zero if the default length is to\n"
21079  " remain unchanged.\n"
21080  "\n"
21081  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21082  " actual tick length.\n"
21083  "\n"
21084  ""},
21085  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
21086  "Set orientation\n"
21087  "\n"
21088  "DESCRIPTION:\n"
21089  "\n"
21090  " Set integer plot orientation parameter. This function is identical to\n"
21091  " plsdiori except for the type of the argument, and should be used in\n"
21092  " the same way. See the documentation of plsdiori for details.\n"
21093  "\n"
21094  " Redacted form: plsori(ori)\n"
21095  "\n"
21096  " This function is used in example 3.\n"
21097  "\n"
21098  "\n"
21099  "\n"
21100  "SYNOPSIS:\n"
21101  "\n"
21102  "plsori(ori)\n"
21103  "\n"
21104  "ARGUMENTS:\n"
21105  "\n"
21106  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21107  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21108  " angle.\n"
21109  "\n"
21110  ""},
21111  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
21112  "Set page parameters\n"
21113  "\n"
21114  "DESCRIPTION:\n"
21115  "\n"
21116  " Sets the page configuration (optional). If an individual parameter is\n"
21117  " zero then that parameter value is not updated. Not all parameters are\n"
21118  " recognized by all drivers and the interpretation is device-dependent.\n"
21119  " The X-window driver uses the length and offset parameters to determine\n"
21120  " the window size and location. The length and offset values are\n"
21121  " expressed in units that are specific to the current driver. For\n"
21122  " instance: screen drivers will usually interpret them as number of\n"
21123  " pixels, whereas printer drivers will usually use mm.\n"
21124  "\n"
21125  " This routine, if used, must be called before initializing PLplot. It\n"
21126  " may be called at later times for interactive drivers to change only\n"
21127  " the dpi for subsequent redraws which you can force via a call to\n"
21128  " plreplot. If this function is not called then the page size defaults\n"
21129  " to landscape A4 for drivers which use real world page sizes and 744\n"
21130  " pixels wide by 538 pixels high for raster drivers. The default value\n"
21131  " for dx and dy is 90 pixels per inch for raster drivers.\n"
21132  "\n"
21133  "\n"
21134  "\n"
21135  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21136  "\n"
21137  " This function is used in examples 14 and 31.\n"
21138  "\n"
21139  "\n"
21140  "\n"
21141  "SYNOPSIS:\n"
21142  "\n"
21143  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21144  "\n"
21145  "ARGUMENTS:\n"
21146  "\n"
21147  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21148  " by raster drivers, ignored by drivers which use \"real world\" units\n"
21149  " (e.g. mm).\n"
21150  "\n"
21151  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21152  " by raster drivers, ignored by drivers which use \"real world\" units\n"
21153  " (e.g. mm).\n"
21154  "\n"
21155  " xleng (PLINT, input) : Page length, x.\n"
21156  "\n"
21157  " yleng (PLINT, input) : Page length, y.\n"
21158  "\n"
21159  " xoff (PLINT, input) : Page offset, x.\n"
21160  "\n"
21161  " yoff (PLINT, input) : Page offset, y.\n"
21162  "\n"
21163  ""},
21164  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
21165  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21166  "\n"
21167  "DESCRIPTION:\n"
21168  "\n"
21169  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21170  "\n"
21171  " Redacted form: plspal0(filename)\n"
21172  "\n"
21173  " This function is in example 16.\n"
21174  "\n"
21175  "\n"
21176  "\n"
21177  "SYNOPSIS:\n"
21178  "\n"
21179  "plspal0(filename)\n"
21180  "\n"
21181  "ARGUMENTS:\n"
21182  "\n"
21183  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21184  " containing the name of the cmap0*.pal file. If this string is\n"
21185  " empty, use the default cmap0*.pal file.\n"
21186  "\n"
21187  ""},
21188  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
21189  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21190  "\n"
21191  "DESCRIPTION:\n"
21192  "\n"
21193  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21194  "\n"
21195  " Redacted form: plspal1(filename, interpolate)\n"
21196  "\n"
21197  " This function is used in example 16.\n"
21198  "\n"
21199  "\n"
21200  "\n"
21201  "SYNOPSIS:\n"
21202  "\n"
21203  "plspal1(filename, interpolate)\n"
21204  "\n"
21205  "ARGUMENTS:\n"
21206  "\n"
21207  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21208  " containing the name of the cmap1*.pal file. If this string is\n"
21209  " empty, use the default cmap1*.pal file.\n"
21210  "\n"
21211  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21212  " columns containing the intensity index, r, g, b, alpha and\n"
21213  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21214  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21215  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21216  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21217  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21218  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21219  " are used instead to set the cmap1 palette directly with a call to\n"
21220  " plscmap1a.\n"
21221  "\n"
21222  ""},
21223  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
21224  "Set the pause (on end-of-page) status\n"
21225  "\n"
21226  "DESCRIPTION:\n"
21227  "\n"
21228  " Set the pause (on end-of-page) status.\n"
21229  "\n"
21230  " Redacted form: plspause(pause)\n"
21231  "\n"
21232  " This function is in examples 14,20.\n"
21233  "\n"
21234  "\n"
21235  "\n"
21236  "SYNOPSIS:\n"
21237  "\n"
21238  "plspause(pause)\n"
21239  "\n"
21240  "ARGUMENTS:\n"
21241  "\n"
21242  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21243  " end-of-page for those drivers which support this. Otherwise there\n"
21244  " is no pause.\n"
21245  "\n"
21246  ""},
21247  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
21248  "Set current output stream\n"
21249  "\n"
21250  "DESCRIPTION:\n"
21251  "\n"
21252  " Sets the number of the current output stream. The stream number\n"
21253  " defaults to 0 unless changed by this routine. The first use of this\n"
21254  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21255  "\n"
21256  " Redacted form: plsstrm(strm)\n"
21257  "\n"
21258  " This function is examples 1,14,20.\n"
21259  "\n"
21260  "\n"
21261  "\n"
21262  "SYNOPSIS:\n"
21263  "\n"
21264  "plsstrm(strm)\n"
21265  "\n"
21266  "ARGUMENTS:\n"
21267  "\n"
21268  " strm (PLINT, input) : The current stream number.\n"
21269  "\n"
21270  ""},
21271  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
21272  "Set the number of subpages in x and y\n"
21273  "\n"
21274  "DESCRIPTION:\n"
21275  "\n"
21276  " Set the number of subpages in x and y.\n"
21277  "\n"
21278  " Redacted form: plssub(nx, ny)\n"
21279  "\n"
21280  " This function is examples 1,2,14,21,25,27.\n"
21281  "\n"
21282  "\n"
21283  "\n"
21284  "SYNOPSIS:\n"
21285  "\n"
21286  "plssub(nx, ny)\n"
21287  "\n"
21288  "ARGUMENTS:\n"
21289  "\n"
21290  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21291  " of window columns).\n"
21292  "\n"
21293  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21294  " of window rows).\n"
21295  "\n"
21296  ""},
21297  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
21298  "Set symbol size\n"
21299  "\n"
21300  "DESCRIPTION:\n"
21301  "\n"
21302  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21303  " plsym. The actual height of a symbol is the product of the default\n"
21304  " symbol size and a scaling factor as for the character height.\n"
21305  "\n"
21306  " Redacted form: plssym(def, scale)\n"
21307  "\n"
21308  " This function is used in example 29.\n"
21309  "\n"
21310  "\n"
21311  "\n"
21312  "SYNOPSIS:\n"
21313  "\n"
21314  "plssym(def, scale)\n"
21315  "\n"
21316  "ARGUMENTS:\n"
21317  "\n"
21318  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21319  " should be set to zero if the default height is to remain\n"
21320  " unchanged.\n"
21321  "\n"
21322  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21323  " actual symbol height.\n"
21324  "\n"
21325  ""},
21326  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
21327  "Initialization\n"
21328  "\n"
21329  "DESCRIPTION:\n"
21330  "\n"
21331  " Initializing the plotting package. The program prompts for the device\n"
21332  " keyword or number of the desired output device. Hitting a RETURN in\n"
21333  " response to the prompt is the same as selecting the first device. If\n"
21334  " only one device is enabled when PLplot is installed, plstar will issue\n"
21335  " no prompt. The output device is divided into nx by ny subpages, each\n"
21336  " of which may be used independently. The subroutine pladv is used to\n"
21337  " advance from one subpage to the next.\n"
21338  "\n"
21339  " Redacted form: plstar(nx, ny)\n"
21340  "\n"
21341  " This function is used in example 1.\n"
21342  "\n"
21343  "\n"
21344  "\n"
21345  "SYNOPSIS:\n"
21346  "\n"
21347  "plstar(nx, ny)\n"
21348  "\n"
21349  "ARGUMENTS:\n"
21350  "\n"
21351  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21352  " x direction.\n"
21353  "\n"
21354  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21355  " y direction.\n"
21356  "\n"
21357  ""},
21358  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
21359  "Initialization\n"
21360  "\n"
21361  "DESCRIPTION:\n"
21362  "\n"
21363  " Alternative to plstar for initializing the plotting package. The\n"
21364  " device name keyword for the desired output device must be supplied as\n"
21365  " an argument. These keywords are the same as those printed out by\n"
21366  " plstar. If the requested device is not available, or if the input\n"
21367  " string is empty or begins with ``?'', the prompted start up of plstar\n"
21368  " is used. This routine also divides the output device page into nx by\n"
21369  " ny subpages, each of which may be used independently. The subroutine\n"
21370  " pladv is used to advance from one subpage to the next.\n"
21371  "\n"
21372  " Redacted form: General: plstart(devname, nx, ny)\n"
21373  "\n"
21374  "\n"
21375  " This function is not used in any examples.\n"
21376  "\n"
21377  "\n"
21378  "\n"
21379  "SYNOPSIS:\n"
21380  "\n"
21381  "plstart(devname, nx, ny)\n"
21382  "\n"
21383  "ARGUMENTS:\n"
21384  "\n"
21385  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21386  " containing the device name keyword of the required output device.\n"
21387  " If\n"
21388  " devname is NULL or if the first character of the string is a ``?'',\n"
21389  " the normal (prompted) start up is used.\n"
21390  "\n"
21391  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21392  " x direction.\n"
21393  "\n"
21394  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21395  " y direction.\n"
21396  "\n"
21397  ""},
21398  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
21399  "Set a global coordinate transform function\n"
21400  "\n"
21401  "DESCRIPTION:\n"
21402  "\n"
21403  " This function can be used to define a coordinate transformation which\n"
21404  " affects all elements drawn within the current plot window. The\n"
21405  " coordinate_transform callback function is similar to that provided for\n"
21406  " the plmap and plmeridians functions. The coordinate_transform_data\n"
21407  " parameter may be used to pass extra data to coordinate_transform.\n"
21408  "\n"
21409  " Redacted form: General: plstransform(coordinate_transform,\n"
21410  " coordinate_transform_data)\n"
21411  "\n"
21412  "\n"
21413  " This function is used in examples 19 and 22.\n"
21414  "\n"
21415  "\n"
21416  "\n"
21417  "SYNOPSIS:\n"
21418  "\n"
21419  "plstransform(coordinate_transform, coordinate_transform_data)\n"
21420  "\n"
21421  "ARGUMENTS:\n"
21422  "\n"
21423  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21424  " function that defines the transformation from the input (x, y)\n"
21425  " world coordinates to new PLplot world coordinates. If\n"
21426  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21427  " case), then no transform is applied.\n"
21428  "\n"
21429  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21430  " for\n"
21431  " coordinate_transform.\n"
21432  "\n"
21433  ""},
21434  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
21435  "Plot a glyph at the specified points\n"
21436  "\n"
21437  "DESCRIPTION:\n"
21438  "\n"
21439  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21440  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21441  " is specified with a PLplot user string. Note that the user string is\n"
21442  " not actually limited to one glyph so it is possible (but not normally\n"
21443  " useful) to plot more than one glyph at the specified points with this\n"
21444  " function. As with plmtex and plptex, the user string can contain FCI\n"
21445  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21446  " else PLplot escapes for Hershey or unicode text to determine the\n"
21447  " glyph.\n"
21448  "\n"
21449  " Redacted form: plstring(x, y, string)\n"
21450  "\n"
21451  " This function is used in examples 4, 21 and 26.\n"
21452  "\n"
21453  "\n"
21454  "\n"
21455  "SYNOPSIS:\n"
21456  "\n"
21457  "plstring(n, x, y, string)\n"
21458  "\n"
21459  "ARGUMENTS:\n"
21460  "\n"
21461  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21462  "\n"
21463  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21464  " the points.\n"
21465  "\n"
21466  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21467  " the points.\n"
21468  "\n"
21469  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21470  " the glyph(s) to be plotted at each of the n points.\n"
21471  "\n"
21472  ""},
21473  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
21474  "Plot a glyph at the specified 3D points\n"
21475  "\n"
21476  "DESCRIPTION:\n"
21477  "\n"
21478  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21479  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21480  " this function similar to what is done for plline3. The glyph is\n"
21481  " specified with a PLplot user string. Note that the user string is not\n"
21482  " actually limited to one glyph so it is possible (but not normally\n"
21483  " useful) to plot more than one glyph at the specified points with this\n"
21484  " function. As with plmtex and plptex, the user string can contain FCI\n"
21485  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21486  " else PLplot escapes for Hershey or unicode text to determine the\n"
21487  " glyph.\n"
21488  "\n"
21489  " Redacted form: plstring3(x, y, z, string)\n"
21490  "\n"
21491  " This function is used in example 18.\n"
21492  "\n"
21493  "\n"
21494  "\n"
21495  "SYNOPSIS:\n"
21496  "\n"
21497  "plstring3(n, x, y, z, string)\n"
21498  "\n"
21499  "ARGUMENTS:\n"
21500  "\n"
21501  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21502  "\n"
21503  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21504  " the points.\n"
21505  "\n"
21506  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21507  " the points.\n"
21508  "\n"
21509  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21510  " the points.\n"
21511  "\n"
21512  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21513  " the glyph(s) to be plotted at each of the n points. points.\n"
21514  "\n"
21515  ""},
21516  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
21517  "Add a point to a strip chart\n"
21518  "\n"
21519  "DESCRIPTION:\n"
21520  "\n"
21521  " Add a point to a given pen of a given strip chart. There is no need\n"
21522  " for all pens to have the same number of points or to be equally\n"
21523  " sampled in the x coordinate. Allocates memory and rescales as\n"
21524  " necessary.\n"
21525  "\n"
21526  " Redacted form: plstripa(id, pen, x, y)\n"
21527  "\n"
21528  " This function is used in example 17.\n"
21529  "\n"
21530  "\n"
21531  "\n"
21532  "SYNOPSIS:\n"
21533  "\n"
21534  "plstripa(id, pen, x, y)\n"
21535  "\n"
21536  "ARGUMENTS:\n"
21537  "\n"
21538  " id (PLINT, input) : Identification number of the strip chart (set\n"
21539  " up in plstripc).\n"
21540  "\n"
21541  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21542  "\n"
21543  " x (PLFLT, input) : X coordinate of point to plot.\n"
21544  "\n"
21545  " y (PLFLT, input) : Y coordinate of point to plot.\n"
21546  "\n"
21547  ""},
21548  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
21549  "Create a 4-pen strip chart\n"
21550  "\n"
21551  "DESCRIPTION:\n"
21552  "\n"
21553  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21554  "\n"
21555  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21556  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21557  " styline, legline, labx, laby, labz)\n"
21558  "\n"
21559  "\n"
21560  " This function is used in example 17.\n"
21561  "\n"
21562  "\n"
21563  "\n"
21564  "SYNOPSIS:\n"
21565  "\n"
21566  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21567  "\n"
21568  "ARGUMENTS:\n"
21569  "\n"
21570  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21571  " number of the strip chart to use on plstripa and plstripd.\n"
21572  "\n"
21573  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21574  " the x-axis specification as in plbox.\n"
21575  "\n"
21576  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21577  " the y-axis specification as in plbox.\n"
21578  "\n"
21579  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21580  " change as data are added.\n"
21581  "\n"
21582  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21583  " change as data are added.\n"
21584  "\n"
21585  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21586  " is multiplied by the factor (1 +\n"
21587  " xjump) .\n"
21588  "\n"
21589  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21590  " change as data are added.\n"
21591  "\n"
21592  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21593  " change as data are added.\n"
21594  "\n"
21595  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21596  "\n"
21597  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21598  "\n"
21599  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21600  " true, otherwise not.\n"
21601  "\n"
21602  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21603  " otherwise slide display.\n"
21604  "\n"
21605  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21606  "\n"
21607  " collab (PLINT, input) : Legend color index (cmap0).\n"
21608  "\n"
21609  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21610  " indices for the 4 pens.\n"
21611  "\n"
21612  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21613  " indices for the 4 pens.\n"
21614  "\n"
21615  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21616  " strings containing legends for the 4 pens.\n"
21617  "\n"
21618  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21619  " the label for the x axis.\n"
21620  "\n"
21621  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21622  " the label for the y axis.\n"
21623  "\n"
21624  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21625  " the plot title.\n"
21626  "\n"
21627  ""},
21628  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
21629  "Deletes and releases memory used by a strip chart\n"
21630  "\n"
21631  "DESCRIPTION:\n"
21632  "\n"
21633  " Deletes and releases memory used by a strip chart.\n"
21634  "\n"
21635  " Redacted form: plstripd(id)\n"
21636  "\n"
21637  " This function is used in example 17.\n"
21638  "\n"
21639  "\n"
21640  "\n"
21641  "SYNOPSIS:\n"
21642  "\n"
21643  "plstripd(id)\n"
21644  "\n"
21645  "ARGUMENTS:\n"
21646  "\n"
21647  " id (PLINT, input) : Identification number of strip chart to delete.\n"
21648  "\n"
21649  ""},
21650  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
21651  "Set line style\n"
21652  "\n"
21653  "DESCRIPTION:\n"
21654  "\n"
21655  " This sets up the line style for all lines subsequently drawn. A line\n"
21656  " consists of segments in which the pen is alternately down and up. The\n"
21657  " lengths of these segments are passed in the vectors mark and space\n"
21658  " respectively. The number of mark-space pairs is specified by nms. In\n"
21659  " order to return the line style to the default continuous line, plstyl\n"
21660  " should be called with nms =0 .(see also pllsty)\n"
21661  "\n"
21662  " Redacted form: plstyl(mark, space)\n"
21663  "\n"
21664  " This function is used in examples 1, 9, and 14.\n"
21665  "\n"
21666  "\n"
21667  "\n"
21668  "SYNOPSIS:\n"
21669  "\n"
21670  "plstyl(nms, mark, space)\n"
21671  "\n"
21672  "ARGUMENTS:\n"
21673  "\n"
21674  " nms (PLINT, input) : The number of mark and space elements in a\n"
21675  " line. Thus a simple broken line can be obtained by setting nms=1\n"
21676  " . A continuous line is specified by setting nms=0 .\n"
21677  "\n"
21678  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21679  " segments during which the pen is down, measured in micrometers.\n"
21680  "\n"
21681  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21682  " the segments during which the pen is up, measured in micrometers.\n"
21683  "\n"
21684  ""},
21685  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
21686  "Set arrow style for vector plots\n"
21687  "\n"
21688  "DESCRIPTION:\n"
21689  "\n"
21690  " Set the style for the arrow used by plvect to plot vectors.\n"
21691  "\n"
21692  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21693  "\n"
21694  " This function is used in example 22.\n"
21695  "\n"
21696  "\n"
21697  "\n"
21698  "SYNOPSIS:\n"
21699  "\n"
21700  "plsvect(arrowx, arrowy, npts, fill)\n"
21701  "\n"
21702  "ARGUMENTS:\n"
21703  "\n"
21704  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21705  " the x and y points which make up the arrow. The arrow is plotted\n"
21706  " by joining these points to form a polygon. The scaling assumes\n"
21707  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21708  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21709  " will be reset to its default.\n"
21710  "\n"
21711  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21712  " arrowy.\n"
21713  "\n"
21714  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21715  " fill is false then the arrow is open.\n"
21716  "\n"
21717  ""},
21718  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
21719  "Specify viewport in absolute coordinates\n"
21720  "\n"
21721  "DESCRIPTION:\n"
21722  "\n"
21723  " Alternate routine to plvpor for setting up the viewport. This routine\n"
21724  " should be used only if the viewport is required to have a definite\n"
21725  " size in millimeters. The routine plgspa is useful for finding out the\n"
21726  " size of the current subpage.\n"
21727  "\n"
21728  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21729  "\n"
21730  " This function is used in example 10.\n"
21731  "\n"
21732  "\n"
21733  "\n"
21734  "SYNOPSIS:\n"
21735  "\n"
21736  "plsvpa(xmin, xmax, ymin, ymax)\n"
21737  "\n"
21738  "ARGUMENTS:\n"
21739  "\n"
21740  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21741  " viewport from the left-hand edge of the subpage in millimeters.\n"
21742  "\n"
21743  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21744  " viewport from the left-hand edge of the subpage in millimeters.\n"
21745  "\n"
21746  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21747  " viewport from the bottom edge of the subpage in millimeters.\n"
21748  "\n"
21749  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21750  " from the bottom edge of the subpage in millimeters.\n"
21751  "\n"
21752  ""},
21753  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
21754  "Set x axis parameters\n"
21755  "\n"
21756  "DESCRIPTION:\n"
21757  "\n"
21758  " Sets values of the digmax and digits flags for the x axis. See the\n"
21759  " PLplot documentation for more information.\n"
21760  "\n"
21761  " Redacted form: plsxax(digmax, digits)\n"
21762  "\n"
21763  " This function is used in example 31.\n"
21764  "\n"
21765  "\n"
21766  "\n"
21767  "SYNOPSIS:\n"
21768  "\n"
21769  "plsxax(digmax, digits)\n"
21770  "\n"
21771  "ARGUMENTS:\n"
21772  "\n"
21773  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21774  " digits for the x axis. If nonzero, the printed label will be\n"
21775  " switched to a floating-point representation when the number of\n"
21776  " digits exceeds digmax.\n"
21777  "\n"
21778  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21779  " its value here has no effect since it is set only by plbox or\n"
21780  " plbox3. However, the user may obtain its value after a call to\n"
21781  " either of these functions by calling plgxax.\n"
21782  "\n"
21783  ""},
21784  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
21785  "Set y axis parameters\n"
21786  "\n"
21787  "DESCRIPTION:\n"
21788  "\n"
21789  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21790  " the description of plsxax for more detail.\n"
21791  "\n"
21792  " Redacted form: plsyax(digmax, digits)\n"
21793  "\n"
21794  " This function is used in examples 1, 14, and 31.\n"
21795  "\n"
21796  "\n"
21797  "\n"
21798  "SYNOPSIS:\n"
21799  "\n"
21800  "plsyax(digmax, digits)\n"
21801  "\n"
21802  "ARGUMENTS:\n"
21803  "\n"
21804  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21805  " digits for the y axis. If nonzero, the printed label will be\n"
21806  " switched to a floating-point representation when the number of\n"
21807  " digits exceeds digmax.\n"
21808  "\n"
21809  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21810  " its value here has no effect since it is set only by plbox or\n"
21811  " plbox3. However, the user may obtain its value after a call to\n"
21812  " either of these functions by calling plgyax.\n"
21813  "\n"
21814  ""},
21815  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
21816  "Plot a glyph at the specified points\n"
21817  "\n"
21818  "DESCRIPTION:\n"
21819  "\n"
21820  " Plot a glyph at the specified points. (This function is largely\n"
21821  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21822  "\n"
21823  " Redacted form: plsym(x, y, code)\n"
21824  "\n"
21825  " This function is used in example 7.\n"
21826  "\n"
21827  "\n"
21828  "\n"
21829  "SYNOPSIS:\n"
21830  "\n"
21831  "plsym(n, x, y, code)\n"
21832  "\n"
21833  "ARGUMENTS:\n"
21834  "\n"
21835  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21836  "\n"
21837  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21838  " the points.\n"
21839  "\n"
21840  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21841  " the points.\n"
21842  "\n"
21843  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21844  " to be plotted at each of the n points.\n"
21845  "\n"
21846  ""},
21847  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21848  "Set z axis parameters\n"
21849  "\n"
21850  "DESCRIPTION:\n"
21851  "\n"
21852  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21853  " the description of plsxax for more detail.\n"
21854  "\n"
21855  " Redacted form: plszax(digmax, digits)\n"
21856  "\n"
21857  " This function is used in example 31.\n"
21858  "\n"
21859  "\n"
21860  "\n"
21861  "SYNOPSIS:\n"
21862  "\n"
21863  "plszax(digmax, digits)\n"
21864  "\n"
21865  "ARGUMENTS:\n"
21866  "\n"
21867  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21868  " digits for the z axis. If nonzero, the printed label will be\n"
21869  " switched to a floating-point representation when the number of\n"
21870  " digits exceeds digmax.\n"
21871  "\n"
21872  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21873  " its value here has no effect since it is set only by plbox or\n"
21874  " plbox3. However, the user may obtain its value after a call to\n"
21875  " either of these functions by calling plgzax.\n"
21876  "\n"
21877  ""},
21878  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21879  "Switch to text screen\n"
21880  "\n"
21881  "DESCRIPTION:\n"
21882  "\n"
21883  " Sets an interactive device to text mode, used in conjunction with\n"
21884  " plgra to allow graphics and text to be interspersed. On a device\n"
21885  " which supports separate text and graphics windows, this command causes\n"
21886  " control to be switched to the text window. This can be useful for\n"
21887  " printing diagnostic messages or getting user input, which would\n"
21888  " otherwise interfere with the plots. The program must switch back to\n"
21889  " the graphics window before issuing plot commands, as the text (or\n"
21890  " console) device will probably become quite confused otherwise. If\n"
21891  " already in text mode, this command is ignored. It is also ignored on\n"
21892  " devices which only support a single window or use a different method\n"
21893  " for shifting focus (see also plgra).\n"
21894  "\n"
21895  " Redacted form: pltext()\n"
21896  "\n"
21897  " This function is used in example 1.\n"
21898  "\n"
21899  "\n"
21900  "\n"
21901  "SYNOPSIS:\n"
21902  "\n"
21903  "pltext()\n"
21904  "\n"
21905  ""},
21906  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21907  "Set format for date / time labels\n"
21908  "\n"
21909  "DESCRIPTION:\n"
21910  "\n"
21911  " Sets the format for date / time labels. To enable date / time format\n"
21912  " labels see the options to plbox, plbox3, and plenv.\n"
21913  "\n"
21914  " Redacted form: pltimefmt(fmt)\n"
21915  "\n"
21916  " This function is used in example 29.\n"
21917  "\n"
21918  "\n"
21919  "\n"
21920  "SYNOPSIS:\n"
21921  "\n"
21922  "pltimefmt(fmt)\n"
21923  "\n"
21924  "ARGUMENTS:\n"
21925  "\n"
21926  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21927  " interpreted similarly to the format specifier of typical system\n"
21928  " strftime routines except that PLplot ignores locale and also\n"
21929  " supplies some useful extensions in the context of plotting. All\n"
21930  " text in the string is printed as-is other than conversion\n"
21931  " specifications which take the form of a '%' character followed by\n"
21932  " further conversion specification character. The conversion\n"
21933  " specifications which are similar to those provided by system\n"
21934  " strftime routines are the following: %a: The abbreviated (English)\n"
21935  " weekday name.\n"
21936  " %A: The full (English) weekday name.\n"
21937  " %b: The abbreviated (English) month name.\n"
21938  " %B: The full (English) month name.\n"
21939  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21940  " %C: The century number (year/100) as a 2-digit integer.\n"
21941  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21942  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21943  " %e: Like %d, but a leading zero is replaced by a space.\n"
21944  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21945  " %h: Equivalent to %b.\n"
21946  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21947  " 00 to 23).\n"
21948  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21949  " 01 to 12).\n"
21950  " %j: The day of the year as a decimal number (range 001 to\n"
21951  " 366).\n"
21952  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21953  " 23); single digits are preceded by a blank. (See also %H.)\n"
21954  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21955  " 12); single digits are preceded by a blank. (See also %I.)\n"
21956  " %m: The month as a decimal number (range 01 to 12).\n"
21957  " %M: The minute as a decimal number (range 00 to 59).\n"
21958  " %n: A newline character.\n"
21959  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21960  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21961  " %r: Equivalent to %I:%M:%S %p.\n"
21962  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21963  " including the seconds, see %T below.\n"
21964  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21965  " +0000 (UTC).\n"
21966  " %S: The second as a decimal number (range 00 to 60). (The\n"
21967  " range is up to 60 to allow for occasional leap seconds.)\n"
21968  " %t: A tab character.\n"
21969  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21970  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21971  " being 1. See also %w.\n"
21972  " %U: The week number of the current year as a decimal number,\n"
21973  " range 00 to 53, starting with the first Sunday as the first\n"
21974  " day of week 01. See also %V and %W.\n"
21975  " %v: Equivalent to %e-%b-%Y.\n"
21976  " %V: The ISO 8601 week number of the current year as a decimal\n"
21977  " number, range 01 to 53, where week 1 is the first week that\n"
21978  " has at least 4 days in the new year. See also %U and %W.\n"
21979  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21980  " being 0. See also %u.\n"
21981  " %W: The week number of the current year as a decimal number,\n"
21982  " range 00 to 53, starting with the first Monday as the first\n"
21983  " day of week 01.\n"
21984  " %x: Equivalent to %a %b %d %Y.\n"
21985  " %X: Equivalent to %T.\n"
21986  " %y: The year as a decimal number without a century (range 00\n"
21987  " to 99).\n"
21988  " %Y: The year as a decimal number including a century.\n"
21989  " %z: The UTC time-zone string = \"+0000\".\n"
21990  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21991  " %+: The UTC date and time in default format of the Unix date\n"
21992  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21993  " %%: A literal \"%\" character.\n"
21994  " The conversion specifications which are extensions to those normally\n"
21995  " provided by system strftime routines are the following: %(0-9):\n"
21996  " The fractional part of the seconds field (including leading\n"
21997  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21998  " seconds to millisecond accuracy (00.000).\n"
21999  " %.: The fractional part of the seconds field (including\n"
22000  " leading decimal point) to the maximum available accuracy. Thus\n"
22001  " %S%. would give seconds with fractional part up to 9 decimal\n"
22002  " places if available.\n"
22003  "\n"
22004  ""},
22005  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
22006  "Specify viewport using aspect ratio only\n"
22007  "\n"
22008  "DESCRIPTION:\n"
22009  "\n"
22010  " Selects the largest viewport with the given aspect ratio within the\n"
22011  " subpage that leaves a standard margin (left-hand margin of eight\n"
22012  " character heights, and a margin around the other three sides of five\n"
22013  " character heights).\n"
22014  "\n"
22015  " Redacted form: plvasp(aspect)\n"
22016  "\n"
22017  " This function is used in example 13.\n"
22018  "\n"
22019  "\n"
22020  "\n"
22021  "SYNOPSIS:\n"
22022  "\n"
22023  "plvasp(aspect)\n"
22024  "\n"
22025  "ARGUMENTS:\n"
22026  "\n"
22027  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22028  " axis of resulting viewport.\n"
22029  "\n"
22030  ""},
22031  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
22032  "Vector plot\n"
22033  "\n"
22034  "DESCRIPTION:\n"
22035  "\n"
22036  " Draws a plot of vector data contained in the matrices (\n"
22037  " u[\n"
22038  " nx][\n"
22039  " ny],\n"
22040  " v[\n"
22041  " nx][\n"
22042  " ny]) . The scaling factor for the vectors is given by scale. A\n"
22043  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22044  " additional data required by the transformation routine to map indices\n"
22045  " within the matrices to the world coordinates. The style of the vector\n"
22046  " arrow may be set using plsvect.\n"
22047  "\n"
22048  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22049  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22050  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22051  " with either one or two dimensions.\n"
22052  "\n"
22053  " This function is used in example 22.\n"
22054  "\n"
22055  "\n"
22056  "\n"
22057  "SYNOPSIS:\n"
22058  "\n"
22059  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22060  "\n"
22061  "ARGUMENTS:\n"
22062  "\n"
22063  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22064  " and y components of the vector data to be plotted.\n"
22065  "\n"
22066  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22067  "\n"
22068  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22069  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22070  " automatically calculated for the data. If scale < 0 then the\n"
22071  " scaling factor is automatically calculated for the data and then\n"
22072  " multiplied by -\n"
22073  " scale. If scale > 0 then the scaling factor is set to scale.\n"
22074  "\n"
22075  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22076  " defines the transformation between the zero-based indices of the\n"
22077  " matrices u and v and world coordinates.For the C case,\n"
22078  " transformation functions are provided in the PLplot library: pltr0\n"
22079  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22080  " mappings respectively defined by vectors and matrices. In\n"
22081  " addition, C callback routines for the transformation can be\n"
22082  " supplied by the user such as the mypltr function in\n"
22083  " examples/c/x09c.c which provides a general linear transformation\n"
22084  " between index coordinates and world coordinates.For languages\n"
22085  " other than C you should consult the PLplot documentation for the\n"
22086  " details concerning how PLTRANSFORM_callback arguments are\n"
22087  " interfaced. However, in general, a particular pattern of\n"
22088  " callback-associated arguments such as a tr vector with 6 elements;\n"
22089  " xg and yg vectors; or xg and yg matrices are respectively\n"
22090  " interfaced to a linear-transformation routine similar to the above\n"
22091  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22092  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22093  " support native language callbacks for handling index to\n"
22094  " world-coordinate transformations. Examples of these various\n"
22095  " approaches are given in examples/<language>x09*,\n"
22096  " examples/<language>x16*, examples/<language>x20*,\n"
22097  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22098  " supported languages.\n"
22099  "\n"
22100  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22101  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22102  " that is externally supplied.\n"
22103  "\n"
22104  ""},
22105  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
22106  "Specify viewport using coordinates and aspect ratio\n"
22107  "\n"
22108  "DESCRIPTION:\n"
22109  "\n"
22110  " Device-independent routine for setting up the viewport. The viewport\n"
22111  " is chosen to be the largest with the given aspect ratio that fits\n"
22112  " within the specified region (in terms of normalized subpage\n"
22113  " coordinates). This routine is functionally equivalent to plvpor when\n"
22114  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22115  " routine reserves no extra space at the edges for labels.\n"
22116  "\n"
22117  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22118  "\n"
22119  " This function is used in example 9.\n"
22120  "\n"
22121  "\n"
22122  "\n"
22123  "SYNOPSIS:\n"
22124  "\n"
22125  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22126  "\n"
22127  "ARGUMENTS:\n"
22128  "\n"
22129  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22130  " left-hand edge of the viewport.\n"
22131  "\n"
22132  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22133  " right-hand edge of the viewport.\n"
22134  "\n"
22135  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22136  " bottom edge of the viewport.\n"
22137  "\n"
22138  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22139  " edge of the viewport.\n"
22140  "\n"
22141  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22142  " axis.\n"
22143  "\n"
22144  ""},
22145  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
22146  "Specify viewport using normalized subpage coordinates\n"
22147  "\n"
22148  "DESCRIPTION:\n"
22149  "\n"
22150  " Device-independent routine for setting up the viewport. This defines\n"
22151  " the viewport in terms of normalized subpage coordinates which run from\n"
22152  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22153  " current subpage. Use the alternate routine plsvpa in order to create\n"
22154  " a viewport of a definite size.\n"
22155  "\n"
22156  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22157  "\n"
22158  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22159  " 24, 26, 27, and 31.\n"
22160  "\n"
22161  "\n"
22162  "\n"
22163  "SYNOPSIS:\n"
22164  "\n"
22165  "plvpor(xmin, xmax, ymin, ymax)\n"
22166  "\n"
22167  "ARGUMENTS:\n"
22168  "\n"
22169  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22170  " left-hand edge of the viewport.\n"
22171  "\n"
22172  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22173  " right-hand edge of the viewport.\n"
22174  "\n"
22175  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22176  " bottom edge of the viewport.\n"
22177  "\n"
22178  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22179  " edge of the viewport.\n"
22180  "\n"
22181  ""},
22182  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
22183  "Select standard viewport\n"
22184  "\n"
22185  "DESCRIPTION:\n"
22186  "\n"
22187  " Selects the largest viewport within the subpage that leaves a standard\n"
22188  " margin (left-hand margin of eight character heights, and a margin\n"
22189  " around the other three sides of five character heights).\n"
22190  "\n"
22191  " Redacted form: plvsta()\n"
22192  "\n"
22193  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22194  "\n"
22195  "\n"
22196  "\n"
22197  "SYNOPSIS:\n"
22198  "\n"
22199  "plvsta()\n"
22200  "\n"
22201  ""},
22202  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
22203  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22204  "\n"
22205  "DESCRIPTION:\n"
22206  "\n"
22207  " Configure the transformations required for projecting a 3D surface on\n"
22208  " an existing 2D window. Those transformations (see the PLplot\n"
22209  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22210  " surface which has its limits expressed in 3D world coordinates and\n"
22211  " also normalized 3D coordinates (used for interpreting the altitude and\n"
22212  " azimuth of the viewing angle). The transformations consist of the\n"
22213  " linear transform from 3D world coordinates to normalized 3D\n"
22214  " coordinates, and the 3D rotation of normalized coordinates required to\n"
22215  " align the pole of the new 3D coordinate system with the viewing\n"
22216  " direction specified by altitude and azimuth so that x and y of the\n"
22217  " surface elements in that transformed coordinate system are the\n"
22218  " projection of the 3D surface with given viewing direction on the 2D\n"
22219  " window.\n"
22220  "\n"
22221  " The enclosing rectangular cuboid for the surface plot is defined by\n"
22222  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22223  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22224  " sizes of basex by basey by height so that xmin maps to -\n"
22225  " basex/2, xmax maps to basex/2, ymin maps to -\n"
22226  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22227  " The resulting rectangular cuboid in normalized coordinates is then\n"
22228  " viewed by an observer at altitude alt and azimuth az. This routine\n"
22229  " must be called before plbox3 or any of the 3D surface plotting\n"
22230  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22231  " plsurf3dl or plfill3.\n"
22232  "\n"
22233  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22234  " zmin, zmax, alt, az)\n"
22235  "\n"
22236  " This function is examples 8, 11, 18, and 21.\n"
22237  "\n"
22238  "\n"
22239  "\n"
22240  "SYNOPSIS:\n"
22241  "\n"
22242  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22243  "\n"
22244  "ARGUMENTS:\n"
22245  "\n"
22246  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22247  " rectangular cuboid.\n"
22248  "\n"
22249  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22250  " rectangular cuboid.\n"
22251  "\n"
22252  " height (PLFLT, input) : The normalized z coordinate size of the\n"
22253  " rectangular cuboid.\n"
22254  "\n"
22255  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22256  " rectangular cuboid.\n"
22257  "\n"
22258  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22259  " rectangular cuboid.\n"
22260  "\n"
22261  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22262  " rectangular cuboid.\n"
22263  "\n"
22264  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22265  " rectangular cuboid.\n"
22266  "\n"
22267  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22268  " rectangular cuboid.\n"
22269  "\n"
22270  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22271  " rectangular cuboid.\n"
22272  "\n"
22273  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22274  " plane of the rectangular cuboid in normalized coordinates.\n"
22275  "\n"
22276  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22277  " rectangular cuboid in normalized coordinates. When az=0, the\n"
22278  " observer is looking face onto the zx plane of the rectangular\n"
22279  " cuboid in normalized coordinates, and as az is increased, the\n"
22280  " observer moves clockwise around that cuboid when viewed from above\n"
22281  " the xy plane.\n"
22282  "\n"
22283  ""},
22284  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
22285  "Set pen width\n"
22286  "\n"
22287  "DESCRIPTION:\n"
22288  "\n"
22289  " Sets the pen width.\n"
22290  "\n"
22291  " Redacted form: plwidth(width)\n"
22292  "\n"
22293  " This function is used in examples 1 and 2.\n"
22294  "\n"
22295  "\n"
22296  "\n"
22297  "SYNOPSIS:\n"
22298  "\n"
22299  "plwidth(width)\n"
22300  "\n"
22301  "ARGUMENTS:\n"
22302  "\n"
22303  " width (PLFLT, input) : The desired pen width. If width is negative\n"
22304  " or the same as the previous value no action is taken. width = 0.\n"
22305  " should be interpreted as as the minimum valid pen width for the\n"
22306  " device. The interpretation of positive width values is also\n"
22307  " device dependent.\n"
22308  "\n"
22309  ""},
22310  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
22311  "Specify window\n"
22312  "\n"
22313  "DESCRIPTION:\n"
22314  "\n"
22315  " Specify the window, i.e., the world coordinates of the edges of the\n"
22316  " viewport.\n"
22317  "\n"
22318  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22319  "\n"
22320  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22321  " 29, and 31.\n"
22322  "\n"
22323  "\n"
22324  "\n"
22325  "SYNOPSIS:\n"
22326  "\n"
22327  "plwind(xmin, xmax, ymin, ymax)\n"
22328  "\n"
22329  "ARGUMENTS:\n"
22330  "\n"
22331  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22332  " of the viewport.\n"
22333  "\n"
22334  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22335  " of the viewport.\n"
22336  "\n"
22337  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22338  " the viewport.\n"
22339  "\n"
22340  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22341  " viewport.\n"
22342  "\n"
22343  ""},
22344  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
22345  "Enter or leave xor mode\n"
22346  "\n"
22347  "DESCRIPTION:\n"
22348  "\n"
22349  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22350  " those drivers (e.g., the xwin driver) that support it. Enables\n"
22351  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22352  " is not capable of xor operation it returns a status of false.\n"
22353  "\n"
22354  " Redacted form: plxormod(mode, status)\n"
22355  "\n"
22356  " This function is used in examples 1 and 20.\n"
22357  "\n"
22358  "\n"
22359  "\n"
22360  "SYNOPSIS:\n"
22361  "\n"
22362  "plxormod(mode, status)\n"
22363  "\n"
22364  "ARGUMENTS:\n"
22365  "\n"
22366  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22367  " is false means leave xor mode.\n"
22368  "\n"
22369  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22370  " modestatus of true (false) means driver is capable (incapable) of\n"
22371  " xor mode.\n"
22372  "\n"
22373  ""},
22374  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
22375  "Plot continental outline or shapefile data in world coordinates\n"
22376  "\n"
22377  "DESCRIPTION:\n"
22378  "\n"
22379  " Plots continental outlines or shapefile data in world coordinates. A\n"
22380  " demonstration of how to use this function to create different\n"
22381  " projections can be found in examples/c/x19c. PLplot is provided with\n"
22382  " basic coastal outlines and USA state borders. To use the map\n"
22383  " functionality PLplot must be compiled with the shapelib library.\n"
22384  " Shapefiles have become a popular standard for geographical data and\n"
22385  " data in this format can be easily found from a number of online\n"
22386  " sources. Shapefile data is actually provided as three or more files\n"
22387  " with the same filename, but different extensions. The .shp and .shx\n"
22388  " files are required for plotting Shapefile data with PLplot.\n"
22389  "\n"
22390  " PLplot currently supports the point, multipoint, polyline and polygon\n"
22391  " objects within shapefiles. However holes in polygons are not\n"
22392  " supported. When plmap is used the type of object is derived from the\n"
22393  " shapefile, if you wish to override the type then use one of the other\n"
22394  " plmap variants. The built in maps have line data only.\n"
22395  "\n"
22396  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22397  "\n"
22398  " This function is used in example 19.\n"
22399  "\n"
22400  "\n"
22401  "\n"
22402  "SYNOPSIS:\n"
22403  "\n"
22404  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22405  "\n"
22406  "ARGUMENTS:\n"
22407  "\n"
22408  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22409  " transform the original map data coordinates to a new coordinate\n"
22410  " system. The PLplot-supplied map data is provided as latitudes and\n"
22411  " longitudes; other Shapefile data may be provided in other\n"
22412  " coordinate systems as can be found in their .prj plain text files.\n"
22413  " For example, by using this transform we can change from a\n"
22414  " longitude, latitude coordinate to a polar stereographic\n"
22415  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22416  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22417  " corresponding y coordinates (latitudes for the PLplot supplied\n"
22418  " data). After the call to mapform(), x[] and y[] should be\n"
22419  " replaced by the corresponding plot coordinates. If no transform is\n"
22420  " desired, mapform can be replaced by NULL.\n"
22421  "\n"
22422  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22423  " the type of map plotted. This is either one of the PLplot built-in\n"
22424  " maps or the file name of a set of Shapefile files without the file\n"
22425  " extensions. For the PLplot built-in maps the possible values are:\n"
22426  " \"globe\" -- continental outlines\n"
22427  " \"usa\" -- USA and state boundaries\n"
22428  " \"cglobe\" -- continental outlines and countries\n"
22429  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22430  "\n"
22431  "\n"
22432  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22433  " drawn. The units must match the shapefile (built in maps are\n"
22434  " degrees lat/lon). Objects in the file which do not encroach on the\n"
22435  " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22436  " note this is simply an optimisation, not a clipping so for objects\n"
22437  " with some points inside the box and some points outside the box\n"
22438  " all the points will be rendered. These parameters also define\n"
22439  " latitude and longitude wrapping for shapefiles using these units.\n"
22440  " Longitude points will be wrapped by integer multiples of 360\n"
22441  " degrees to place them in the box. This allows the same data to be\n"
22442  " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22443  " you plot from -180-540 you will get two cycles of data drawn. The\n"
22444  " value of minx must be less than the value of maxx. Passing in a\n"
22445  " nan, max/-max floating point number or +/-infinity will case the\n"
22446  " bounding box from the shapefile to be used.\n"
22447  "\n"
22448  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22449  " drawn - see minx.\n"
22450  "\n"
22451  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22452  " drawn - see minx.\n"
22453  "\n"
22454  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22455  " drawn - see minx.\n"
22456  "\n"
22457  ""},
22458  { (char *)"plmapline", _wrap_plmapline, METH_VARARGS, (char *)"\n"
22459  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22460  "\n"
22461  "DESCRIPTION:\n"
22462  "\n"
22463  " Plot all or a subset of Shapefile data using lines in world\n"
22464  " coordinates. Our 19th standard example demonstrates how to use this\n"
22465  " function. This function plots data from a Shapefile using lines as in\n"
22466  " plmap, however it also has the option of also only drawing specified\n"
22467  " elements from the Shapefile. The vector of indices of the required\n"
22468  " elements are passed as a function argument. The Shapefile data should\n"
22469  " include a metadata file (extension.dbf) listing all items within the\n"
22470  " Shapefile. This file can be opened by most popular spreadsheet\n"
22471  " programs and can be used to decide which indices to pass to this\n"
22472  " function.\n"
22473  "\n"
22474  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22475  " plotentries)\n"
22476  "\n"
22477  " This function is used in example 19.\n"
22478  "\n"
22479  "\n"
22480  "\n"
22481  "SYNOPSIS:\n"
22482  "\n"
22483  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22484  "\n"
22485  "ARGUMENTS:\n"
22486  "\n"
22487  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22488  " transform the coordinates given in the shapefile into a plot\n"
22489  " coordinate system. By using this transform, we can change from a\n"
22490  " longitude, latitude coordinate to a polar stereographic project,\n"
22491  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22492  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22493  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22494  " plot coordinates. If no transform is desired, mapform can be\n"
22495  " replaced by NULL.\n"
22496  "\n"
22497  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22498  " the file name of a set of Shapefile files without the file\n"
22499  " extension.\n"
22500  "\n"
22501  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22502  " be in the same units as used by the Shapefile. You could use a\n"
22503  " very large negative number to plot everything, but you can improve\n"
22504  " performance by limiting the area drawn. The units must match those\n"
22505  " of the Shapefile projection, which may be for example longitude or\n"
22506  " distance. The value of minx must be less than the value of maxx.\n"
22507  "\n"
22508  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22509  " use a very large number to plot everything, but you can improve\n"
22510  " performance by limiting the area drawn.\n"
22511  "\n"
22512  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22513  " be in the same units as used by the Shapefile. You could use a\n"
22514  " very large negative number to plot everything, but you can improve\n"
22515  " performance by limiting the area drawn. The units must match those\n"
22516  " of the Shapefile projection, which may be for example latitude or\n"
22517  " distance. The value of miny must be less than the value of maxy.\n"
22518  "\n"
22519  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22520  " use a very large number to plot everything, but you can improve\n"
22521  " performance by limiting the area drawn.\n"
22522  "\n"
22523  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22524  " zero-based indices of the Shapefile elements which will be drawn.\n"
22525  " Setting\n"
22526  " plotentries to NULL will plot all elements of the Shapefile.\n"
22527  "\n"
22528  " nplotentries (PLINT, input) : The number of items in\n"
22529  " plotentries. Ignored if\n"
22530  " plotentries is NULL.\n"
22531  "\n"
22532  ""},
22533  { (char *)"plmapstring", _wrap_plmapstring, METH_VARARGS, (char *)"\n"
22534  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22535  "\n"
22536  "DESCRIPTION:\n"
22537  "\n"
22538  " As per plmapline, however the items are plotted as strings or points\n"
22539  " in the same way as plstring.\n"
22540  "\n"
22541  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22542  " maxy, plotentries)\n"
22543  "\n"
22544  " This function is not used in any examples.\n"
22545  "\n"
22546  "\n"
22547  "\n"
22548  "SYNOPSIS:\n"
22549  "\n"
22550  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22551  "\n"
22552  "ARGUMENTS:\n"
22553  "\n"
22554  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22555  " transform the coordinates given in the shapefile into a plot\n"
22556  " coordinate system. By using this transform, we can change from a\n"
22557  " longitude, latitude coordinate to a polar stereographic project,\n"
22558  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22559  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22560  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22561  " plot coordinates. If no transform is desired, mapform can be\n"
22562  " replaced by NULL.\n"
22563  "\n"
22564  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22565  " the file name of a set of Shapefile files without the file\n"
22566  " extension.\n"
22567  "\n"
22568  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22569  " drawn.\n"
22570  "\n"
22571  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22572  " be in the same units as used by the Shapefile. You could use a\n"
22573  " very large negative number to plot everything, but you can improve\n"
22574  " performance by limiting the area drawn. The units must match those\n"
22575  " of the Shapefile projection, which may be for example longitude or\n"
22576  " distance. The value of minx must be less than the value of maxx.\n"
22577  "\n"
22578  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22579  " use a very large number to plot everything, but you can improve\n"
22580  " performance by limiting the area drawn.\n"
22581  "\n"
22582  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22583  " be in the same units as used by the Shapefile. You could use a\n"
22584  " very large negative number to plot everything, but you can improve\n"
22585  " performance by limiting the area drawn. The units must match those\n"
22586  " of the Shapefile projection, which may be for example latitude or\n"
22587  " distance. The value of miny must be less than the value of maxy.\n"
22588  "\n"
22589  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22590  " use a very large number to plot everything, but you can improve\n"
22591  " performance by limiting the area drawn.\n"
22592  "\n"
22593  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22594  " zero-based indices of the Shapefile elements which will be drawn.\n"
22595  " Setting\n"
22596  " plotentries to NULL will plot all elements of the Shapefile.\n"
22597  "\n"
22598  " nplotentries (PLINT, input) : The number of items in\n"
22599  " plotentries. Ignored if\n"
22600  " plotentries is NULL.\n"
22601  "\n"
22602  ""},
22603  { (char *)"plmaptex", _wrap_plmaptex, METH_VARARGS, (char *)"\n"
22604  "Draw text at points defined by Shapefile data in world coordinates\n"
22605  "\n"
22606  "DESCRIPTION:\n"
22607  "\n"
22608  " As per plmapline, however the items are plotted as text in the same\n"
22609  " way as plptex.\n"
22610  "\n"
22611  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22612  " miny, maxy, plotentry)\n"
22613  "\n"
22614  " This function is used in example 19.\n"
22615  "\n"
22616  "\n"
22617  "\n"
22618  "SYNOPSIS:\n"
22619  "\n"
22620  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22621  "\n"
22622  "ARGUMENTS:\n"
22623  "\n"
22624  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22625  " transform the coordinates given in the shapefile into a plot\n"
22626  " coordinate system. By using this transform, we can change from a\n"
22627  " longitude, latitude coordinate to a polar stereographic project,\n"
22628  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22629  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22630  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22631  " plot coordinates. If no transform is desired, mapform can be\n"
22632  " replaced by NULL.\n"
22633  "\n"
22634  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22635  " the file name of a set of Shapefile files without the file\n"
22636  " extension.\n"
22637  "\n"
22638  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22639  " dy/dx.\n"
22640  "\n"
22641  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22642  " dy/dx.\n"
22643  "\n"
22644  " just (PLFLT, input) : Set the justification of the text. The value\n"
22645  " given will be the fraction of the distance along the string that\n"
22646  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22647  " centralized text and 1.0 gives right aligned text.\n"
22648  "\n"
22649  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22650  "\n"
22651  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22652  " be in the same units as used by the Shapefile. You could use a\n"
22653  " very large negative number to plot everything, but you can improve\n"
22654  " performance by limiting the area drawn. The units must match those\n"
22655  " of the Shapefile projection, which may be for example longitude or\n"
22656  " distance. The value of minx must be less than the value of maxx.\n"
22657  "\n"
22658  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22659  " use a very large number to plot everything, but you can improve\n"
22660  " performance by limiting the area drawn.\n"
22661  "\n"
22662  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22663  " be in the same units as used by the Shapefile. You could use a\n"
22664  " very large negative number to plot everything, but you can improve\n"
22665  " performance by limiting the area drawn. The units must match those\n"
22666  " of the Shapefile projection, which may be for example latitude or\n"
22667  " distance. The value of miny must be less than the value of maxy.\n"
22668  "\n"
22669  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22670  " use a very large number to plot everything, but you can improve\n"
22671  " performance by limiting the area drawn.\n"
22672  "\n"
22673  " plotentry (PLINT, input) : An integer indicating which text string\n"
22674  " of the Shapefile (zero indexed) will be drawn.\n"
22675  "\n"
22676  ""},
22677  { (char *)"plmapfill", _wrap_plmapfill, METH_VARARGS, (char *)"\n"
22678  "Plot all or a subset of Shapefile data, filling the polygons\n"
22679  "\n"
22680  "DESCRIPTION:\n"
22681  "\n"
22682  " As per plmapline, however the items are filled in the same way as\n"
22683  " plfill.\n"
22684  "\n"
22685  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22686  " plotentries)\n"
22687  "\n"
22688  " This function is used in example 19.\n"
22689  "\n"
22690  "\n"
22691  "\n"
22692  "SYNOPSIS:\n"
22693  "\n"
22694  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22695  "\n"
22696  "ARGUMENTS:\n"
22697  "\n"
22698  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22699  " transform the coordinates given in the shapefile into a plot\n"
22700  " coordinate system. By using this transform, we can change from a\n"
22701  " longitude, latitude coordinate to a polar stereographic project,\n"
22702  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22703  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22704  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22705  " plot coordinates. If no transform is desired, mapform can be\n"
22706  " replaced by NULL.\n"
22707  "\n"
22708  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22709  " the file name of a set of Shapefile files without the file\n"
22710  " extension.\n"
22711  "\n"
22712  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22713  " be in the same units as used by the Shapefile. You could use a\n"
22714  " very large negative number to plot everything, but you can improve\n"
22715  " performance by limiting the area drawn. The units must match those\n"
22716  " of the Shapefile projection, which may be for example longitude or\n"
22717  " distance. The value of minx must be less than the value of maxx.\n"
22718  "\n"
22719  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22720  " use a very large number to plot everything, but you can improve\n"
22721  " performance by limiting the area drawn.\n"
22722  "\n"
22723  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22724  " be in the same units as used by the Shapefile. You could use a\n"
22725  " very large negative number to plot everything, but you can improve\n"
22726  " performance by limiting the area drawn. The units must match those\n"
22727  " of the Shapefile projection, which may be for example latitude or\n"
22728  " distance. The value of miny must be less than the value of maxy.\n"
22729  "\n"
22730  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22731  " use a very large number to plot everything, but you can improve\n"
22732  " performance by limiting the area drawn.\n"
22733  "\n"
22734  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22735  " zero-based indices of the Shapefile elements which will be drawn.\n"
22736  " Setting\n"
22737  " plotentries to NULL will plot all elements of the Shapefile.\n"
22738  "\n"
22739  " nplotentries (PLINT, input) : The number of items in\n"
22740  " plotentries. Ignored if\n"
22741  " plotentries is NULL.\n"
22742  "\n"
22743  ""},
22744  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
22745  "Plot latitude and longitude lines\n"
22746  "\n"
22747  "DESCRIPTION:\n"
22748  "\n"
22749  " Displays latitude and longitude on the current plot. The lines are\n"
22750  " plotted in the current color and line style.\n"
22751  "\n"
22752  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22753  " minlat, maxlat)\n"
22754  "\n"
22755  " This function is used in example 19.\n"
22756  "\n"
22757  "\n"
22758  "\n"
22759  "SYNOPSIS:\n"
22760  "\n"
22761  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22762  "\n"
22763  "ARGUMENTS:\n"
22764  "\n"
22765  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22766  " transform the coordinate longitudes and latitudes to a plot\n"
22767  " coordinate system. By using this transform, we can change from a\n"
22768  " longitude, latitude coordinate to a polar stereographic project,\n"
22769  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22770  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22771  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22772  " plot coordinates. If no transform is desired, mapform can be\n"
22773  " replaced by NULL.\n"
22774  "\n"
22775  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22776  " longitude lines are to be plotted.\n"
22777  "\n"
22778  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22779  " lines are to be plotted.\n"
22780  "\n"
22781  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22782  " side of the plot. The value of minlong must be less than the value\n"
22783  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22784  " equal to 360.\n"
22785  "\n"
22786  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22787  " side of the plot.\n"
22788  "\n"
22789  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22790  " background. One can always use -90.0 as the boundary outside the\n"
22791  " plot window will be automatically eliminated. However, the\n"
22792  " program will be faster if one can reduce the size of the\n"
22793  " background plotted.\n"
22794  "\n"
22795  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22796  " background. One can always use 90.0 as the boundary outside the\n"
22797  " plot window will be automatically eliminated.\n"
22798  "\n"
22799  ""},
22800  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
22801  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22802  "\n"
22803  "DESCRIPTION:\n"
22804  "\n"
22805  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22806  " automatically adjusted to use the maximum and minimum values in idata\n"
22807  " as valuemin and valuemax in a call to plimagefr.\n"
22808  "\n"
22809  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22810  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22811  "\n"
22812  "\n"
22813  " This function is used in example 20.\n"
22814  "\n"
22815  "\n"
22816  "\n"
22817  "SYNOPSIS:\n"
22818  "\n"
22819  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22820  "\n"
22821  "ARGUMENTS:\n"
22822  "\n"
22823  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22824  " to plot. Should have dimensions of\n"
22825  " nx by\n"
22826  " ny.\n"
22827  "\n"
22828  " nx, ny (PLINT, input) : Dimensions of idata\n"
22829  "\n"
22830  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22831  " are linearly transformed to these world coordinate ranges such\n"
22832  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22833  " - 1] corresponds to (xmax, ymax).\n"
22834  "\n"
22835  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22836  " (inclusive) will be plotted.\n"
22837  "\n"
22838  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22839  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22840  " Dymin) to (Dxmax, Dymax).\n"
22841  "\n"
22842  ""},
22843  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
22844  "Plot a 2D matrix using cmap1\n"
22845  "\n"
22846  "DESCRIPTION:\n"
22847  "\n"
22848  " Plot a 2D matrix using cmap1.\n"
22849  "\n"
22850  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22851  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22852  "\n"
22853  "\n"
22854  " This function is used in example 20.\n"
22855  "\n"
22856  "\n"
22857  "\n"
22858  "SYNOPSIS:\n"
22859  "\n"
22860  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22861  "\n"
22862  "ARGUMENTS:\n"
22863  "\n"
22864  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22865  " plot. Should have dimensions of\n"
22866  " nx by\n"
22867  " ny.\n"
22868  "\n"
22869  " nx, ny (PLINT, input) : Dimensions of idata\n"
22870  "\n"
22871  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22872  " pltr below for how these arguments are used (only for the special case\n"
22873  " when the callback function\n"
22874  " pltr is not supplied).\n"
22875  "\n"
22876  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22877  " (inclusive) will be plotted.\n"
22878  "\n"
22879  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22880  " values to use for value to color mappings. A datum equal to or\n"
22881  " less than valuemin will be plotted with color 0.0, while a datum\n"
22882  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22883  " Data between valuemin and valuemax map linearly to colors in the\n"
22884  " range (0.0-1.0).\n"
22885  "\n"
22886  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22887  " defines the transformation between the zero-based indices of the\n"
22888  " matrix idata and world coordinates. If\n"
22889  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22890  " indices of idata are mapped to the range\n"
22891  " xmin through\n"
22892  " xmax and the y indices of idata are mapped to the range\n"
22893  " ymin through\n"
22894  " ymax.For the C case, transformation functions are provided in the\n"
22895  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22896  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22897  " matrices. In addition, C callback routines for the transformation\n"
22898  " can be supplied by the user such as the mypltr function in\n"
22899  " examples/c/x09c.c which provides a general linear transformation\n"
22900  " between index coordinates and world coordinates.For languages\n"
22901  " other than C you should consult the PLplot documentation for the\n"
22902  " details concerning how PLTRANSFORM_callback arguments are\n"
22903  " interfaced. However, in general, a particular pattern of\n"
22904  " callback-associated arguments such as a tr vector with 6 elements;\n"
22905  " xg and yg vectors; or xg and yg matrices are respectively\n"
22906  " interfaced to a linear-transformation routine similar to the above\n"
22907  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22908  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22909  " support native language callbacks for handling index to\n"
22910  " world-coordinate transformations. Examples of these various\n"
22911  " approaches are given in examples/<language>x09*,\n"
22912  " examples/<language>x16*, examples/<language>x20*,\n"
22913  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22914  " supported languages.\n"
22915  "\n"
22916  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22917  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22918  " externally supplied.\n"
22919  "\n"
22920  ""},
22921  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
22922  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
22923  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22924  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
22925  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
22926  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, (char *)"\n"
22927  "Wait for graphics input event and translate to world coordinates.\n"
22928  "\n"
22929  "DESCRIPTION:\n"
22930  "\n"
22931  " Wait for graphics input event and translate to world coordinates.\n"
22932  " Returns 0 if no translation to world coordinates is possible.\n"
22933  "\n"
22934  " This function returns 1 on success and 0 if no translation to world\n"
22935  " coordinates is possible.\n"
22936  "\n"
22937  " Redacted form: plGetCursor(gin)\n"
22938  "\n"
22939  " This function is used in examples 1 and 20.\n"
22940  "\n"
22941  "\n"
22942  "\n"
22943  "SYNOPSIS:\n"
22944  "\n"
22945  "PLINT plGetCursor(gin)\n"
22946  "\n"
22947  "ARGUMENTS:\n"
22948  "\n"
22949  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22950  " which will contain the output. The structure is not allocated by\n"
22951  " the routine and must exist before the function is called.\n"
22952  "\n"
22953  ""},
22954  { NULL, NULL, 0, NULL }
22955 };
22956 
22957 
22958 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22959 
22960 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22961 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22962 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22963 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22964 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22965 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};
22966 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};
22967 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};
22968 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};
22969 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};
22970 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22971 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22972 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22973 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22974 
22979  &_swigt__p_char,
22986  &_swigt__p_int,
22990 };
22991 
22992 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22993 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22994 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22995 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22996 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23002 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23003 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23004 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23005 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23006 
23018  _swigc__p_int,
23022 };
23023 
23024 
23025 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23026 
23028 {0, 0, 0, 0.0, 0, 0}};
23029 
23030 #ifdef __cplusplus
23031 }
23032 #endif
23033 /* -----------------------------------------------------------------------------
23034  * Type initialization:
23035  * This problem is tough by the requirement that no dynamic
23036  * memory is used. Also, since swig_type_info structures store pointers to
23037  * swig_cast_info structures and swig_cast_info structures store pointers back
23038  * to swig_type_info structures, we need some lookup code at initialization.
23039  * The idea is that swig generates all the structures that are needed.
23040  * The runtime then collects these partially filled structures.
23041  * The SWIG_InitializeModule function takes these initial arrays out of
23042  * swig_module, and does all the lookup, filling in the swig_module.types
23043  * array with the correct data and linking the correct swig_cast_info
23044  * structures together.
23045  *
23046  * The generated swig_type_info structures are assigned statically to an initial
23047  * array. We just loop through that array, and handle each type individually.
23048  * First we lookup if this type has been already loaded, and if so, use the
23049  * loaded structure instead of the generated one. Then we have to fill in the
23050  * cast linked list. The cast data is initially stored in something like a
23051  * two-dimensional array. Each row corresponds to a type (there are the same
23052  * number of rows as there are in the swig_type_initial array). Each entry in
23053  * a column is one of the swig_cast_info structures for that type.
23054  * The cast_initial array is actually an array of arrays, because each row has
23055  * a variable number of columns. So to actually build the cast linked list,
23056  * we find the array of casts associated with the type, and loop through it
23057  * adding the casts to the list. The one last trick we need to do is making
23058  * sure the type pointer in the swig_cast_info struct is correct.
23059  *
23060  * First off, we lookup the cast->type name to see if it is already loaded.
23061  * There are three cases to handle:
23062  * 1) If the cast->type has already been loaded AND the type we are adding
23063  * casting info to has not been loaded (it is in this module), THEN we
23064  * replace the cast->type pointer with the type pointer that has already
23065  * been loaded.
23066  * 2) If BOTH types (the one we are adding casting info to, and the
23067  * cast->type) are loaded, THEN the cast info has already been loaded by
23068  * the previous module so we just ignore it.
23069  * 3) Finally, if cast->type has not already been loaded, then we add that
23070  * swig_cast_info to the linked list (because the cast->type) pointer will
23071  * be correct.
23072  * ----------------------------------------------------------------------------- */
23073 
23074 #ifdef __cplusplus
23075 extern "C" {
23076 #if 0
23077 } /* c-mode */
23078 #endif
23079 #endif
23080 
23081 #if 0
23082 #define SWIGRUNTIME_DEBUG
23083 #endif
23084 
23085 
23086 SWIGRUNTIME void
23087 SWIG_InitializeModule(void *clientdata) {
23088  size_t i;
23089  swig_module_info *module_head, *iter;
23090  int init;
23091 
23092  /* check to see if the circular list has been setup, if not, set it up */
23093  if (swig_module.next==0) {
23094  /* Initialize the swig_module */
23098  init = 1;
23099  } else {
23100  init = 0;
23101  }
23102 
23103  /* Try and load any already created modules */
23104  module_head = SWIG_GetModule(clientdata);
23105  if (!module_head) {
23106  /* This is the first module loaded for this interpreter */
23107  /* so set the swig module into the interpreter */
23108  SWIG_SetModule(clientdata, &swig_module);
23109  } else {
23110  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23111  iter=module_head;
23112  do {
23113  if (iter==&swig_module) {
23114  /* Our module is already in the list, so there's nothing more to do. */
23115  return;
23116  }
23117  iter=iter->next;
23118  } while (iter!= module_head);
23119 
23120  /* otherwise we must add our module into the list */
23121  swig_module.next = module_head->next;
23122  module_head->next = &swig_module;
23123  }
23124 
23125  /* When multiple interpreters are used, a module could have already been initialized in
23126  a different interpreter, but not yet have a pointer in this interpreter.
23127  In this case, we do not want to continue adding types... everything should be
23128  set up already */
23129  if (init == 0) return;
23130 
23131  /* Now work on filling in swig_module.types */
23132 #ifdef SWIGRUNTIME_DEBUG
23133  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23134 #endif
23135  for (i = 0; i < swig_module.size; ++i) {
23136  swig_type_info *type = 0;
23137  swig_type_info *ret;
23138  swig_cast_info *cast;
23139 
23140 #ifdef SWIGRUNTIME_DEBUG
23141  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23142 #endif
23143 
23144  /* if there is another module already loaded */
23145  if (swig_module.next != &swig_module) {
23147  }
23148  if (type) {
23149  /* Overwrite clientdata field */
23150 #ifdef SWIGRUNTIME_DEBUG
23151  printf("SWIG_InitializeModule: found type %s\n", type->name);
23152 #endif
23155 #ifdef SWIGRUNTIME_DEBUG
23156  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23157 #endif
23158  }
23159  } else {
23160  type = swig_module.type_initial[i];
23161  }
23162 
23163  /* Insert casting types */
23164  cast = swig_module.cast_initial[i];
23165  while (cast->type) {
23166  /* Don't need to add information already in the list */
23167  ret = 0;
23168 #ifdef SWIGRUNTIME_DEBUG
23169  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23170 #endif
23171  if (swig_module.next != &swig_module) {
23173 #ifdef SWIGRUNTIME_DEBUG
23174  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23175 #endif
23176  }
23177  if (ret) {
23178  if (type == swig_module.type_initial[i]) {
23179 #ifdef SWIGRUNTIME_DEBUG
23180  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23181 #endif
23182  cast->type = ret;
23183  ret = 0;
23184  } else {
23185  /* Check for casting already in the list */
23186  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23187 #ifdef SWIGRUNTIME_DEBUG
23188  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23189 #endif
23190  if (!ocast) ret = 0;
23191  }
23192  }
23193 
23194  if (!ret) {
23195 #ifdef SWIGRUNTIME_DEBUG
23196  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23197 #endif
23198  if (type->cast) {
23199  type->cast->prev = cast;
23200  cast->next = type->cast;
23201  }
23202  type->cast = cast;
23203  }
23204  cast++;
23205  }
23206  /* Set entry in modules->types array equal to the type */
23207  swig_module.types[i] = type;
23208  }
23209  swig_module.types[i] = 0;
23210 
23211 #ifdef SWIGRUNTIME_DEBUG
23212  printf("**** SWIG_InitializeModule: Cast List ******\n");
23213  for (i = 0; i < swig_module.size; ++i) {
23214  int j = 0;
23216  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23217  while (cast->type) {
23218  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23219  cast++;
23220  ++j;
23221  }
23222  printf("---- Total casts: %d\n",j);
23223  }
23224  printf("**** SWIG_InitializeModule: Cast List ******\n");
23225 #endif
23226 }
23227 
23228 /* This function will propagate the clientdata field of type to
23229 * any new swig_type_info structures that have been added into the list
23230 * of equivalent types. It is like calling
23231 * SWIG_TypeClientData(type, clientdata) a second time.
23232 */
23233 SWIGRUNTIME void
23235  size_t i;
23236  swig_cast_info *equiv;
23237  static int init_run = 0;
23238 
23239  if (init_run) return;
23240  init_run = 1;
23241 
23242  for (i = 0; i < swig_module.size; i++) {
23243  if (swig_module.types[i]->clientdata) {
23244  equiv = swig_module.types[i]->cast;
23245  while (equiv) {
23246  if (!equiv->converter) {
23247  if (equiv->type && !equiv->type->clientdata)
23249  }
23250  equiv = equiv->next;
23251  }
23252  }
23253  }
23254 }
23255 
23256 #ifdef __cplusplus
23257 #if 0
23258 {
23259  /* c-mode */
23260 #endif
23261 }
23262 #endif
23263 
23264 
23265 
23266 #ifdef __cplusplus
23267 extern "C" {
23268 #endif
23269 
23270  /* Python-specific SWIG API */
23271 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23272 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23273 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23274 
23275  /* -----------------------------------------------------------------------------
23276  * global variable support code.
23277  * ----------------------------------------------------------------------------- */
23278 
23279  typedef struct swig_globalvar {
23280  char *name; /* Name of global variable */
23281  PyObject *(*get_attr)(void); /* Return the current value */
23282  int (*set_attr)(PyObject *); /* Set the value */
23284  } swig_globalvar;
23285 
23286  typedef struct swig_varlinkobject {
23287  PyObject_HEAD
23290 
23291  SWIGINTERN PyObject *
23293 #if PY_VERSION_HEX >= 0x03000000
23294  return PyUnicode_InternFromString("<Swig global variables>");
23295 #else
23296  return PyString_FromString("<Swig global variables>");
23297 #endif
23298  }
23299 
23300  SWIGINTERN PyObject *
23302 #if PY_VERSION_HEX >= 0x03000000
23303  PyObject *str = PyUnicode_InternFromString("(");
23304  PyObject *tail;
23305  PyObject *joined;
23306  swig_globalvar *var;
23307  for (var = v->vars; var; var=var->next) {
23308  tail = PyUnicode_FromString(var->name);
23309  joined = PyUnicode_Concat(str, tail);
23310  Py_DecRef(str);
23311  Py_DecRef(tail);
23312  str = joined;
23313  if (var->next) {
23314  tail = PyUnicode_InternFromString(", ");
23315  joined = PyUnicode_Concat(str, tail);
23316  Py_DecRef(str);
23317  Py_DecRef(tail);
23318  str = joined;
23319  }
23320  }
23321  tail = PyUnicode_InternFromString(")");
23322  joined = PyUnicode_Concat(str, tail);
23323  Py_DecRef(str);
23324  Py_DecRef(tail);
23325  str = joined;
23326 #else
23327  PyObject *str = PyString_FromString("(");
23328  swig_globalvar *var;
23329  for (var = v->vars; var; var=var->next) {
23330  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
23331  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
23332  }
23333  PyString_ConcatAndDel(&str,PyString_FromString(")"));
23334 #endif
23335  return str;
23336  }
23337 
23338  SWIGINTERN int
23340  PyObject *str = swig_varlink_str(v);
23341  const char *tmp = SWIG_Python_str_AsChar(str);
23342  fprintf(fp,"Swig global variables ");
23343  fprintf(fp,"%s\n", tmp ? tmp : "Invalid global variable");
23345  Py_DECREF(str);
23346  return 0;
23347  }
23348 
23349  SWIGINTERN void
23351  swig_globalvar *var = v->vars;
23352  while (var) {
23353  swig_globalvar *n = var->next;
23354  free(var->name);
23355  free(var);
23356  var = n;
23357  }
23358  }
23359 
23360  SWIGINTERN PyObject *
23362  PyObject *res = NULL;
23363  swig_globalvar *var = v->vars;
23364  while (var) {
23365  if (strcmp(var->name,n) == 0) {
23366  res = (*var->get_attr)();
23367  break;
23368  }
23369  var = var->next;
23370  }
23371  if (res == NULL && !PyErr_Occurred()) {
23372  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23373  }
23374  return res;
23375  }
23376 
23377  SWIGINTERN int
23378  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23379  int res = 1;
23380  swig_globalvar *var = v->vars;
23381  while (var) {
23382  if (strcmp(var->name,n) == 0) {
23383  res = (*var->set_attr)(p);
23384  break;
23385  }
23386  var = var->next;
23387  }
23388  if (res == 1 && !PyErr_Occurred()) {
23389  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
23390  }
23391  return res;
23392  }
23393 
23394  SWIGINTERN PyTypeObject*
23396  static char varlink__doc__[] = "Swig var link object";
23397  static PyTypeObject varlink_type;
23398  static int type_init = 0;
23399  if (!type_init) {
23400  const PyTypeObject tmp = {
23401 #if PY_VERSION_HEX >= 0x03000000
23402  PyVarObject_HEAD_INIT(NULL, 0)
23403 #else
23404  PyObject_HEAD_INIT(NULL)
23405  0, /* ob_size */
23406 #endif
23407  (char *)"swigvarlink", /* tp_name */
23408  sizeof(swig_varlinkobject), /* tp_basicsize */
23409  0, /* tp_itemsize */
23410  (destructor) swig_varlink_dealloc, /* tp_dealloc */
23411  (printfunc) swig_varlink_print, /* tp_print */
23412  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
23413  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
23414  0, /* tp_compare */
23415  (reprfunc) swig_varlink_repr, /* tp_repr */
23416  0, /* tp_as_number */
23417  0, /* tp_as_sequence */
23418  0, /* tp_as_mapping */
23419  0, /* tp_hash */
23420  0, /* tp_call */
23421  (reprfunc) swig_varlink_str, /* tp_str */
23422  0, /* tp_getattro */
23423  0, /* tp_setattro */
23424  0, /* tp_as_buffer */
23425  0, /* tp_flags */
23426  varlink__doc__, /* tp_doc */
23427  0, /* tp_traverse */
23428  0, /* tp_clear */
23429  0, /* tp_richcompare */
23430  0, /* tp_weaklistoffset */
23431 #if PY_VERSION_HEX >= 0x02020000
23432  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23433 #endif
23434 #if PY_VERSION_HEX >= 0x02030000
23435  0, /* tp_del */
23436 #endif
23437 #if PY_VERSION_HEX >= 0x02060000
23438  0, /* tp_version_tag */
23439 #endif
23440 #if PY_VERSION_HEX >= 0x03040000
23441  0, /* tp_finalize */
23442 #endif
23443 #ifdef COUNT_ALLOCS
23444  0, /* tp_allocs */
23445  0, /* tp_frees */
23446  0, /* tp_maxalloc */
23447 #if PY_VERSION_HEX >= 0x02050000
23448  0, /* tp_prev */
23449 #endif
23450  0 /* tp_next */
23451 #endif
23452  };
23453  varlink_type = tmp;
23454  type_init = 1;
23455 #if PY_VERSION_HEX < 0x02020000
23456  varlink_type.ob_type = &PyType_Type;
23457 #else
23458  if (PyType_Ready(&varlink_type) < 0)
23459  return NULL;
23460 #endif
23461  }
23462  return &varlink_type;
23463  }
23464 
23465  /* Create a variable linking object for use later */
23466  SWIGINTERN PyObject *
23468  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
23469  if (result) {
23470  result->vars = 0;
23471  }
23472  return ((PyObject*) result);
23473  }
23474 
23475  SWIGINTERN void
23476  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23478  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23479  if (gv) {
23480  size_t size = strlen(name)+1;
23481  gv->name = (char *)malloc(size);
23482  if (gv->name) {
23483  strncpy(gv->name,name,size);
23484  gv->get_attr = get_attr;
23485  gv->set_attr = set_attr;
23486  gv->next = v->vars;
23487  }
23488  }
23489  v->vars = gv;
23490  }
23491 
23492  SWIGINTERN PyObject *
23494  static PyObject *_SWIG_globals = 0;
23495  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
23496  return _SWIG_globals;
23497  }
23498 
23499  /* -----------------------------------------------------------------------------
23500  * constants/methods manipulation
23501  * ----------------------------------------------------------------------------- */
23502 
23503  /* Install Constants */
23504  SWIGINTERN void
23505  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23506  PyObject *obj = 0;
23507  size_t i;
23508  for (i = 0; constants[i].type; ++i) {
23509  switch(constants[i].type) {
23510  case SWIG_PY_POINTER:
23511  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23512  break;
23513  case SWIG_PY_BINARY:
23514  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23515  break;
23516  default:
23517  obj = 0;
23518  break;
23519  }
23520  if (obj) {
23521  PyDict_SetItemString(d, constants[i].name, obj);
23522  Py_DECREF(obj);
23523  }
23524  }
23525  }
23526 
23527  /* -----------------------------------------------------------------------------*/
23528  /* Fix SwigMethods to carry the callback ptrs when needed */
23529  /* -----------------------------------------------------------------------------*/
23530 
23531  SWIGINTERN void
23532  SWIG_Python_FixMethods(PyMethodDef *methods,
23533  swig_const_info *const_table,
23534  swig_type_info **types,
23535  swig_type_info **types_initial) {
23536  size_t i;
23537  for (i = 0; methods[i].ml_name; ++i) {
23538  const char *c = methods[i].ml_doc;
23539  if (!c) continue;
23540  c = strstr(c, "swig_ptr: ");
23541  if (c) {
23542  int j;
23543  swig_const_info *ci = 0;
23544  const char *name = c + 10;
23545  for (j = 0; const_table[j].type; ++j) {
23546  if (strncmp(const_table[j].name, name,
23547  strlen(const_table[j].name)) == 0) {
23548  ci = &(const_table[j]);
23549  break;
23550  }
23551  }
23552  if (ci) {
23553  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23554  if (ptr) {
23555  size_t shift = (ci->ptype) - types;
23556  swig_type_info *ty = types_initial[shift];
23557  size_t ldoc = (c - methods[i].ml_doc);
23558  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23559  char *ndoc = (char*)malloc(ldoc + lptr + 10);
23560  if (ndoc) {
23561  char *buff = ndoc;
23562  memcpy(buff, methods[i].ml_doc, ldoc);
23563  buff += ldoc;
23564  memcpy(buff, "swig_ptr: ", 10);
23565  buff += 10;
23566  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23567  methods[i].ml_doc = ndoc;
23568  }
23569  }
23570  }
23571  }
23572  }
23573  }
23574 
23575 #ifdef __cplusplus
23576 }
23577 #endif
23578 
23579 /* -----------------------------------------------------------------------------*
23580  * Partial Init method
23581  * -----------------------------------------------------------------------------*/
23582 
23583 #ifdef __cplusplus
23584 extern "C"
23585 #endif
23586 
23587 SWIGEXPORT
23588 #if PY_VERSION_HEX >= 0x03000000
23589 PyObject*
23590 #else
23591 void
23592 #endif
23593 SWIG_init(void) {
23594  PyObject *m, *d, *md;
23595 #if PY_VERSION_HEX >= 0x03000000
23596  static struct PyModuleDef SWIG_module = {
23597 # if PY_VERSION_HEX >= 0x03020000
23598  PyModuleDef_HEAD_INIT,
23599 # else
23600  {
23601  PyObject_HEAD_INIT(NULL)
23602  NULL, /* m_init */
23603  0, /* m_index */
23604  NULL, /* m_copy */
23605  },
23606 # endif
23607  (char *) SWIG_name,
23608  NULL,
23609  -1,
23610  SwigMethods,
23611  NULL,
23612  NULL,
23613  NULL,
23614  NULL
23615  };
23616 #endif
23617 
23618 #if defined(SWIGPYTHON_BUILTIN)
23619  static SwigPyClientData SwigPyObject_clientdata = {
23620  0, 0, 0, 0, 0, 0, 0
23621  };
23622  static PyGetSetDef this_getset_def = {
23623  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23624  };
23625  static SwigPyGetSet thisown_getset_closure = {
23626  (PyCFunction) SwigPyObject_own,
23627  (PyCFunction) SwigPyObject_own
23628  };
23629  static PyGetSetDef thisown_getset_def = {
23630  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23631  };
23632  PyTypeObject *builtin_pytype;
23633  int builtin_base_count;
23634  swig_type_info *builtin_basetype;
23635  PyObject *tuple;
23636  PyGetSetDescrObject *static_getset;
23637  PyTypeObject *metatype;
23638  PyTypeObject *swigpyobject;
23639  SwigPyClientData *cd;
23640  PyObject *public_interface, *public_symbol;
23641  PyObject *this_descr;
23642  PyObject *thisown_descr;
23643  PyObject *self = 0;
23644  int i;
23645 
23646  (void)builtin_pytype;
23647  (void)builtin_base_count;
23648  (void)builtin_basetype;
23649  (void)tuple;
23650  (void)static_getset;
23651  (void)self;
23652 
23653  /* Metaclass is used to implement static member variables */
23654  metatype = SwigPyObjectType();
23655  assert(metatype);
23656 #endif
23657 
23658  /* Fix SwigMethods to carry the callback ptrs when needed */
23660 
23661 #if PY_VERSION_HEX >= 0x03000000
23662  m = PyModule_Create(&SWIG_module);
23663 #else
23664  m = Py_InitModule((char *) SWIG_name, SwigMethods);
23665 #endif
23666 
23667  md = d = PyModule_GetDict(m);
23668  (void)md;
23669 
23671 
23672 #ifdef SWIGPYTHON_BUILTIN
23673  swigpyobject = SwigPyObject_TypeOnce();
23674 
23675  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23676  assert(SwigPyObject_stype);
23677  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23678  if (!cd) {
23679  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23680  SwigPyObject_clientdata.pytype = swigpyobject;
23681  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23682  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23683 # if PY_VERSION_HEX >= 0x03000000
23684  return NULL;
23685 # else
23686  return;
23687 # endif
23688  }
23689 
23690  /* All objects have a 'this' attribute */
23691  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23692  (void)this_descr;
23693 
23694  /* All objects have a 'thisown' attribute */
23695  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23696  (void)thisown_descr;
23697 
23698  public_interface = PyList_New(0);
23699  public_symbol = 0;
23700  (void)public_symbol;
23701 
23702  PyDict_SetItemString(md, "__all__", public_interface);
23703  Py_DECREF(public_interface);
23704  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23705  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23706  for (i = 0; swig_const_table[i].name != 0; ++i)
23707  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23708 #endif
23709 
23711 
23712 
23713  import_array();
23714 
23715  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23716  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23717  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23718  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23719  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23720  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23721  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23722  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23723  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23724  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23725  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23726  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23727  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23728  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23729  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23730  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23731  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23732  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23733  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23734  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23735  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23736  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23737  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23738  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23739  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23740  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23741  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23742  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23743  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23744  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23745  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23746  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23747  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23748  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23749  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23750  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23751  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23752  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23753  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23754  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23755  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23756  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23757  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23758  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23759  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23760  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23761  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23762  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23763  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23764  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23765  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23766  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23767  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23768  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23769  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23770  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23771  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23772  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23773  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23774  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23775  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23776  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23777  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23778  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23779  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23780  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23781  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23782  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23783  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23784  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23785  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23786  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23787  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23788  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23789  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23790  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23791  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23792  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23793  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23794  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23795  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23796  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23797  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23798  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23799  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23800  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23801  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23802  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23803  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23804  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23805  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23806  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23807  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23808  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23809  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23810  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23811  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23812  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23813  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23814  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23815  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23816  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23817  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23818  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23819  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23820  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23821  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23822  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23823  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23824  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23825  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23826  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23827  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23828  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23829  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23830  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23831  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23832  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23833  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23834  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23835  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23836  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23837  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23838  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23839  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23840  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23841  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23842  SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23843  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23844  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23845  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23846  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23847  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23848  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23849  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23850  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23851  SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23852  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23853  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23854  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23855  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23856  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23857  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23858  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23859  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23860  SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23861  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23862  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23863  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23864  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23865  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23866  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23867  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23868  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23869  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23870  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23871  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23872  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23873  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23874  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23875  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23876  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23877  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23878  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23879  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23880  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23881  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23882  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23883  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23884  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23885  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23886  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23887  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23888  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23889  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23890  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23891  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23892 #if PY_VERSION_HEX >= 0x03000000
23893  return m;
23894 #else
23895  return;
23896 #endif
23897 }
23898 
#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)