PLplot  5.13.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 4.0.0
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 1
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 #ifndef PyObject_DEL
816 # define PyObject_DEL PyObject_Del
817 #endif
818 
819 // SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
820 // interface files check for it.
821 # define SWIGPY_USE_CAPSULE
822 # define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
823 
824 #if PY_VERSION_HEX < 0x03020000
825 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
826 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
827 #define Py_hash_t long
828 #endif
829 
830 /* -----------------------------------------------------------------------------
831  * error manipulation
832  * ----------------------------------------------------------------------------- */
833 
834 SWIGRUNTIME PyObject*
836  PyObject* type = 0;
837  switch(code) {
838  case SWIG_MemoryError:
839  type = PyExc_MemoryError;
840  break;
841  case SWIG_IOError:
842  type = PyExc_IOError;
843  break;
844  case SWIG_RuntimeError:
845  type = PyExc_RuntimeError;
846  break;
847  case SWIG_IndexError:
848  type = PyExc_IndexError;
849  break;
850  case SWIG_TypeError:
851  type = PyExc_TypeError;
852  break;
853  case SWIG_DivisionByZero:
854  type = PyExc_ZeroDivisionError;
855  break;
856  case SWIG_OverflowError:
857  type = PyExc_OverflowError;
858  break;
859  case SWIG_SyntaxError:
860  type = PyExc_SyntaxError;
861  break;
862  case SWIG_ValueError:
863  type = PyExc_ValueError;
864  break;
865  case SWIG_SystemError:
866  type = PyExc_SystemError;
867  break;
868  case SWIG_AttributeError:
869  type = PyExc_AttributeError;
870  break;
871  default:
872  type = PyExc_RuntimeError;
873  }
874  return type;
875 }
876 
877 
878 SWIGRUNTIME void
879 SWIG_Python_AddErrorMsg(const char* mesg)
880 {
881  PyObject *type = 0;
882  PyObject *value = 0;
883  PyObject *traceback = 0;
884 
885  if (PyErr_Occurred())
886  PyErr_Fetch(&type, &value, &traceback);
887  if (value) {
888  PyObject *old_str = PyObject_Str(value);
889  const char *tmp = SWIG_Python_str_AsChar(old_str);
890  PyErr_Clear();
891  Py_XINCREF(type);
892  if (tmp)
893  PyErr_Format(type, "%s %s", tmp, mesg);
894  else
895  PyErr_Format(type, "%s", mesg);
897  Py_DECREF(old_str);
898  Py_DECREF(value);
899  } else {
900  PyErr_SetString(PyExc_RuntimeError, mesg);
901  }
902 }
903 
904 SWIGRUNTIME int
906 {
907  PyObject *error;
908  if (obj)
909  return 0;
910  error = PyErr_Occurred();
911  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
912 }
913 
914 SWIGRUNTIME void
916 {
917  if (SWIG_Python_TypeErrorOccurred(NULL)) {
918  /* Use existing TypeError to preserve stacktrace and enhance with given message */
919  PyObject *newvalue;
920  PyObject *type = NULL, *value = NULL, *traceback = NULL;
921  PyErr_Fetch(&type, &value, &traceback);
922 #if PY_VERSION_HEX >= 0x03000000
923  newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
924 #else
925  newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
926 #endif
927  Py_XDECREF(value);
928  PyErr_Restore(type, newvalue, traceback);
929  } else {
930  /* Raise TypeError using given message */
931  PyErr_SetString(PyExc_TypeError, message);
932  }
933 }
934 
935 #if defined(SWIG_PYTHON_NO_THREADS)
936 # if defined(SWIG_PYTHON_THREADS)
937 # undef SWIG_PYTHON_THREADS
938 # endif
939 #endif
940 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
941 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
942 # define SWIG_PYTHON_USE_GIL
943 # endif
944 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
945 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
946 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
947 # endif
948 # ifdef __cplusplus /* C++ code */
949  class SWIG_Python_Thread_Block {
950  bool status;
951  PyGILState_STATE state;
952  public:
953  void end() { if (status) { PyGILState_Release(state); status = false;} }
954  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
955  ~SWIG_Python_Thread_Block() { end(); }
956  };
957  class SWIG_Python_Thread_Allow {
958  bool status;
959  PyThreadState *save;
960  public:
961  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
962  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
963  ~SWIG_Python_Thread_Allow() { end(); }
964  };
965 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
966 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
967 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
968 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
969 # else /* C code */
970 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
971 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
972 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
973 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
974 # endif
975 # else /* Old thread way, not implemented, user must provide it */
976 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
977 # define SWIG_PYTHON_INITIALIZE_THREADS
978 # endif
979 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
980 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
981 # endif
982 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
983 # define SWIG_PYTHON_THREAD_END_BLOCK
984 # endif
985 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
986 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
987 # endif
988 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
989 # define SWIG_PYTHON_THREAD_END_ALLOW
990 # endif
991 # endif
992 #else /* No thread support */
993 # define SWIG_PYTHON_INITIALIZE_THREADS
994 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
995 # define SWIG_PYTHON_THREAD_END_BLOCK
996 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
997 # define SWIG_PYTHON_THREAD_END_ALLOW
998 #endif
999 
1000 /* -----------------------------------------------------------------------------
1001  * Python API portion that goes into the runtime
1002  * ----------------------------------------------------------------------------- */
1003 
1004 #ifdef __cplusplus
1005 extern "C" {
1006 #endif
1007 
1008 /* -----------------------------------------------------------------------------
1009  * Constant declarations
1010  * ----------------------------------------------------------------------------- */
1011 
1012 /* Constant Types */
1013 #define SWIG_PY_POINTER 4
1014 #define SWIG_PY_BINARY 5
1015 
1016 /* Constant information structure */
1017 typedef struct swig_const_info {
1018  int type;
1019  const char *name;
1020  long lvalue;
1021  double dvalue;
1022  void *pvalue;
1024 } swig_const_info;
1025 
1026 
1027 /* -----------------------------------------------------------------------------
1028  * Wrapper of PyInstanceMethod_New() used in Python 3
1029  * It is exported to the generated module, used for -fastproxy
1030  * ----------------------------------------------------------------------------- */
1031 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1032 {
1033 #if PY_VERSION_HEX >= 0x03000000
1034  return PyInstanceMethod_New(func);
1035 #else
1036  return PyMethod_New(func, NULL, NULL);
1037 #endif
1038 }
1039 
1040 #ifdef __cplusplus
1041 }
1042 #endif
1043 
1044 
1045 /* -----------------------------------------------------------------------------
1046  * pyrun.swg
1047  *
1048  * This file contains the runtime support for Python modules
1049  * and includes code for managing global variables and pointer
1050  * type checking.
1051  *
1052  * ----------------------------------------------------------------------------- */
1053 
1054 #if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1055 # error "This version of SWIG only supports Python >= 2.7"
1056 #endif
1057 
1058 #if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1059 # error "This version of SWIG only supports Python 3 >= 3.2"
1060 #endif
1061 
1062 /* Common SWIG API */
1063 
1064 /* for raw pointers */
1065 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1066 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1067 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1068 
1069 #ifdef SWIGPYTHON_BUILTIN
1070 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1071 #else
1072 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1073 #endif
1074 
1075 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1076 
1077 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1078 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1079 #define swig_owntype int
1080 
1081 /* for raw packed data */
1082 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1083 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1084 
1085 /* for class or struct pointers */
1086 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1087 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1088 
1089 /* for C or C++ function pointers */
1090 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1091 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1092 
1093 /* for C++ member pointers, ie, member methods */
1094 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1095 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1096 
1097 
1098 /* Runtime API */
1099 
1100 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1101 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1102 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1103 
1104 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1105 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1106 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1107 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1108 #define SWIG_fail goto fail
1109 
1110 
1111 /* Runtime API implementation */
1112 
1113 /* Error manipulation */
1114 
1115 SWIGINTERN void
1116 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1118  PyErr_SetObject(errtype, obj);
1119  Py_DECREF(obj);
1121 }
1122 
1123 SWIGINTERN void
1124 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1126  PyErr_SetString(errtype, msg);
1128 }
1129 
1130 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1131 
1132 /* Set a constant value */
1133 
1134 #if defined(SWIGPYTHON_BUILTIN)
1135 
1136 SWIGINTERN void
1137 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1138  PyObject *s = PyString_InternFromString(key);
1139  PyList_Append(seq, s);
1140  Py_DECREF(s);
1141 }
1142 
1143 SWIGINTERN void
1144 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1145  PyDict_SetItemString(d, name, obj);
1146  Py_DECREF(obj);
1147  if (public_interface)
1148  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1149 }
1150 
1151 #else
1152 
1153 SWIGINTERN void
1154 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1155  PyDict_SetItemString(d, name, obj);
1156  Py_DECREF(obj);
1157 }
1158 
1159 #endif
1160 
1161 /* Append a value to the result obj */
1162 
1163 SWIGINTERN PyObject*
1164 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1165 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1166  if (!result) {
1167  result = obj;
1168  } else if (result == Py_None) {
1169  Py_DECREF(result);
1170  result = obj;
1171  } else {
1172  if (!PyList_Check(result)) {
1173  PyObject *o2 = result;
1174  result = PyList_New(1);
1175  PyList_SetItem(result, 0, o2);
1176  }
1177  PyList_Append(result,obj);
1178  Py_DECREF(obj);
1179  }
1180  return result;
1181 #else
1182  PyObject* o2;
1183  PyObject* o3;
1184  if (!result) {
1185  result = obj;
1186  } else if (result == Py_None) {
1187  Py_DECREF(result);
1188  result = obj;
1189  } else {
1190  if (!PyTuple_Check(result)) {
1191  o2 = result;
1192  result = PyTuple_New(1);
1193  PyTuple_SET_ITEM(result, 0, o2);
1194  }
1195  o3 = PyTuple_New(1);
1196  PyTuple_SET_ITEM(o3, 0, obj);
1197  o2 = result;
1198  result = PySequence_Concat(o2, o3);
1199  Py_DECREF(o2);
1200  Py_DECREF(o3);
1201  }
1202  return result;
1203 #endif
1204 }
1205 
1206 /* Unpack the argument tuple */
1207 
1208 SWIGINTERN Py_ssize_t
1209 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1210 {
1211  if (!args) {
1212  if (!min && !max) {
1213  return 1;
1214  } else {
1215  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1216  name, (min == max ? "" : "at least "), (int)min);
1217  return 0;
1218  }
1219  }
1220  if (!PyTuple_Check(args)) {
1221  if (min <= 1 && max >= 1) {
1222  Py_ssize_t i;
1223  objs[0] = args;
1224  for (i = 1; i < max; ++i) {
1225  objs[i] = 0;
1226  }
1227  return 2;
1228  }
1229  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1230  return 0;
1231  } else {
1232  Py_ssize_t l = PyTuple_GET_SIZE(args);
1233  if (l < min) {
1234  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1235  name, (min == max ? "" : "at least "), (int)min, (int)l);
1236  return 0;
1237  } else if (l > max) {
1238  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1239  name, (min == max ? "" : "at most "), (int)max, (int)l);
1240  return 0;
1241  } else {
1242  Py_ssize_t i;
1243  for (i = 0; i < l; ++i) {
1244  objs[i] = PyTuple_GET_ITEM(args, i);
1245  }
1246  for (; l < max; ++l) {
1247  objs[l] = 0;
1248  }
1249  return i + 1;
1250  }
1251  }
1252 }
1253 
1254 /* A functor is a function object with one single object argument */
1255 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, (char *)"O", obj);
1256 
1257 /*
1258  Helper for static pointer initialization for both C and C++ code, for example
1259  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1260 */
1261 #ifdef __cplusplus
1262 #define SWIG_STATIC_POINTER(var) var
1263 #else
1264 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1265 #endif
1266 
1267 /* -----------------------------------------------------------------------------
1268  * Pointer declarations
1269  * ----------------------------------------------------------------------------- */
1270 
1271 /* Flags for new pointer objects */
1272 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1273 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1274 
1275 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1276 
1277 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1278 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1279 
1280 #ifdef __cplusplus
1281 extern "C" {
1282 #endif
1283 
1284 /* The python void return value */
1285 
1286 SWIGRUNTIMEINLINE PyObject *
1288 {
1289  PyObject *none = Py_None;
1290  Py_INCREF(none);
1291  return none;
1292 }
1293 
1294 /* SwigPyClientData */
1295 
1296 typedef struct {
1297  PyObject *klass;
1298  PyObject *newraw;
1299  PyObject *newargs;
1300  PyObject *destroy;
1301  int delargs;
1303  PyTypeObject *pytype;
1305 
1306 SWIGRUNTIMEINLINE int
1308 {
1310  int fail = data ? data->implicitconv : 0;
1311  if (fail)
1312  PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1313  return fail;
1314 }
1315 
1316 SWIGRUNTIMEINLINE PyObject *
1318  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1319  PyObject *klass = data ? data->klass : 0;
1320  return (klass ? klass : PyExc_RuntimeError);
1321 }
1322 
1323 
1325 SwigPyClientData_New(PyObject* obj)
1326 {
1327  if (!obj) {
1328  return 0;
1329  } else {
1330  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1331  /* the klass element */
1332  data->klass = obj;
1333  Py_INCREF(data->klass);
1334  /* the newraw method and newargs arguments used to create a new raw instance */
1335  if (PyClass_Check(obj)) {
1336  data->newraw = 0;
1337  data->newargs = obj;
1338  Py_INCREF(obj);
1339  } else {
1340  data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1341  if (data->newraw) {
1342  Py_INCREF(data->newraw);
1343  data->newargs = PyTuple_New(1);
1344  PyTuple_SetItem(data->newargs, 0, obj);
1345  } else {
1346  data->newargs = obj;
1347  }
1348  Py_INCREF(data->newargs);
1349  }
1350  /* the destroy method, aka as the C++ delete method */
1351  data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1352  if (PyErr_Occurred()) {
1353  PyErr_Clear();
1354  data->destroy = 0;
1355  }
1356  if (data->destroy) {
1357  int flags;
1358  Py_INCREF(data->destroy);
1359  flags = PyCFunction_GET_FLAGS(data->destroy);
1360  data->delargs = !(flags & (METH_O));
1361  } else {
1362  data->delargs = 0;
1363  }
1364  data->implicitconv = 0;
1365  data->pytype = 0;
1366  return data;
1367  }
1368 }
1369 
1370 SWIGRUNTIME void
1372  Py_XDECREF(data->newraw);
1373  Py_XDECREF(data->newargs);
1374  Py_XDECREF(data->destroy);
1375 }
1376 
1377 /* =============== SwigPyObject =====================*/
1378 
1379 typedef struct {
1380  PyObject_HEAD
1381  void *ptr;
1383  int own;
1384  PyObject *next;
1385 #ifdef SWIGPYTHON_BUILTIN
1386  PyObject *dict;
1387 #endif
1388 } SwigPyObject;
1389 
1390 
1391 #ifdef SWIGPYTHON_BUILTIN
1392 
1393 SWIGRUNTIME PyObject *
1394 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1395 {
1396  SwigPyObject *sobj = (SwigPyObject *)v;
1397 
1398  if (!sobj->dict)
1399  sobj->dict = PyDict_New();
1400 
1401  Py_INCREF(sobj->dict);
1402  return sobj->dict;
1403 }
1404 
1405 #endif
1406 
1407 SWIGRUNTIME PyObject *
1409 {
1410  return PyLong_FromVoidPtr(v->ptr);
1411 }
1412 
1413 SWIGRUNTIME PyObject *
1414 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1415 {
1416  PyObject *res = NULL;
1417  PyObject *args = PyTuple_New(1);
1418  if (args) {
1419  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1420  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1421  if (ofmt) {
1422 #if PY_VERSION_HEX >= 0x03000000
1423  res = PyUnicode_Format(ofmt,args);
1424 #else
1425  res = PyString_Format(ofmt,args);
1426 #endif
1427  Py_DECREF(ofmt);
1428  }
1429  Py_DECREF(args);
1430  }
1431  }
1432  return res;
1433 }
1434 
1435 SWIGRUNTIME PyObject *
1437 {
1438  return SwigPyObject_format("%o",v);
1439 }
1440 
1441 SWIGRUNTIME PyObject *
1443 {
1444  return SwigPyObject_format("%x",v);
1445 }
1446 
1447 SWIGRUNTIME PyObject *
1449 {
1450  const char *name = SWIG_TypePrettyName(v->ty);
1451  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1452  if (v->next) {
1453  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1454 # if PY_VERSION_HEX >= 0x03000000
1455  PyObject *joined = PyUnicode_Concat(repr, nrep);
1456  Py_DecRef(repr);
1457  Py_DecRef(nrep);
1458  repr = joined;
1459 # else
1460  PyString_ConcatAndDel(&repr,nrep);
1461 # endif
1462  }
1463  return repr;
1464 }
1465 
1466 /* We need a version taking two PyObject* parameters so it's a valid
1467  * PyCFunction to use in swigobject_methods[]. */
1468 SWIGRUNTIME PyObject *
1469 SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1470 {
1471  return SwigPyObject_repr((SwigPyObject*)v);
1472 }
1473 
1474 SWIGRUNTIME int
1476 {
1477  void *i = v->ptr;
1478  void *j = w->ptr;
1479  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1480 }
1481 
1482 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1483 SWIGRUNTIME PyObject*
1485 {
1486  PyObject* res;
1487  if( op != Py_EQ && op != Py_NE ) {
1488  Py_INCREF(Py_NotImplemented);
1489  return Py_NotImplemented;
1490  }
1491  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1492  return res;
1493 }
1494 
1495 
1496 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1497 
1498 #ifdef SWIGPYTHON_BUILTIN
1499 static swig_type_info *SwigPyObject_stype = 0;
1500 SWIGRUNTIME PyTypeObject*
1501 SwigPyObject_type(void) {
1502  SwigPyClientData *cd;
1503  assert(SwigPyObject_stype);
1504  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1505  assert(cd);
1506  assert(cd->pytype);
1507  return cd->pytype;
1508 }
1509 #else
1510 SWIGRUNTIME PyTypeObject*
1512  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1513  return type;
1514 }
1515 #endif
1516 
1518 SwigPyObject_Check(PyObject *op) {
1519 #ifdef SWIGPYTHON_BUILTIN
1520  PyTypeObject *target_tp = SwigPyObject_type();
1521  if (PyType_IsSubtype(op->ob_type, target_tp))
1522  return 1;
1523  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1524 #else
1525  return (Py_TYPE(op) == SwigPyObject_type())
1526  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1527 #endif
1528 }
1529 
1530 SWIGRUNTIME PyObject *
1531 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1532 
1533 SWIGRUNTIME void
1535 {
1536  SwigPyObject *sobj = (SwigPyObject *) v;
1537  PyObject *next = sobj->next;
1538  if (sobj->own == SWIG_POINTER_OWN) {
1539  swig_type_info *ty = sobj->ty;
1540  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1541  PyObject *destroy = data ? data->destroy : 0;
1542  if (destroy) {
1543  /* destroy is always a VARARGS method */
1544  PyObject *res;
1545 
1546  /* PyObject_CallFunction() has the potential to silently drop
1547  the active exception. In cases of unnamed temporary
1548  variable or where we just finished iterating over a generator
1549  StopIteration will be active right now, and this needs to
1550  remain true upon return from SwigPyObject_dealloc. So save
1551  and restore. */
1552 
1553  PyObject *type = NULL, *value = NULL, *traceback = NULL;
1554  PyErr_Fetch(&type, &value, &traceback);
1555 
1556  if (data->delargs) {
1557  /* we need to create a temporary object to carry the destroy operation */
1558  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1559  res = SWIG_Python_CallFunctor(destroy, tmp);
1560  Py_DECREF(tmp);
1561  } else {
1562  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1563  PyObject *mself = PyCFunction_GET_SELF(destroy);
1564  res = ((*meth)(mself, v));
1565  }
1566  if (!res)
1567  PyErr_WriteUnraisable(destroy);
1568 
1569  PyErr_Restore(type, value, traceback);
1570 
1571  Py_XDECREF(res);
1572  }
1573 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1574  else {
1575  const char *name = SWIG_TypePrettyName(ty);
1576  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1577  }
1578 #endif
1579  }
1580  Py_XDECREF(next);
1581  PyObject_DEL(v);
1582 }
1583 
1584 SWIGRUNTIME PyObject*
1585 SwigPyObject_append(PyObject* v, PyObject* next)
1586 {
1587  SwigPyObject *sobj = (SwigPyObject *) v;
1588  if (!SwigPyObject_Check(next)) {
1589  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1590  return NULL;
1591  }
1592  sobj->next = next;
1593  Py_INCREF(next);
1594  return SWIG_Py_Void();
1595 }
1596 
1597 SWIGRUNTIME PyObject*
1598 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1599 {
1600  SwigPyObject *sobj = (SwigPyObject *) v;
1601  if (sobj->next) {
1602  Py_INCREF(sobj->next);
1603  return sobj->next;
1604  } else {
1605  return SWIG_Py_Void();
1606  }
1607 }
1608 
1609 SWIGINTERN PyObject*
1610 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1611 {
1612  SwigPyObject *sobj = (SwigPyObject *)v;
1613  sobj->own = 0;
1614  return SWIG_Py_Void();
1615 }
1616 
1617 SWIGINTERN PyObject*
1618 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1619 {
1620  SwigPyObject *sobj = (SwigPyObject *)v;
1621  sobj->own = SWIG_POINTER_OWN;
1622  return SWIG_Py_Void();
1623 }
1624 
1625 SWIGINTERN PyObject*
1626 SwigPyObject_own(PyObject *v, PyObject *args)
1627 {
1628  PyObject *val = 0;
1629  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1630  return NULL;
1631  } else {
1632  SwigPyObject *sobj = (SwigPyObject *)v;
1633  PyObject *obj = PyBool_FromLong(sobj->own);
1634  if (val) {
1635  if (PyObject_IsTrue(val)) {
1636  SwigPyObject_acquire(v,args);
1637  } else {
1638  SwigPyObject_disown(v,args);
1639  }
1640  }
1641  return obj;
1642  }
1643 }
1644 
1645 static PyMethodDef
1647  {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1648  {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1649  {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1650  {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1651  {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1652  {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1653  {0, 0, 0, 0}
1654 };
1655 
1656 SWIGRUNTIME PyTypeObject*
1658  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1659 
1660  static PyNumberMethods SwigPyObject_as_number = {
1661  (binaryfunc)0, /*nb_add*/
1662  (binaryfunc)0, /*nb_subtract*/
1663  (binaryfunc)0, /*nb_multiply*/
1664  /* nb_divide removed in Python 3 */
1665 #if PY_VERSION_HEX < 0x03000000
1666  (binaryfunc)0, /*nb_divide*/
1667 #endif
1668  (binaryfunc)0, /*nb_remainder*/
1669  (binaryfunc)0, /*nb_divmod*/
1670  (ternaryfunc)0,/*nb_power*/
1671  (unaryfunc)0, /*nb_negative*/
1672  (unaryfunc)0, /*nb_positive*/
1673  (unaryfunc)0, /*nb_absolute*/
1674  (inquiry)0, /*nb_nonzero*/
1675  0, /*nb_invert*/
1676  0, /*nb_lshift*/
1677  0, /*nb_rshift*/
1678  0, /*nb_and*/
1679  0, /*nb_xor*/
1680  0, /*nb_or*/
1681 #if PY_VERSION_HEX < 0x03000000
1682  0, /*nb_coerce*/
1683 #endif
1684  (unaryfunc)SwigPyObject_long, /*nb_int*/
1685 #if PY_VERSION_HEX < 0x03000000
1686  (unaryfunc)SwigPyObject_long, /*nb_long*/
1687 #else
1688  0, /*nb_reserved*/
1689 #endif
1690  (unaryfunc)0, /*nb_float*/
1691 #if PY_VERSION_HEX < 0x03000000
1692  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1693  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1694 #endif
1695 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1696  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1697 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1698  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1699 #else
1700  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1701 #endif
1702  };
1703 
1704  static PyTypeObject swigpyobject_type;
1705  static int type_init = 0;
1706  if (!type_init) {
1707  const PyTypeObject tmp = {
1708 #if PY_VERSION_HEX >= 0x03000000
1709  PyVarObject_HEAD_INIT(NULL, 0)
1710 #else
1711  PyObject_HEAD_INIT(NULL)
1712  0, /* ob_size */
1713 #endif
1714  "SwigPyObject", /* tp_name */
1715  sizeof(SwigPyObject), /* tp_basicsize */
1716  0, /* tp_itemsize */
1717  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1718  0, /* tp_print */
1719  (getattrfunc)0, /* tp_getattr */
1720  (setattrfunc)0, /* tp_setattr */
1721 #if PY_VERSION_HEX >= 0x03000000
1722  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1723 #else
1724  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1725 #endif
1726  (reprfunc)SwigPyObject_repr, /* tp_repr */
1727  &SwigPyObject_as_number, /* tp_as_number */
1728  0, /* tp_as_sequence */
1729  0, /* tp_as_mapping */
1730  (hashfunc)0, /* tp_hash */
1731  (ternaryfunc)0, /* tp_call */
1732  0, /* tp_str */
1733  PyObject_GenericGetAttr, /* tp_getattro */
1734  0, /* tp_setattro */
1735  0, /* tp_as_buffer */
1736  Py_TPFLAGS_DEFAULT, /* tp_flags */
1737  swigobject_doc, /* tp_doc */
1738  0, /* tp_traverse */
1739  0, /* tp_clear */
1740  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1741  0, /* tp_weaklistoffset */
1742  0, /* tp_iter */
1743  0, /* tp_iternext */
1744  swigobject_methods, /* tp_methods */
1745  0, /* tp_members */
1746  0, /* tp_getset */
1747  0, /* tp_base */
1748  0, /* tp_dict */
1749  0, /* tp_descr_get */
1750  0, /* tp_descr_set */
1751  0, /* tp_dictoffset */
1752  0, /* tp_init */
1753  0, /* tp_alloc */
1754  0, /* tp_new */
1755  0, /* tp_free */
1756  0, /* tp_is_gc */
1757  0, /* tp_bases */
1758  0, /* tp_mro */
1759  0, /* tp_cache */
1760  0, /* tp_subclasses */
1761  0, /* tp_weaklist */
1762  0, /* tp_del */
1763  0, /* tp_version_tag */
1764 #if PY_VERSION_HEX >= 0x03040000
1765  0, /* tp_finalize */
1766 #endif
1767 #ifdef COUNT_ALLOCS
1768  0, /* tp_allocs */
1769  0, /* tp_frees */
1770  0, /* tp_maxalloc */
1771  0, /* tp_prev */
1772  0 /* tp_next */
1773 #endif
1774  };
1775  swigpyobject_type = tmp;
1776  type_init = 1;
1777  if (PyType_Ready(&swigpyobject_type) < 0)
1778  return NULL;
1779  }
1780  return &swigpyobject_type;
1781 }
1782 
1783 SWIGRUNTIME PyObject *
1784 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1785 {
1786  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1787  if (sobj) {
1788  sobj->ptr = ptr;
1789  sobj->ty = ty;
1790  sobj->own = own;
1791  sobj->next = 0;
1792  }
1793  return (PyObject *)sobj;
1794 }
1795 
1796 /* -----------------------------------------------------------------------------
1797  * Implements a simple Swig Packed type, and use it instead of string
1798  * ----------------------------------------------------------------------------- */
1799 
1800 typedef struct {
1801  PyObject_HEAD
1802  void *pack;
1804  size_t size;
1805 } SwigPyPacked;
1806 
1807 SWIGRUNTIME int
1809 {
1810  char result[SWIG_BUFFER_SIZE];
1811  fputs("<Swig Packed ", fp);
1812  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1813  fputs("at ", fp);
1814  fputs(result, fp);
1815  }
1816  fputs(v->ty->name,fp);
1817  fputs(">", fp);
1818  return 0;
1819 }
1820 
1821 SWIGRUNTIME PyObject *
1823 {
1824  char result[SWIG_BUFFER_SIZE];
1825  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1826  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1827  } else {
1828  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1829  }
1830 }
1831 
1832 SWIGRUNTIME PyObject *
1834 {
1835  char result[SWIG_BUFFER_SIZE];
1836  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1837  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1838  } else {
1839  return SWIG_Python_str_FromChar(v->ty->name);
1840  }
1841 }
1842 
1843 SWIGRUNTIME int
1845 {
1846  size_t i = v->size;
1847  size_t j = w->size;
1848  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1849  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1850 }
1851 
1852 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1853 
1854 SWIGRUNTIME PyTypeObject*
1856  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1857  return type;
1858 }
1859 
1861 SwigPyPacked_Check(PyObject *op) {
1862  return ((op)->ob_type == SwigPyPacked_TypeOnce())
1863  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1864 }
1865 
1866 SWIGRUNTIME void
1868 {
1869  if (SwigPyPacked_Check(v)) {
1870  SwigPyPacked *sobj = (SwigPyPacked *) v;
1871  free(sobj->pack);
1872  }
1873  PyObject_DEL(v);
1874 }
1875 
1876 SWIGRUNTIME PyTypeObject*
1878  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1879  static PyTypeObject swigpypacked_type;
1880  static int type_init = 0;
1881  if (!type_init) {
1882  const PyTypeObject tmp = {
1883 #if PY_VERSION_HEX>=0x03000000
1884  PyVarObject_HEAD_INIT(NULL, 0)
1885 #else
1886  PyObject_HEAD_INIT(NULL)
1887  0, /* ob_size */
1888 #endif
1889  "SwigPyPacked", /* tp_name */
1890  sizeof(SwigPyPacked), /* tp_basicsize */
1891  0, /* tp_itemsize */
1892  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1893  (printfunc)SwigPyPacked_print, /* tp_print */
1894  (getattrfunc)0, /* tp_getattr */
1895  (setattrfunc)0, /* tp_setattr */
1896 #if PY_VERSION_HEX>=0x03000000
1897  0, /* tp_reserved in 3.0.1 */
1898 #else
1899  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1900 #endif
1901  (reprfunc)SwigPyPacked_repr, /* tp_repr */
1902  0, /* tp_as_number */
1903  0, /* tp_as_sequence */
1904  0, /* tp_as_mapping */
1905  (hashfunc)0, /* tp_hash */
1906  (ternaryfunc)0, /* tp_call */
1907  (reprfunc)SwigPyPacked_str, /* tp_str */
1908  PyObject_GenericGetAttr, /* tp_getattro */
1909  0, /* tp_setattro */
1910  0, /* tp_as_buffer */
1911  Py_TPFLAGS_DEFAULT, /* tp_flags */
1912  swigpacked_doc, /* tp_doc */
1913  0, /* tp_traverse */
1914  0, /* tp_clear */
1915  0, /* tp_richcompare */
1916  0, /* tp_weaklistoffset */
1917  0, /* tp_iter */
1918  0, /* tp_iternext */
1919  0, /* tp_methods */
1920  0, /* tp_members */
1921  0, /* tp_getset */
1922  0, /* tp_base */
1923  0, /* tp_dict */
1924  0, /* tp_descr_get */
1925  0, /* tp_descr_set */
1926  0, /* tp_dictoffset */
1927  0, /* tp_init */
1928  0, /* tp_alloc */
1929  0, /* tp_new */
1930  0, /* tp_free */
1931  0, /* tp_is_gc */
1932  0, /* tp_bases */
1933  0, /* tp_mro */
1934  0, /* tp_cache */
1935  0, /* tp_subclasses */
1936  0, /* tp_weaklist */
1937  0, /* tp_del */
1938  0, /* tp_version_tag */
1939 #if PY_VERSION_HEX >= 0x03040000
1940  0, /* tp_finalize */
1941 #endif
1942 #ifdef COUNT_ALLOCS
1943  0, /* tp_allocs */
1944  0, /* tp_frees */
1945  0, /* tp_maxalloc */
1946  0, /* tp_prev */
1947  0 /* tp_next */
1948 #endif
1949  };
1950  swigpypacked_type = tmp;
1951  type_init = 1;
1952  if (PyType_Ready(&swigpypacked_type) < 0)
1953  return NULL;
1954  }
1955  return &swigpypacked_type;
1956 }
1957 
1958 SWIGRUNTIME PyObject *
1959 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1960 {
1961  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1962  if (sobj) {
1963  void *pack = malloc(size);
1964  if (pack) {
1965  memcpy(pack, ptr, size);
1966  sobj->pack = pack;
1967  sobj->ty = ty;
1968  sobj->size = size;
1969  } else {
1970  PyObject_DEL((PyObject *) sobj);
1971  sobj = 0;
1972  }
1973  }
1974  return (PyObject *) sobj;
1975 }
1976 
1978 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1979 {
1980  if (SwigPyPacked_Check(obj)) {
1981  SwigPyPacked *sobj = (SwigPyPacked *)obj;
1982  if (sobj->size != size) return 0;
1983  memcpy(ptr, sobj->pack, size);
1984  return sobj->ty;
1985  } else {
1986  return 0;
1987  }
1988 }
1989 
1990 /* -----------------------------------------------------------------------------
1991  * pointers/data manipulation
1992  * ----------------------------------------------------------------------------- */
1993 
1994 static PyObject *Swig_This_global = NULL;
1995 
1996 SWIGRUNTIME PyObject *
1998 {
1999  if (Swig_This_global == NULL)
2001  return Swig_This_global;
2002 }
2003 
2004 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2005 
2006 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2007 #if PY_VERSION_HEX>=0x03000000
2008 #define SWIG_PYTHON_SLOW_GETSET_THIS
2009 #endif
2010 
2012 SWIG_Python_GetSwigThis(PyObject *pyobj)
2013 {
2014  PyObject *obj;
2015 
2016  if (SwigPyObject_Check(pyobj))
2017  return (SwigPyObject *) pyobj;
2018 
2019 #ifdef SWIGPYTHON_BUILTIN
2020  (void)obj;
2021 # ifdef PyWeakref_CheckProxy
2022  if (PyWeakref_CheckProxy(pyobj)) {
2023  pyobj = PyWeakref_GET_OBJECT(pyobj);
2024  if (pyobj && SwigPyObject_Check(pyobj))
2025  return (SwigPyObject*) pyobj;
2026  }
2027 # endif
2028  return NULL;
2029 #else
2030 
2031  obj = 0;
2032 
2033 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2034  if (PyInstance_Check(pyobj)) {
2035  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2036  } else {
2037  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2038  if (dictptr != NULL) {
2039  PyObject *dict = *dictptr;
2040  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2041  } else {
2042 #ifdef PyWeakref_CheckProxy
2043  if (PyWeakref_CheckProxy(pyobj)) {
2044  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2045  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2046  }
2047 #endif
2048  obj = PyObject_GetAttr(pyobj,SWIG_This());
2049  if (obj) {
2050  Py_DECREF(obj);
2051  } else {
2052  if (PyErr_Occurred()) PyErr_Clear();
2053  return 0;
2054  }
2055  }
2056  }
2057 #else
2058  obj = PyObject_GetAttr(pyobj,SWIG_This());
2059  if (obj) {
2060  Py_DECREF(obj);
2061  } else {
2062  if (PyErr_Occurred()) PyErr_Clear();
2063  return 0;
2064  }
2065 #endif
2066  if (obj && !SwigPyObject_Check(obj)) {
2067  /* a PyObject is called 'this', try to get the 'real this'
2068  SwigPyObject from it */
2069  return SWIG_Python_GetSwigThis(obj);
2070  }
2071  return (SwigPyObject *)obj;
2072 #endif
2073 }
2074 
2075 /* Acquire a pointer value */
2076 
2077 SWIGRUNTIME int
2078 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2079  if (own == SWIG_POINTER_OWN) {
2081  if (sobj) {
2082  int oldown = sobj->own;
2083  sobj->own = own;
2084  return oldown;
2085  }
2086  }
2087  return 0;
2088 }
2089 
2090 /* Convert a pointer value */
2091 
2092 SWIGRUNTIME int
2093 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2094  int res;
2095  SwigPyObject *sobj;
2096  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2097 
2098  if (!obj)
2099  return SWIG_ERROR;
2100  if (obj == Py_None && !implicit_conv) {
2101  if (ptr)
2102  *ptr = 0;
2103  return SWIG_OK;
2104  }
2105 
2106  res = SWIG_ERROR;
2107 
2108  sobj = SWIG_Python_GetSwigThis(obj);
2109  if (own)
2110  *own = 0;
2111  while (sobj) {
2112  void *vptr = sobj->ptr;
2113  if (ty) {
2114  swig_type_info *to = sobj->ty;
2115  if (to == ty) {
2116  /* no type cast needed */
2117  if (ptr) *ptr = vptr;
2118  break;
2119  } else {
2120  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2121  if (!tc) {
2122  sobj = (SwigPyObject *)sobj->next;
2123  } else {
2124  if (ptr) {
2125  int newmemory = 0;
2126  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2127  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2128  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2129  if (own)
2130  *own = *own | SWIG_CAST_NEW_MEMORY;
2131  }
2132  }
2133  break;
2134  }
2135  }
2136  } else {
2137  if (ptr) *ptr = vptr;
2138  break;
2139  }
2140  }
2141  if (sobj) {
2142  if (own)
2143  *own = *own | sobj->own;
2144  if (flags & SWIG_POINTER_DISOWN) {
2145  sobj->own = 0;
2146  }
2147  res = SWIG_OK;
2148  } else {
2149  if (implicit_conv) {
2150  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2151  if (data && !data->implicitconv) {
2152  PyObject *klass = data->klass;
2153  if (klass) {
2154  PyObject *impconv;
2155  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2156  impconv = SWIG_Python_CallFunctor(klass, obj);
2157  data->implicitconv = 0;
2158  if (PyErr_Occurred()) {
2159  PyErr_Clear();
2160  impconv = 0;
2161  }
2162  if (impconv) {
2163  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2164  if (iobj) {
2165  void *vptr;
2166  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2167  if (SWIG_IsOK(res)) {
2168  if (ptr) {
2169  *ptr = vptr;
2170  /* transfer the ownership to 'ptr' */
2171  iobj->own = 0;
2172  res = SWIG_AddCast(res);
2173  res = SWIG_AddNewMask(res);
2174  } else {
2175  res = SWIG_AddCast(res);
2176  }
2177  }
2178  }
2179  Py_DECREF(impconv);
2180  }
2181  }
2182  }
2183  }
2184  if (!SWIG_IsOK(res) && obj == Py_None) {
2185  if (ptr)
2186  *ptr = 0;
2187  if (PyErr_Occurred())
2188  PyErr_Clear();
2189  res = SWIG_OK;
2190  }
2191  }
2192  return res;
2193 }
2194 
2195 /* Convert a function ptr value */
2196 
2197 SWIGRUNTIME int
2198 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2199  if (!PyCFunction_Check(obj)) {
2200  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2201  } else {
2202  void *vptr = 0;
2203  swig_cast_info *tc;
2204 
2205  /* here we get the method pointer for callbacks */
2206  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2207  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2208  if (desc)
2209  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2210  if (!desc)
2211  return SWIG_ERROR;
2212  tc = SWIG_TypeCheck(desc,ty);
2213  if (tc) {
2214  int newmemory = 0;
2215  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2216  assert(!newmemory); /* newmemory handling not yet implemented */
2217  } else {
2218  return SWIG_ERROR;
2219  }
2220  return SWIG_OK;
2221  }
2222 }
2223 
2224 /* Convert a packed pointer value */
2225 
2226 SWIGRUNTIME int
2227 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2228  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2229  if (!to) return SWIG_ERROR;
2230  if (ty) {
2231  if (to != ty) {
2232  /* check type cast? */
2233  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2234  if (!tc) return SWIG_ERROR;
2235  }
2236  }
2237  return SWIG_OK;
2238 }
2239 
2240 /* -----------------------------------------------------------------------------
2241  * Create a new pointer object
2242  * ----------------------------------------------------------------------------- */
2243 
2244 /*
2245  Create a new instance object, without calling __init__, and set the
2246  'this' attribute.
2247 */
2248 
2249 SWIGRUNTIME PyObject*
2251 {
2252  PyObject *inst = 0;
2253  PyObject *newraw = data->newraw;
2254  if (newraw) {
2255  inst = PyObject_Call(newraw, data->newargs, NULL);
2256  if (inst) {
2257 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2258  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2259  if (dictptr != NULL) {
2260  PyObject *dict = *dictptr;
2261  if (dict == NULL) {
2262  dict = PyDict_New();
2263  *dictptr = dict;
2264  PyDict_SetItem(dict, SWIG_This(), swig_this);
2265  }
2266  }
2267 #else
2268  PyObject *key = SWIG_This();
2269  PyObject_SetAttr(inst, key, swig_this);
2270 #endif
2271  }
2272  } else {
2273 #if PY_VERSION_HEX >= 0x03000000
2274  PyObject *empty_args = PyTuple_New(0);
2275  if (empty_args) {
2276  inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, Py_None);
2277  Py_DECREF(empty_args);
2278  if (inst) {
2279  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2280  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2281  }
2282  }
2283 #else
2284  PyObject *dict = PyDict_New();
2285  if (dict) {
2286  PyDict_SetItem(dict, SWIG_This(), swig_this);
2287  inst = PyInstance_NewRaw(data->newargs, dict);
2288  Py_DECREF(dict);
2289  }
2290 #endif
2291  }
2292  return inst;
2293 }
2294 
2295 SWIGRUNTIME void
2296 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2297 {
2298  PyObject *dict;
2299 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2300  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2301  if (dictptr != NULL) {
2302  dict = *dictptr;
2303  if (dict == NULL) {
2304  dict = PyDict_New();
2305  *dictptr = dict;
2306  }
2307  PyDict_SetItem(dict, SWIG_This(), swig_this);
2308  return;
2309  }
2310 #endif
2311  dict = PyObject_GetAttrString(inst, "__dict__");
2312  PyDict_SetItem(dict, SWIG_This(), swig_this);
2313  Py_DECREF(dict);
2314 }
2315 
2316 
2317 SWIGINTERN PyObject *
2319  PyObject *obj[2];
2320  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2321  return NULL;
2322  } else {
2323  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2324  if (sthis) {
2325  SwigPyObject_append((PyObject*) sthis, obj[1]);
2326  } else {
2327  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2328  }
2329  return SWIG_Py_Void();
2330  }
2331 }
2332 
2333 /* Create a new pointer object */
2334 
2335 SWIGRUNTIME PyObject *
2336 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2337  SwigPyClientData *clientdata;
2338  PyObject * robj;
2339  int own;
2340 
2341  if (!ptr)
2342  return SWIG_Py_Void();
2343 
2344  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2345  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2346  if (clientdata && clientdata->pytype) {
2347  SwigPyObject *newobj;
2348  if (flags & SWIG_BUILTIN_TP_INIT) {
2349  newobj = (SwigPyObject*) self;
2350  if (newobj->ptr) {
2351  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2352  while (newobj->next)
2353  newobj = (SwigPyObject *) newobj->next;
2354  newobj->next = next_self;
2355  newobj = (SwigPyObject *)next_self;
2356 #ifdef SWIGPYTHON_BUILTIN
2357  newobj->dict = 0;
2358 #endif
2359  }
2360  } else {
2361  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2362 #ifdef SWIGPYTHON_BUILTIN
2363  newobj->dict = 0;
2364 #endif
2365  }
2366  if (newobj) {
2367  newobj->ptr = ptr;
2368  newobj->ty = type;
2369  newobj->own = own;
2370  newobj->next = 0;
2371  return (PyObject*) newobj;
2372  }
2373  return SWIG_Py_Void();
2374  }
2375 
2376  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2377 
2378  robj = SwigPyObject_New(ptr, type, own);
2379  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2380  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2381  Py_DECREF(robj);
2382  robj = inst;
2383  }
2384  return robj;
2385 }
2386 
2387 /* Create a new packed object */
2388 
2389 SWIGRUNTIMEINLINE PyObject *
2390 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2391  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2392 }
2393 
2394 /* -----------------------------------------------------------------------------*
2395  * Get type list
2396  * -----------------------------------------------------------------------------*/
2397 
2398 #ifdef SWIG_LINK_RUNTIME
2399 void *SWIG_ReturnGlobalTypeList(void *);
2400 #endif
2401 
2404  static void *type_pointer = (void *)0;
2405  /* first check if module already created */
2406  if (!type_pointer) {
2407 #ifdef SWIG_LINK_RUNTIME
2408  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2409 #else
2410  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2411  if (PyErr_Occurred()) {
2412  PyErr_Clear();
2413  type_pointer = (void *)0;
2414  }
2415 #endif
2416  }
2417  return (swig_module_info *) type_pointer;
2418 }
2419 
2420 SWIGRUNTIME void
2422 {
2423  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2424  swig_type_info **types = swig_module->types;
2425  size_t i;
2426  for (i =0; i < swig_module->size; ++i) {
2427  swig_type_info *ty = types[i];
2428  if (ty->owndata) {
2430  if (data) SwigPyClientData_Del(data);
2431  }
2432  }
2433  Py_DECREF(SWIG_This());
2434  Swig_This_global = NULL;
2435 }
2436 
2437 SWIGRUNTIME void
2439 #if PY_VERSION_HEX >= 0x03000000
2440  /* Add a dummy module object into sys.modules */
2441  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2442 #else
2443  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2444  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2445 #endif
2446  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2447  if (pointer && module) {
2448  PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2449  } else {
2450  Py_XDECREF(pointer);
2451  }
2452 }
2453 
2454 /* The python cached type query */
2455 SWIGRUNTIME PyObject *
2457  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2458  return cache;
2459 }
2460 
2462 SWIG_Python_TypeQuery(const char *type)
2463 {
2464  PyObject *cache = SWIG_Python_TypeCache();
2465  PyObject *key = SWIG_Python_str_FromChar(type);
2466  PyObject *obj = PyDict_GetItem(cache, key);
2467  swig_type_info *descriptor;
2468  if (obj) {
2469  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2470  } else {
2472  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2473  if (descriptor) {
2474  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2475  PyDict_SetItem(cache, key, obj);
2476  Py_DECREF(obj);
2477  }
2478  }
2479  Py_DECREF(key);
2480  return descriptor;
2481 }
2482 
2483 /*
2484  For backward compatibility only
2485 */
2486 #define SWIG_POINTER_EXCEPTION 0
2487 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2488 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2489 
2490 SWIGRUNTIME int
2491 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2492 {
2493  if (PyErr_Occurred()) {
2494  PyObject *type = 0;
2495  PyObject *value = 0;
2496  PyObject *traceback = 0;
2497  PyErr_Fetch(&type, &value, &traceback);
2498  if (value) {
2499  PyObject *old_str = PyObject_Str(value);
2500  const char *tmp = SWIG_Python_str_AsChar(old_str);
2501  const char *errmesg = tmp ? tmp : "Invalid error message";
2502  Py_XINCREF(type);
2503  PyErr_Clear();
2504  if (infront) {
2505  PyErr_Format(type, "%s %s", mesg, errmesg);
2506  } else {
2507  PyErr_Format(type, "%s %s", errmesg, mesg);
2508  }
2510  Py_DECREF(old_str);
2511  }
2512  return 1;
2513  } else {
2514  return 0;
2515  }
2516 }
2517 
2518 SWIGRUNTIME int
2520 {
2521  if (PyErr_Occurred()) {
2522  /* add information about failing argument */
2523  char mesg[256];
2524  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2525  return SWIG_Python_AddErrMesg(mesg, 1);
2526  } else {
2527  return 0;
2528  }
2529 }
2530 
2531 SWIGRUNTIMEINLINE const char *
2532 SwigPyObject_GetDesc(PyObject *self)
2533 {
2534  SwigPyObject *v = (SwigPyObject *)self;
2535  swig_type_info *ty = v ? v->ty : 0;
2536  return ty ? ty->str : "";
2537 }
2538 
2539 SWIGRUNTIME void
2540 SWIG_Python_TypeError(const char *type, PyObject *obj)
2541 {
2542  if (type) {
2543 #if defined(SWIG_COBJECT_TYPES)
2544  if (obj && SwigPyObject_Check(obj)) {
2545  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2546  if (otype) {
2547  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2548  type, otype);
2549  return;
2550  }
2551  } else
2552 #endif
2553  {
2554  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2555  if (otype) {
2556  PyObject *str = PyObject_Str(obj);
2557  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2558  if (cstr) {
2559  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2560  type, otype, cstr);
2562  } else {
2563  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2564  type, otype);
2565  }
2566  Py_XDECREF(str);
2567  return;
2568  }
2569  }
2570  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2571  } else {
2572  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2573  }
2574 }
2575 
2576 
2577 /* Convert a pointer value, signal an exception on a type mismatch */
2578 SWIGRUNTIME void *
2579 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2580  void *result;
2581  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2582  PyErr_Clear();
2583 #if SWIG_POINTER_EXCEPTION
2584  if (flags) {
2586  SWIG_Python_ArgFail(argnum);
2587  }
2588 #endif
2589  }
2590  return result;
2591 }
2592 
2593 #ifdef SWIGPYTHON_BUILTIN
2594 SWIGRUNTIME int
2595 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2596  PyTypeObject *tp = obj->ob_type;
2597  PyObject *descr;
2598  PyObject *encoded_name;
2599  descrsetfunc f;
2600  int res = -1;
2601 
2602 # ifdef Py_USING_UNICODE
2603  if (PyString_Check(name)) {
2604  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2605  if (!name)
2606  return -1;
2607  } else if (!PyUnicode_Check(name))
2608 # else
2609  if (!PyString_Check(name))
2610 # endif
2611  {
2612  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2613  return -1;
2614  } else {
2615  Py_INCREF(name);
2616  }
2617 
2618  if (!tp->tp_dict) {
2619  if (PyType_Ready(tp) < 0)
2620  goto done;
2621  }
2622 
2623  descr = _PyType_Lookup(tp, name);
2624  f = NULL;
2625  if (descr != NULL)
2626  f = descr->ob_type->tp_descr_set;
2627  if (!f) {
2628  if (PyString_Check(name)) {
2629  encoded_name = name;
2630  Py_INCREF(name);
2631  } else {
2632  encoded_name = PyUnicode_AsUTF8String(name);
2633  if (!encoded_name)
2634  return -1;
2635  }
2636  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2637  Py_DECREF(encoded_name);
2638  } else {
2639  res = f(descr, obj, value);
2640  }
2641 
2642  done:
2643  Py_DECREF(name);
2644  return res;
2645 }
2646 #endif
2647 
2648 
2649 #ifdef __cplusplus
2650 }
2651 #endif
2652 
2653 
2654 
2655 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2656 
2657 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2658 
2659 
2660 
2661 /* -------- TYPES TABLE (BEGIN) -------- */
2662 
2663 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2664 #define SWIGTYPE_p_PLcGrid swig_types[1]
2665 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2666 #define SWIGTYPE_p_char swig_types[3]
2667 #define SWIGTYPE_p_double swig_types[4]
2668 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2669 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2670 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2671 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2672 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2673 #define SWIGTYPE_p_int swig_types[10]
2674 #define SWIGTYPE_p_p_char swig_types[11]
2675 #define SWIGTYPE_p_p_double swig_types[12]
2676 #define SWIGTYPE_p_unsigned_int swig_types[13]
2678 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2679 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2680 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2681 
2682 /* -------- TYPES TABLE (END) -------- */
2683 
2684 #ifdef SWIG_TypeQuery
2685 # undef SWIG_TypeQuery
2686 #endif
2687 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2688 
2689 /*-----------------------------------------------
2690  @(target):= _plplotc.so
2691  ------------------------------------------------*/
2692 #if PY_VERSION_HEX >= 0x03000000
2693 # define SWIG_init PyInit__plplotc
2694 
2695 #else
2696 # define SWIG_init init_plplotc
2697 
2698 #endif
2699 #define SWIG_name "_plplotc"
2700 
2701 #define SWIGVERSION 0x040000
2702 #define SWIG_VERSION SWIGVERSION
2703 
2704 
2705 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2706 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2707 
2708 
2709 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2710 #include <arrayobject.h>
2711 #include "plplot.h"
2712 #include "plplotP.h"
2713 
2714 #define NPY_PLINT NPY_INT32
2715 
2716 #ifdef PL_DOUBLE
2717 #define NPY_PLFLT NPY_FLOAT64
2718 #else
2719 #define NPY_PLFLT NPY_FLOAT32
2720 #endif
2721 
2722 // python-1.5 compatibility mode?
2723 #if !defined ( PySequence_Fast_GET_ITEM )
2724  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2725 #endif
2726 #define PySequence_Size PySequence_Length
2727 
2728 
2729  static PLINT Alen = 0;
2730  static PLINT Xlen = 0, Ylen = 0;
2731 
2732 
2733 SWIGINTERN int
2734 SWIG_AsVal_double (PyObject *obj, double *val)
2735 {
2736  int res = SWIG_TypeError;
2737  if (PyFloat_Check(obj)) {
2738  if (val) *val = PyFloat_AsDouble(obj);
2739  return SWIG_OK;
2740 #if PY_VERSION_HEX < 0x03000000
2741  } else if (PyInt_Check(obj)) {
2742  if (val) *val = (double) PyInt_AsLong(obj);
2743  return SWIG_OK;
2744 #endif
2745  } else if (PyLong_Check(obj)) {
2746  double v = PyLong_AsDouble(obj);
2747  if (!PyErr_Occurred()) {
2748  if (val) *val = v;
2749  return SWIG_OK;
2750  } else {
2751  PyErr_Clear();
2752  }
2753  }
2754 #ifdef SWIG_PYTHON_CAST_MODE
2755  {
2756  int dispatch = 0;
2757  double d = PyFloat_AsDouble(obj);
2758  if (!PyErr_Occurred()) {
2759  if (val) *val = d;
2760  return SWIG_AddCast(SWIG_OK);
2761  } else {
2762  PyErr_Clear();
2763  }
2764  if (!dispatch) {
2765  long v = PyLong_AsLong(obj);
2766  if (!PyErr_Occurred()) {
2767  if (val) *val = v;
2769  } else {
2770  PyErr_Clear();
2771  }
2772  }
2773  }
2774 #endif
2775  return res;
2776 }
2777 
2778 
2779  #define SWIG_From_double PyFloat_FromDouble
2780 
2781 
2782  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2783  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2784  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2785  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2786  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2788  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
2789 
2790 
2791 SWIGINTERNINLINE PyObject*
2793 {
2794  return PyInt_FromLong((long) value);
2795 }
2796 
2797 
2798 #include <limits.h>
2799 #if !defined(SWIG_NO_LLONG_MAX)
2800 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2801 # define LLONG_MAX __LONG_LONG_MAX__
2802 # define LLONG_MIN (-LLONG_MAX - 1LL)
2803 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2804 # endif
2805 #endif
2806 
2807 
2808 #include <float.h>
2809 
2810 
2811 #include <math.h>
2812 
2813 
2814 SWIGINTERNINLINE int
2815 SWIG_CanCastAsInteger(double *d, double min, double max) {
2816  double x = *d;
2817  if ((min <= x && x <= max)) {
2818  double fx = floor(x);
2819  double cx = ceil(x);
2820  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2821  if ((errno == EDOM) || (errno == ERANGE)) {
2822  errno = 0;
2823  } else {
2824  double summ, reps, diff;
2825  if (rd < x) {
2826  diff = x - rd;
2827  } else if (rd > x) {
2828  diff = rd - x;
2829  } else {
2830  return 1;
2831  }
2832  summ = rd + x;
2833  reps = diff/summ;
2834  if (reps < 8*DBL_EPSILON) {
2835  *d = rd;
2836  return 1;
2837  }
2838  }
2839  }
2840  return 0;
2841 }
2842 
2843 
2844 SWIGINTERN int
2845 SWIG_AsVal_long (PyObject *obj, long* val)
2846 {
2847 #if PY_VERSION_HEX < 0x03000000
2848  if (PyInt_Check(obj)) {
2849  if (val) *val = PyInt_AsLong(obj);
2850  return SWIG_OK;
2851  } else
2852 #endif
2853  if (PyLong_Check(obj)) {
2854  long v = PyLong_AsLong(obj);
2855  if (!PyErr_Occurred()) {
2856  if (val) *val = v;
2857  return SWIG_OK;
2858  } else {
2859  PyErr_Clear();
2860  return SWIG_OverflowError;
2861  }
2862  }
2863 #ifdef SWIG_PYTHON_CAST_MODE
2864  {
2865  int dispatch = 0;
2866  long v = PyInt_AsLong(obj);
2867  if (!PyErr_Occurred()) {
2868  if (val) *val = v;
2869  return SWIG_AddCast(SWIG_OK);
2870  } else {
2871  PyErr_Clear();
2872  }
2873  if (!dispatch) {
2874  double d;
2875  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2876  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2877  if (val) *val = (long)(d);
2878  return res;
2879  }
2880  }
2881  }
2882 #endif
2883  return SWIG_TypeError;
2884 }
2885 
2886 
2887 SWIGINTERN int
2888 SWIG_AsVal_int (PyObject * obj, int *val)
2889 {
2890  long v;
2891  int res = SWIG_AsVal_long (obj, &v);
2892  if (SWIG_IsOK(res)) {
2893  if ((v < INT_MIN || v > INT_MAX)) {
2894  return SWIG_OverflowError;
2895  } else {
2896  if (val) *val = (int)(v);
2897  }
2898  }
2899  return res;
2900 }
2901 
2902 
2903 SWIGINTERN int
2904 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2905 {
2906 #if PY_VERSION_HEX < 0x03000000
2907  if (PyInt_Check(obj)) {
2908  long v = PyInt_AsLong(obj);
2909  if (v >= 0) {
2910  if (val) *val = v;
2911  return SWIG_OK;
2912  } else {
2913  return SWIG_OverflowError;
2914  }
2915  } else
2916 #endif
2917  if (PyLong_Check(obj)) {
2918  unsigned long v = PyLong_AsUnsignedLong(obj);
2919  if (!PyErr_Occurred()) {
2920  if (val) *val = v;
2921  return SWIG_OK;
2922  } else {
2923  PyErr_Clear();
2924  return SWIG_OverflowError;
2925  }
2926  }
2927 #ifdef SWIG_PYTHON_CAST_MODE
2928  {
2929  int dispatch = 0;
2930  unsigned long v = PyLong_AsUnsignedLong(obj);
2931  if (!PyErr_Occurred()) {
2932  if (val) *val = v;
2933  return SWIG_AddCast(SWIG_OK);
2934  } else {
2935  PyErr_Clear();
2936  }
2937  if (!dispatch) {
2938  double d;
2939  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2940  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2941  if (val) *val = (unsigned long)(d);
2942  return res;
2943  }
2944  }
2945  }
2946 #endif
2947  return SWIG_TypeError;
2948 }
2949 
2950 
2951 SWIGINTERN int
2952 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2953 {
2954  unsigned long v;
2955  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2956  if (SWIG_IsOK(res)) {
2957  if ((v > UINT_MAX)) {
2958  return SWIG_OverflowError;
2959  } else {
2960  if (val) *val = (unsigned int)(v);
2961  }
2962  }
2963  return res;
2964 }
2965 
2966 
2967 SWIGINTERNINLINE PyObject*
2969 {
2970  return PyInt_FromSize_t((size_t) value);
2971 }
2972 
2973 
2976 {
2977  static int init = 0;
2978  static swig_type_info* info = 0;
2979  if (!init) {
2980  info = SWIG_TypeQuery("_p_char");
2981  init = 1;
2982  }
2983  return info;
2984 }
2985 
2986 
2987 SWIGINTERN int
2988 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2989 {
2990 #if PY_VERSION_HEX>=0x03000000
2991 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2992  if (PyBytes_Check(obj))
2993 #else
2994  if (PyUnicode_Check(obj))
2995 #endif
2996 #else
2997  if (PyString_Check(obj))
2998 #endif
2999  {
3000  char *cstr; Py_ssize_t len;
3001  int ret = SWIG_OK;
3002 #if PY_VERSION_HEX>=0x03000000
3003 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3004  if (!alloc && cptr) {
3005  /* We can't allow converting without allocation, since the internal
3006  representation of string in Python 3 is UCS-2/UCS-4 but we require
3007  a UTF-8 representation.
3008  TODO(bhy) More detailed explanation */
3009  return SWIG_RuntimeError;
3010  }
3011  obj = PyUnicode_AsUTF8String(obj);
3012  if (!obj)
3013  return SWIG_TypeError;
3014  if (alloc)
3015  *alloc = SWIG_NEWOBJ;
3016 #endif
3017  PyBytes_AsStringAndSize(obj, &cstr, &len);
3018 #else
3019  PyString_AsStringAndSize(obj, &cstr, &len);
3020 #endif
3021  if (cptr) {
3022  if (alloc) {
3023  if (*alloc == SWIG_NEWOBJ) {
3024  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3025  *alloc = SWIG_NEWOBJ;
3026  } else {
3027  *cptr = cstr;
3028  *alloc = SWIG_OLDOBJ;
3029  }
3030  } else {
3031 #if PY_VERSION_HEX>=0x03000000
3032 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3033  *cptr = PyBytes_AsString(obj);
3034 #else
3035  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3036 #endif
3037 #else
3038  *cptr = SWIG_Python_str_AsChar(obj);
3039  if (!*cptr)
3040  ret = SWIG_TypeError;
3041 #endif
3042  }
3043  }
3044  if (psize) *psize = len + 1;
3045 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3046  Py_XDECREF(obj);
3047 #endif
3048  return ret;
3049  } else {
3050 #if defined(SWIG_PYTHON_2_UNICODE)
3051 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3052 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3053 #endif
3054 #if PY_VERSION_HEX<0x03000000
3055  if (PyUnicode_Check(obj)) {
3056  char *cstr; Py_ssize_t len;
3057  if (!alloc && cptr) {
3058  return SWIG_RuntimeError;
3059  }
3060  obj = PyUnicode_AsUTF8String(obj);
3061  if (!obj)
3062  return SWIG_TypeError;
3063  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3064  if (cptr) {
3065  if (alloc) *alloc = SWIG_NEWOBJ;
3066  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3067  }
3068  if (psize) *psize = len + 1;
3069 
3070  Py_XDECREF(obj);
3071  return SWIG_OK;
3072  } else {
3073  Py_XDECREF(obj);
3074  }
3075  }
3076 #endif
3077 #endif
3078 
3079  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3080  if (pchar_descriptor) {
3081  void* vptr = 0;
3082  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3083  if (cptr) *cptr = (char *) vptr;
3084  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3085  if (alloc) *alloc = SWIG_OLDOBJ;
3086  return SWIG_OK;
3087  }
3088  }
3089  }
3090  return SWIG_TypeError;
3091 }
3092 
3093 
3094 SWIGINTERN int
3095 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3096 {
3097  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3098  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3099  if (SWIG_IsOK(res)) {
3100  /* special case of single char conversion when we don't need space for NUL */
3101  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3102  if (csize <= size) {
3103  if (val) {
3104  if (csize) memcpy(val, cptr, csize*sizeof(char));
3105  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3106  }
3107  if (alloc == SWIG_NEWOBJ) {
3108  free((char*)cptr);
3109  res = SWIG_DelNewMask(res);
3110  }
3111  return res;
3112  }
3113  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3114  }
3115  return SWIG_TypeError;
3116 }
3117 
3118 
3119 SWIGINTERNINLINE PyObject *
3120 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3121 {
3122  if (carray) {
3123  if (size > INT_MAX) {
3124  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3125  return pchar_descriptor ?
3126  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3127  } else {
3128 #if PY_VERSION_HEX >= 0x03000000
3129 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3130  return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3131 #else
3132  return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3133 #endif
3134 #else
3135  return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3136 #endif
3137  }
3138  } else {
3139  return SWIG_Py_Void();
3140  }
3141 }
3142 
3143 
3144 SWIGINTERN size_t
3145 SWIG_strnlen(const char* s, size_t maxlen)
3146 {
3147  const char *p;
3148  for (p = s; maxlen-- && *p; p++)
3149  ;
3150  return p - s;
3151 }
3152 
3153 
3154 
3155 
3156 
3157 #define t_output_helper SWIG_Python_AppendOutput
3158 
3159 
3160 SWIGINTERN int
3161 SWIG_AsVal_char (PyObject * obj, char *val)
3162 {
3163  int res = SWIG_AsCharArray(obj, val, 1);
3164  if (!SWIG_IsOK(res)) {
3165  long v;
3166  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3167  if (SWIG_IsOK(res)) {
3168  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3169  if (val) *val = (char)(v);
3170  } else {
3171  res = SWIG_OverflowError;
3172  }
3173  }
3174  }
3175  return res;
3176 }
3177 
3178 #ifdef __cplusplus
3179 extern "C" {
3180 #endif
3181 
3182  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3183 
3184 // some really twisted stuff to allow calling a single precision library from python
3185  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3186  {
3187  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3188  mindims, maxdims );
3189  if ( !tmp )
3190  {
3191  // could be an incoming long array which can't be "safely" converted, do it anyway
3192  if ( PyArray_Check( in ) )
3193  {
3194  PyErr_Clear();
3195  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3196  }
3197  }
3198  return tmp;
3199  }
3200 
3201 
3202 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3203 
3204 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3205  PyObject *resultobj = 0;
3206  PLFLT arg1 ;
3207  PLFLT arg2 ;
3208  PLFLT *arg3 = (PLFLT *) 0 ;
3209  PLFLT *arg4 = (PLFLT *) 0 ;
3210  PLPointer arg5 = (PLPointer) 0 ;
3211  double val1 ;
3212  int ecode1 = 0 ;
3213  double val2 ;
3214  int ecode2 = 0 ;
3215  PLFLT temp3 ;
3216  int res3 = SWIG_TMPOBJ ;
3217  PLFLT temp4 ;
3218  int res4 = SWIG_TMPOBJ ;
3219  PyObject *swig_obj[2] ;
3220 
3221  arg3 = &temp3;
3222  arg4 = &temp4;
3223  {
3224  arg5 = NULL;
3225  }
3226  if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3227  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3228  if (!SWIG_IsOK(ecode1)) {
3229  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3230  }
3231  arg1 = (PLFLT)(val1);
3232  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3233  if (!SWIG_IsOK(ecode2)) {
3234  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3235  }
3236  arg2 = (PLFLT)(val2);
3237  pltr0(arg1,arg2,arg3,arg4,arg5);
3238  resultobj = SWIG_Py_Void();
3239  if (SWIG_IsTmpObj(res3)) {
3240  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3241  } else {
3242  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3243  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3244  }
3245  if (SWIG_IsTmpObj(res4)) {
3246  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3247  } else {
3248  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3249  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3250  }
3251  return resultobj;
3252 fail:
3253  return NULL;
3254 }
3255 
3256 
3257 
3258  PyArrayObject *pltr_xg, *pltr_yg;
3261 
3262  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3263  void cleanup_PLcGrid1( void );
3264  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3265  void cleanup_PLcGrid2( void );
3266 
3267  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3268  {
3269  // fprintf(stderr, "marshal PLcGrid1\n");
3270  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3271  {
3272  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3273  return NULL;
3274  }
3275  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3276  NPY_PLFLT, 1, 1 );
3277  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3278  NPY_PLFLT, 1, 1 );
3279  if ( pltr_xg == 0 || pltr_yg == 0 )
3280  {
3281  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3282  return NULL;
3283  }
3284  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3285  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3286  if ( isimg == 0 )
3287  {
3288  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3289  {
3290  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3291  return NULL;
3292  }
3293  }
3294  else
3295  {
3296  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3297  {
3298  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3299  return NULL;
3300  }
3301  }
3302  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3303  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3304  return &tmpGrid1;
3305  }
3306 
3307  void cleanup_PLcGrid1( void )
3308  {
3309  // fprintf(stderr, "cleanup PLcGrid1\n");
3310  Py_CLEAR( pltr_xg );
3311  Py_CLEAR( pltr_yg );
3312  }
3313 
3314  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3315  {
3316  int i, size;
3317  // fprintf(stderr, "marshal PLcGrid2\n");
3318  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3319  {
3320  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3321  return NULL;
3322  }
3323  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3324  NPY_PLFLT, 2, 2 );
3325  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3326  NPY_PLFLT, 2, 2 );
3327  if ( pltr_xg == 0 || pltr_yg == 0 )
3328  {
3329  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3330  return NULL;
3331  }
3332  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3333  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3334  {
3335  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3336  return NULL;
3337  }
3338  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3339  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3340  if ( isimg == 0 )
3341  {
3342  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3343  {
3344  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3345  return NULL;
3346  }
3347  }
3348  else
3349  {
3350  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3351  {
3352  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3353  return NULL;
3354  }
3355  }
3356  size = tmpGrid2.ny;
3357  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3358  for ( i = 0; i < tmpGrid2.nx; i++ )
3359  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3360  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3361  for ( i = 0; i < tmpGrid2.nx; i++ )
3362  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3363  return &tmpGrid2;
3364  }
3365 
3366  void cleanup_PLcGrid2( void )
3367  {
3368  // fprintf(stderr, "cleanup PLcGrid2\n");
3369  free( tmpGrid2.xg );
3370  free( tmpGrid2.yg );
3371  Py_CLEAR( pltr_xg );
3372  Py_CLEAR( pltr_yg );
3373  }
3374 
3375 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3376  PyObject *resultobj = 0;
3377  PLFLT arg1 ;
3378  PLFLT arg2 ;
3379  PLFLT *arg3 = (PLFLT *) 0 ;
3380  PLFLT *arg4 = (PLFLT *) 0 ;
3381  PLcGrid *arg5 = (PLcGrid *) 0 ;
3382  double val1 ;
3383  int ecode1 = 0 ;
3384  double val2 ;
3385  int ecode2 = 0 ;
3386  PLFLT temp3 ;
3387  int res3 = SWIG_TMPOBJ ;
3388  PLFLT temp4 ;
3389  int res4 = SWIG_TMPOBJ ;
3390  PyObject *swig_obj[3] ;
3391 
3392  arg3 = &temp3;
3393  arg4 = &temp4;
3394  if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3395  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3396  if (!SWIG_IsOK(ecode1)) {
3397  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3398  }
3399  arg1 = (PLFLT)(val1);
3400  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3401  if (!SWIG_IsOK(ecode2)) {
3402  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3403  }
3404  arg2 = (PLFLT)(val2);
3405  {
3406  arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3407  if ( !arg5 )
3408  return NULL;
3409  }
3410  pltr1(arg1,arg2,arg3,arg4,arg5);
3411  resultobj = SWIG_Py_Void();
3412  if (SWIG_IsTmpObj(res3)) {
3413  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3414  } else {
3415  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3416  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3417  }
3418  if (SWIG_IsTmpObj(res4)) {
3419  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3420  } else {
3421  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3422  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3423  }
3424  {
3425  cleanup_PLcGrid1();
3426  }
3427  return resultobj;
3428 fail:
3429  {
3430  cleanup_PLcGrid1();
3431  }
3432  return NULL;
3433 }
3434 
3435 
3436 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3437  PyObject *resultobj = 0;
3438  PLFLT arg1 ;
3439  PLFLT arg2 ;
3440  PLFLT *arg3 = (PLFLT *) 0 ;
3441  PLFLT *arg4 = (PLFLT *) 0 ;
3442  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3443  double val1 ;
3444  int ecode1 = 0 ;
3445  double val2 ;
3446  int ecode2 = 0 ;
3447  PLFLT temp3 ;
3448  int res3 = SWIG_TMPOBJ ;
3449  PLFLT temp4 ;
3450  int res4 = SWIG_TMPOBJ ;
3451  PyObject *swig_obj[3] ;
3452 
3453  arg3 = &temp3;
3454  arg4 = &temp4;
3455  if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3456  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3457  if (!SWIG_IsOK(ecode1)) {
3458  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3459  }
3460  arg1 = (PLFLT)(val1);
3461  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3462  if (!SWIG_IsOK(ecode2)) {
3463  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3464  }
3465  arg2 = (PLFLT)(val2);
3466  {
3467  arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3468  if ( !arg5 )
3469  return NULL;
3470  }
3471  pltr2(arg1,arg2,arg3,arg4,arg5);
3472  resultobj = SWIG_Py_Void();
3473  if (SWIG_IsTmpObj(res3)) {
3474  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3475  } else {
3476  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3477  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3478  }
3479  if (SWIG_IsTmpObj(res4)) {
3480  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3481  } else {
3482  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3483  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3484  }
3485  {
3486  cleanup_PLcGrid2();
3487  }
3488  return resultobj;
3489 fail:
3490  {
3491  cleanup_PLcGrid2();
3492  }
3493  return NULL;
3494 }
3495 
3496 
3497 
3498  // helper code for handling the callback
3499 #if 0
3500  static PyInterpreterState *save_interp = NULL;
3501 #endif
3503  PyObject* python_pltr = NULL;
3504  PyObject* python_f2eval = NULL;
3505  PyObject* python_ct = NULL;
3506  PyObject* python_mapform = NULL;
3507  PyObject* python_label = NULL;
3508 
3509 #if 0
3510 #define MY_BLOCK_THREADS { \
3511  PyThreadState *prev_state, *new_state; \
3512  /* need to have started a thread at some stage */ \
3513  /* for the following to work */ \
3514  PyEval_AcquireLock(); \
3515  new_state = PyThreadState_New( save_interp ); \
3516  prev_state = PyThreadState_Swap( new_state );
3517 #define MY_UNBLOCK_THREADS \
3518  new_state = PyThreadState_Swap( prev_state ); \
3519  PyThreadState_Clear( new_state ); \
3520  PyEval_ReleaseLock(); \
3521  PyThreadState_Delete( new_state ); \
3522  }
3523 #else
3524 #define MY_BLOCK_THREADS
3525 #define MY_UNBLOCK_THREADS
3526 #endif
3527 
3528 // Function prototypes
3529  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3531  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3532  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3533  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3534  pltr_func marshal_pltr( PyObject* input );
3535  void cleanup_pltr( void );
3536  ct_func marshal_ct( PyObject* input );
3537  void cleanup_ct( void );
3538  mapform_func marshal_mapform( PyObject* input );
3539  void cleanup_mapform( void );
3540  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3541  void cleanup_PLPointer( void );
3542 
3543 
3544 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3545 
3546  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3547  {
3548  PyObject *pdata, *arglist, *result;
3549  PyArrayObject *tmp;
3550 
3551  // the data argument is acutally a pointer to a python object
3552  pdata = (PyObject *) data;
3553  if ( data == NULL )
3554  {
3555  pdata = Py_None;
3556  }
3557  if ( python_pltr ) // if not something is terribly wrong
3558  { // hold a reference to the data object
3559  Py_XINCREF( pdata );
3560  // grab the Global Interpreter Lock to be sure threads don't mess us up
3562  // build the argument list
3563 #ifdef PL_DOUBLE
3564  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3565 #else
3566  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3567 #endif
3568  if ( arglist == NULL )
3569  {
3570  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3571  *tx = *ty = 0;
3572  return;
3573  }
3574  // call the python function
3575  result = PyEval_CallObject( python_pltr, arglist );
3576  // release the argument list
3577  Py_CLEAR( arglist );
3578  // check and unpack the result
3579  if ( result == NULL )
3580  {
3581  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3582  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3583  *tx = *ty = 0;
3584  }
3585  else
3586  {
3587  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3588  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3589  {
3590  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3591  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3592  *tx = *ty = 0;
3593  }
3594  else
3595  {
3596  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3597  *tx = t[0];
3598  *ty = t[1];
3599  Py_CLEAR( tmp );
3600  }
3601  }
3602  // release the result
3603  Py_CLEAR( result );
3604  // release the global interpreter lock
3606  }
3607  }
3608 
3610  {
3611  PyObject *pdata, *arglist, *result;
3612  PLFLT fresult = 0.0;
3613 
3614  // the data argument is acutally a pointer to a python object
3615  pdata = (PyObject *) data;
3616  if ( python_f2eval ) // if not something is terribly wrong
3617  { // hold a reference to the data object
3618  Py_XINCREF( pdata );
3619  // grab the Global Interpreter Lock to be sure threads don't mess us up
3621  // build the argument list
3622  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3623  // call the python function
3624  result = PyEval_CallObject( python_f2eval, arglist );
3625  // release the argument list
3626  Py_CLEAR( arglist );
3627  // check and unpack the result
3628  if ( !PyFloat_Check( result ) )
3629  {
3630  fprintf( stderr, "f2eval callback must return a float\n" );
3631  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3632  }
3633  else
3634  {
3635  // should I test the type here?
3636  fresult = (PLFLT) PyFloat_AsDouble( result );
3637  }
3638  // release the result
3639  Py_CLEAR( result );
3640  // release the global interpreter lock
3642  }
3643  return fresult;
3644  }
3645 
3646  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3647  {
3648  PyObject *pdata, *arglist, *result, *unicode_string;
3649  char *pystring;
3650 
3651  // the data argument is acutally a pointer to a python object
3652  if ( data )
3653  pdata = (PyObject *) data;
3654  else
3655  pdata = Py_None;
3656  if ( python_label ) // if not something is terribly wrong
3657  { // hold a reference to the data object
3658  Py_XINCREF( pdata );
3659  // grab the Global Interpreter Lock to be sure threads don't mess us up
3661  // build the argument list
3662 #ifdef PL_DOUBLE
3663  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3664 #else
3665  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3666 #endif
3667  // call the python function
3668  result = PyEval_CallObject( python_label, arglist );
3669  // release the argument list
3670  //Py_CLEAR(arglist);
3671  // check and unpack the result
3672  if ( result == NULL )
3673  {
3674  fprintf( stderr, "label callback failed with 3 arguments\n" );
3675  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3676  }
3677  else if ( PyString_Check( result ) )
3678  {
3679  // should I test the type here?
3680  pystring = PyString_AsString( result );
3681  strncpy( string, pystring, len );
3682  }
3683  else if ( PyUnicode_Check( result ) )
3684  {
3685  // unicode_string is never freed? memory leak here?
3686  unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
3687  pystring = PyBytes_AS_STRING( unicode_string );
3688  // len may be different then the byte string length w/ unicode?
3689  strncpy( string, pystring, len );
3690  }
3691  else
3692  {
3693  fprintf( stderr, "label callback must return a string\n" );
3694  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3695  }
3696  // release the result
3697  Py_CLEAR( result );
3698  // release the global interpreter lock
3700  }
3701  }
3702 
3703  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3704  {
3705  PyObject *px, *py, *pdata, *arglist, *result;
3706  npy_intp n;
3707  n = 1;
3708 
3709  // the data argument is acutally a pointer to a python object
3710  pdata = (PyObject *) data;
3711  if ( data == NULL )
3712  {
3713  pdata = Py_None;
3714  }
3715  if ( python_ct ) // if not something is terribly wrong
3716  { // hold a reference to the data object
3717  Py_XINCREF( pdata );
3718  // grab the Global Interpreter Lock to be sure threads don't mess us up
3720  // build the argument list
3721  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3722  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3723  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3724  // call the python function
3725  result = PyEval_CallObject( python_ct, arglist );
3726  // release the argument list
3727  Py_CLEAR( arglist );
3728  Py_CLEAR( px );
3729  Py_CLEAR( py );
3730  Py_CLEAR( pdata );
3731  // check and unpack the result
3732  if ( result == NULL )
3733  {
3734  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3735  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3736  }
3737  // release the result
3738  Py_CLEAR( result );
3739  // release the global interpreter lock
3741  }
3742  }
3743 
3745  {
3746  PyObject *px, *py, *arglist, *result;
3747  // PyArrayObject *tmpx, *tmpy;
3748 // PLFLT *xx, *yy;
3749 // PLINT i;
3750  npy_intp nn;
3751  nn = n;
3752 
3753  if ( python_mapform ) // if not something is terribly wrong
3754  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3756  // build the argument list
3757 #ifdef PL_HAVE_PTHREAD
3758  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3759  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3760 #else
3761  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3762  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3763 #endif
3764  arglist = Py_BuildValue( "(iOO)", n, px, py );
3765  // call the python function
3766  result = PyEval_CallObject( python_mapform, arglist );
3767  // release the argument list
3768  Py_CLEAR( arglist );
3769  Py_CLEAR( px );
3770  Py_CLEAR( py );
3771  // check and unpack the result
3772  if ( result == NULL )
3773  {
3774  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3775  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3776  }
3777  // release the result
3778  Py_CLEAR( result );
3779  // release the global interpreter lock
3781  }
3782  }
3783 
3784 // marshal the pltr function pointer argument
3785  pltr_func marshal_pltr( PyObject* input )
3786  {
3787  pltr_func result = do_pltr_callback;
3788  PyObject * rep = PyObject_Repr( input );
3789  if ( rep )
3790  {
3791  // Memory leaks here? str and uni_str are not freed?
3792  char* str;
3793  if ( PyUnicode_Check( rep ) )
3794  {
3795  PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
3796  str = PyBytes_AS_STRING( uni_str );
3797  }
3798  else
3799  {
3800  str = PyString_AsString( rep );
3801  }
3802  if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
3803  {
3804  result = pltr0;
3805  pltr_type = CB_0;
3806  python_pltr = NULL;
3807  }
3808  else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
3809  {
3810  result = pltr1;
3811  pltr_type = CB_1;
3812  python_pltr = NULL;
3813  }
3814  else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
3815  {
3816  result = pltr2;
3817  pltr_type = CB_2;
3818  python_pltr = NULL;
3819  }
3820  else
3821  {
3822  python_pltr = input;
3823  pltr_type = CB_Python;
3824  Py_XINCREF( input );
3825  }
3826  Py_CLEAR( rep );
3827  }
3828  else
3829  {
3830  python_pltr = input;
3831  pltr_type = CB_Python;
3832  Py_XINCREF( input );
3833  }
3834  return result;
3835  }
3836 
3837  void cleanup_pltr( void )
3838  {
3839  Py_CLEAR( python_pltr );
3840  python_pltr = 0;
3841  }
3842 
3843 // marshal the ct function pointer argument
3844  ct_func marshal_ct( PyObject* input )
3845  {
3846  ct_func result = do_ct_callback;
3847  python_ct = input;
3848  Py_XINCREF( input );
3849  return result;
3850  }
3851 
3852  void cleanup_ct( void )
3853  {
3854  Py_CLEAR( python_ct );
3855  python_ct = 0;
3856  }
3857 
3858 // marshal the mapform function pointer argument
3859  mapform_func marshal_mapform( PyObject* input )
3860  {
3862  python_mapform = input;
3863  Py_XINCREF( input );
3864  return result;
3865  }
3866 
3867  void cleanup_mapform( void )
3868  {
3869  Py_CLEAR( python_mapform );
3870  python_mapform = 0;
3871  }
3872 
3873  PLPointer marshal_PLPointer( PyObject* input, int isimg )
3874  {
3875  PLPointer result = NULL;
3876  switch ( pltr_type )
3877  {
3878  case CB_0:
3879  break;
3880  case CB_1:
3881  if ( input != Py_None )
3882  result = marshal_PLcGrid1( input, isimg );
3883  break;
3884  case CB_2:
3885  if ( input != Py_None )
3886  result = marshal_PLcGrid2( input, isimg );
3887  break;
3888  case CB_Python:
3889  Py_XINCREF( input );
3890  result = (PLPointer *) input;
3891  break;
3892  default:
3893  fprintf( stderr, "pltr_type is invalid\n" );
3894  }
3895  return result;
3896  }
3897 
3898  void cleanup_PLPointer( void )
3899  {
3900  switch ( pltr_type )
3901  {
3902  case CB_0:
3903  break;
3904  case CB_1:
3905  cleanup_PLcGrid1();
3906  break;
3907  case CB_2:
3908  cleanup_PLcGrid2();
3909  break;
3910  case CB_Python:
3911  Py_CLEAR( python_pltr );
3912  break;
3913  default:
3914  fprintf( stderr, "pltr_type is invalid\n" );
3915  }
3916  python_pltr = 0;
3917  pltr_type = CB_0;
3918  }
3919 
3920 
3921 
3922 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3923  PyObject *resultobj = 0;
3924  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3925  int arg2 ;
3926  void *argp1 = 0 ;
3927  int res1 = 0 ;
3928  int val2 ;
3929  int ecode2 = 0 ;
3930  PyObject *swig_obj[2] ;
3931 
3932  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
3933  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3934  if (!SWIG_IsOK(res1)) {
3935  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3936  }
3937  arg1 = (PLGraphicsIn *)(argp1);
3938  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
3939  if (!SWIG_IsOK(ecode2)) {
3940  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
3941  }
3942  arg2 = (int)(val2);
3943  if (arg1) (arg1)->type = arg2;
3944  resultobj = SWIG_Py_Void();
3945  return resultobj;
3946 fail:
3947  return NULL;
3948 }
3949 
3950 
3951 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3952  PyObject *resultobj = 0;
3953  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3954  void *argp1 = 0 ;
3955  int res1 = 0 ;
3956  PyObject *swig_obj[1] ;
3957  int result;
3958 
3959  if (!args) SWIG_fail;
3960  swig_obj[0] = args;
3961  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3962  if (!SWIG_IsOK(res1)) {
3963  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3964  }
3965  arg1 = (PLGraphicsIn *)(argp1);
3966  result = (int) ((arg1)->type);
3967  resultobj = SWIG_From_int((int)(result));
3968  return resultobj;
3969 fail:
3970  return NULL;
3971 }
3972 
3973 
3974 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3975  PyObject *resultobj = 0;
3976  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3977  unsigned int arg2 ;
3978  void *argp1 = 0 ;
3979  int res1 = 0 ;
3980  unsigned int val2 ;
3981  int ecode2 = 0 ;
3982  PyObject *swig_obj[2] ;
3983 
3984  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
3985  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3986  if (!SWIG_IsOK(res1)) {
3987  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3988  }
3989  arg1 = (PLGraphicsIn *)(argp1);
3990  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
3991  if (!SWIG_IsOK(ecode2)) {
3992  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
3993  }
3994  arg2 = (unsigned int)(val2);
3995  if (arg1) (arg1)->state = arg2;
3996  resultobj = SWIG_Py_Void();
3997  return resultobj;
3998 fail:
3999  return NULL;
4000 }
4001 
4002 
4003 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4004  PyObject *resultobj = 0;
4005  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4006  void *argp1 = 0 ;
4007  int res1 = 0 ;
4008  PyObject *swig_obj[1] ;
4009  unsigned int result;
4010 
4011  if (!args) SWIG_fail;
4012  swig_obj[0] = args;
4013  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4014  if (!SWIG_IsOK(res1)) {
4015  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4016  }
4017  arg1 = (PLGraphicsIn *)(argp1);
4018  result = (unsigned int) ((arg1)->state);
4019  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4020  return resultobj;
4021 fail:
4022  return NULL;
4023 }
4024 
4025 
4026 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4027  PyObject *resultobj = 0;
4028  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4029  unsigned int arg2 ;
4030  void *argp1 = 0 ;
4031  int res1 = 0 ;
4032  unsigned int val2 ;
4033  int ecode2 = 0 ;
4034  PyObject *swig_obj[2] ;
4035 
4036  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4037  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4038  if (!SWIG_IsOK(res1)) {
4039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4040  }
4041  arg1 = (PLGraphicsIn *)(argp1);
4042  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4043  if (!SWIG_IsOK(ecode2)) {
4044  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4045  }
4046  arg2 = (unsigned int)(val2);
4047  if (arg1) (arg1)->keysym = arg2;
4048  resultobj = SWIG_Py_Void();
4049  return resultobj;
4050 fail:
4051  return NULL;
4052 }
4053 
4054 
4055 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4056  PyObject *resultobj = 0;
4057  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4058  void *argp1 = 0 ;
4059  int res1 = 0 ;
4060  PyObject *swig_obj[1] ;
4061  unsigned int result;
4062 
4063  if (!args) SWIG_fail;
4064  swig_obj[0] = args;
4065  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4066  if (!SWIG_IsOK(res1)) {
4067  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4068  }
4069  arg1 = (PLGraphicsIn *)(argp1);
4070  result = (unsigned int) ((arg1)->keysym);
4071  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4072  return resultobj;
4073 fail:
4074  return NULL;
4075 }
4076 
4077 
4078 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4079  PyObject *resultobj = 0;
4080  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4081  unsigned int arg2 ;
4082  void *argp1 = 0 ;
4083  int res1 = 0 ;
4084  unsigned int val2 ;
4085  int ecode2 = 0 ;
4086  PyObject *swig_obj[2] ;
4087 
4088  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4089  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4090  if (!SWIG_IsOK(res1)) {
4091  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4092  }
4093  arg1 = (PLGraphicsIn *)(argp1);
4094  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4095  if (!SWIG_IsOK(ecode2)) {
4096  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4097  }
4098  arg2 = (unsigned int)(val2);
4099  if (arg1) (arg1)->button = arg2;
4100  resultobj = SWIG_Py_Void();
4101  return resultobj;
4102 fail:
4103  return NULL;
4104 }
4105 
4106 
4107 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4108  PyObject *resultobj = 0;
4109  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4110  void *argp1 = 0 ;
4111  int res1 = 0 ;
4112  PyObject *swig_obj[1] ;
4113  unsigned int result;
4114 
4115  if (!args) SWIG_fail;
4116  swig_obj[0] = args;
4117  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4118  if (!SWIG_IsOK(res1)) {
4119  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4120  }
4121  arg1 = (PLGraphicsIn *)(argp1);
4122  result = (unsigned int) ((arg1)->button);
4123  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4124  return resultobj;
4125 fail:
4126  return NULL;
4127 }
4128 
4129 
4130 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4131  PyObject *resultobj = 0;
4132  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4133  PLINT arg2 ;
4134  void *argp1 = 0 ;
4135  int res1 = 0 ;
4136  int val2 ;
4137  int ecode2 = 0 ;
4138  PyObject *swig_obj[2] ;
4139 
4140  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4141  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4142  if (!SWIG_IsOK(res1)) {
4143  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4144  }
4145  arg1 = (PLGraphicsIn *)(argp1);
4146  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4147  if (!SWIG_IsOK(ecode2)) {
4148  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4149  }
4150  arg2 = (PLINT)(val2);
4151  if (arg1) (arg1)->subwindow = arg2;
4152  resultobj = SWIG_Py_Void();
4153  return resultobj;
4154 fail:
4155  return NULL;
4156 }
4157 
4158 
4159 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4160  PyObject *resultobj = 0;
4161  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4162  void *argp1 = 0 ;
4163  int res1 = 0 ;
4164  PyObject *swig_obj[1] ;
4165  PLINT result;
4166 
4167  if (!args) SWIG_fail;
4168  swig_obj[0] = args;
4169  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4170  if (!SWIG_IsOK(res1)) {
4171  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4172  }
4173  arg1 = (PLGraphicsIn *)(argp1);
4174  result = (PLINT) ((arg1)->subwindow);
4175  resultobj = SWIG_From_int((int)(result));
4176  return resultobj;
4177 fail:
4178  return NULL;
4179 }
4180 
4181 
4182 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4183  PyObject *resultobj = 0;
4184  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4185  char *arg2 ;
4186  void *argp1 = 0 ;
4187  int res1 = 0 ;
4188  char temp2[16] ;
4189  int res2 ;
4190  PyObject *swig_obj[2] ;
4191 
4192  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4193  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4194  if (!SWIG_IsOK(res1)) {
4195  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4196  }
4197  arg1 = (PLGraphicsIn *)(argp1);
4198  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4199  if (!SWIG_IsOK(res2)) {
4200  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4201  }
4202  arg2 = (char *)(temp2);
4203  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4204  else memset(arg1->string,0,16*sizeof(char));
4205  resultobj = SWIG_Py_Void();
4206  return resultobj;
4207 fail:
4208  return NULL;
4209 }
4210 
4211 
4212 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4213  PyObject *resultobj = 0;
4214  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4215  void *argp1 = 0 ;
4216  int res1 = 0 ;
4217  PyObject *swig_obj[1] ;
4218  char *result = 0 ;
4219 
4220  if (!args) SWIG_fail;
4221  swig_obj[0] = args;
4222  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4223  if (!SWIG_IsOK(res1)) {
4224  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4225  }
4226  arg1 = (PLGraphicsIn *)(argp1);
4227  result = (char *)(char *) ((arg1)->string);
4228  {
4229  size_t size = SWIG_strnlen(result, 16);
4230 
4231 
4232 
4233  resultobj = SWIG_FromCharPtrAndSize(result, size);
4234  }
4235  return resultobj;
4236 fail:
4237  return NULL;
4238 }
4239 
4240 
4241 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4242  PyObject *resultobj = 0;
4243  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4244  int arg2 ;
4245  void *argp1 = 0 ;
4246  int res1 = 0 ;
4247  int val2 ;
4248  int ecode2 = 0 ;
4249  PyObject *swig_obj[2] ;
4250 
4251  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4252  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4253  if (!SWIG_IsOK(res1)) {
4254  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4255  }
4256  arg1 = (PLGraphicsIn *)(argp1);
4257  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4258  if (!SWIG_IsOK(ecode2)) {
4259  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4260  }
4261  arg2 = (int)(val2);
4262  if (arg1) (arg1)->pX = arg2;
4263  resultobj = SWIG_Py_Void();
4264  return resultobj;
4265 fail:
4266  return NULL;
4267 }
4268 
4269 
4270 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4271  PyObject *resultobj = 0;
4272  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4273  void *argp1 = 0 ;
4274  int res1 = 0 ;
4275  PyObject *swig_obj[1] ;
4276  int result;
4277 
4278  if (!args) SWIG_fail;
4279  swig_obj[0] = args;
4280  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4281  if (!SWIG_IsOK(res1)) {
4282  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4283  }
4284  arg1 = (PLGraphicsIn *)(argp1);
4285  result = (int) ((arg1)->pX);
4286  resultobj = SWIG_From_int((int)(result));
4287  return resultobj;
4288 fail:
4289  return NULL;
4290 }
4291 
4292 
4293 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4294  PyObject *resultobj = 0;
4295  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4296  int arg2 ;
4297  void *argp1 = 0 ;
4298  int res1 = 0 ;
4299  int val2 ;
4300  int ecode2 = 0 ;
4301  PyObject *swig_obj[2] ;
4302 
4303  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4304  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4305  if (!SWIG_IsOK(res1)) {
4306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4307  }
4308  arg1 = (PLGraphicsIn *)(argp1);
4309  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4310  if (!SWIG_IsOK(ecode2)) {
4311  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4312  }
4313  arg2 = (int)(val2);
4314  if (arg1) (arg1)->pY = arg2;
4315  resultobj = SWIG_Py_Void();
4316  return resultobj;
4317 fail:
4318  return NULL;
4319 }
4320 
4321 
4322 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4323  PyObject *resultobj = 0;
4324  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4325  void *argp1 = 0 ;
4326  int res1 = 0 ;
4327  PyObject *swig_obj[1] ;
4328  int result;
4329 
4330  if (!args) SWIG_fail;
4331  swig_obj[0] = args;
4332  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4333  if (!SWIG_IsOK(res1)) {
4334  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4335  }
4336  arg1 = (PLGraphicsIn *)(argp1);
4337  result = (int) ((arg1)->pY);
4338  resultobj = SWIG_From_int((int)(result));
4339  return resultobj;
4340 fail:
4341  return NULL;
4342 }
4343 
4344 
4345 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4346  PyObject *resultobj = 0;
4347  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4348  PLFLT arg2 ;
4349  void *argp1 = 0 ;
4350  int res1 = 0 ;
4351  double val2 ;
4352  int ecode2 = 0 ;
4353  PyObject *swig_obj[2] ;
4354 
4355  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4356  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4357  if (!SWIG_IsOK(res1)) {
4358  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4359  }
4360  arg1 = (PLGraphicsIn *)(argp1);
4361  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4362  if (!SWIG_IsOK(ecode2)) {
4363  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4364  }
4365  arg2 = (PLFLT)(val2);
4366  if (arg1) (arg1)->dX = arg2;
4367  resultobj = SWIG_Py_Void();
4368  return resultobj;
4369 fail:
4370  return NULL;
4371 }
4372 
4373 
4374 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4375  PyObject *resultobj = 0;
4376  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4377  void *argp1 = 0 ;
4378  int res1 = 0 ;
4379  PyObject *swig_obj[1] ;
4380  PLFLT result;
4381 
4382  if (!args) SWIG_fail;
4383  swig_obj[0] = args;
4384  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4385  if (!SWIG_IsOK(res1)) {
4386  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4387  }
4388  arg1 = (PLGraphicsIn *)(argp1);
4389  result = (PLFLT) ((arg1)->dX);
4390  resultobj = SWIG_From_double((double)(result));
4391  return resultobj;
4392 fail:
4393  return NULL;
4394 }
4395 
4396 
4397 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398  PyObject *resultobj = 0;
4399  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4400  PLFLT arg2 ;
4401  void *argp1 = 0 ;
4402  int res1 = 0 ;
4403  double val2 ;
4404  int ecode2 = 0 ;
4405  PyObject *swig_obj[2] ;
4406 
4407  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4408  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4409  if (!SWIG_IsOK(res1)) {
4410  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4411  }
4412  arg1 = (PLGraphicsIn *)(argp1);
4413  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4414  if (!SWIG_IsOK(ecode2)) {
4415  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4416  }
4417  arg2 = (PLFLT)(val2);
4418  if (arg1) (arg1)->dY = arg2;
4419  resultobj = SWIG_Py_Void();
4420  return resultobj;
4421 fail:
4422  return NULL;
4423 }
4424 
4425 
4426 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4427  PyObject *resultobj = 0;
4428  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4429  void *argp1 = 0 ;
4430  int res1 = 0 ;
4431  PyObject *swig_obj[1] ;
4432  PLFLT result;
4433 
4434  if (!args) SWIG_fail;
4435  swig_obj[0] = args;
4436  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4437  if (!SWIG_IsOK(res1)) {
4438  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4439  }
4440  arg1 = (PLGraphicsIn *)(argp1);
4441  result = (PLFLT) ((arg1)->dY);
4442  resultobj = SWIG_From_double((double)(result));
4443  return resultobj;
4444 fail:
4445  return NULL;
4446 }
4447 
4448 
4449 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450  PyObject *resultobj = 0;
4451  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4452  PLFLT arg2 ;
4453  void *argp1 = 0 ;
4454  int res1 = 0 ;
4455  double val2 ;
4456  int ecode2 = 0 ;
4457  PyObject *swig_obj[2] ;
4458 
4459  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4460  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4461  if (!SWIG_IsOK(res1)) {
4462  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4463  }
4464  arg1 = (PLGraphicsIn *)(argp1);
4465  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4466  if (!SWIG_IsOK(ecode2)) {
4467  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4468  }
4469  arg2 = (PLFLT)(val2);
4470  if (arg1) (arg1)->wX = arg2;
4471  resultobj = SWIG_Py_Void();
4472  return resultobj;
4473 fail:
4474  return NULL;
4475 }
4476 
4477 
4478 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4479  PyObject *resultobj = 0;
4480  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4481  void *argp1 = 0 ;
4482  int res1 = 0 ;
4483  PyObject *swig_obj[1] ;
4484  PLFLT result;
4485 
4486  if (!args) SWIG_fail;
4487  swig_obj[0] = args;
4488  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4489  if (!SWIG_IsOK(res1)) {
4490  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4491  }
4492  arg1 = (PLGraphicsIn *)(argp1);
4493  result = (PLFLT) ((arg1)->wX);
4494  resultobj = SWIG_From_double((double)(result));
4495  return resultobj;
4496 fail:
4497  return NULL;
4498 }
4499 
4500 
4501 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4502  PyObject *resultobj = 0;
4503  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4504  PLFLT arg2 ;
4505  void *argp1 = 0 ;
4506  int res1 = 0 ;
4507  double val2 ;
4508  int ecode2 = 0 ;
4509  PyObject *swig_obj[2] ;
4510 
4511  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
4512  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4513  if (!SWIG_IsOK(res1)) {
4514  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4515  }
4516  arg1 = (PLGraphicsIn *)(argp1);
4517  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4518  if (!SWIG_IsOK(ecode2)) {
4519  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4520  }
4521  arg2 = (PLFLT)(val2);
4522  if (arg1) (arg1)->wY = arg2;
4523  resultobj = SWIG_Py_Void();
4524  return resultobj;
4525 fail:
4526  return NULL;
4527 }
4528 
4529 
4530 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531  PyObject *resultobj = 0;
4532  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4533  void *argp1 = 0 ;
4534  int res1 = 0 ;
4535  PyObject *swig_obj[1] ;
4536  PLFLT result;
4537 
4538  if (!args) SWIG_fail;
4539  swig_obj[0] = args;
4540  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4541  if (!SWIG_IsOK(res1)) {
4542  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4543  }
4544  arg1 = (PLGraphicsIn *)(argp1);
4545  result = (PLFLT) ((arg1)->wY);
4546  resultobj = SWIG_From_double((double)(result));
4547  return resultobj;
4548 fail:
4549  return NULL;
4550 }
4551 
4552 
4553 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554  PyObject *resultobj = 0;
4555  PLGraphicsIn *result = 0 ;
4556 
4557  if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
4558  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4560  return resultobj;
4561 fail:
4562  return NULL;
4563 }
4564 
4565 
4566 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567  PyObject *resultobj = 0;
4568  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4569  void *argp1 = 0 ;
4570  int res1 = 0 ;
4571  PyObject *swig_obj[1] ;
4572 
4573  if (!args) SWIG_fail;
4574  swig_obj[0] = args;
4575  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4576  if (!SWIG_IsOK(res1)) {
4577  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4578  }
4579  arg1 = (PLGraphicsIn *)(argp1);
4580  free((char *) arg1);
4581  resultobj = SWIG_Py_Void();
4582  return resultobj;
4583 fail:
4584  return NULL;
4585 }
4586 
4587 
4588 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589  PyObject *obj;
4590  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
4592  return SWIG_Py_Void();
4593 }
4594 
4595 SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596  return SWIG_Python_InitShadowInstance(args);
4597 }
4598 
4599 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600  PyObject *resultobj = 0;
4601  PLINT arg1 ;
4602  int val1 ;
4603  int ecode1 = 0 ;
4604  PyObject *swig_obj[1] ;
4605 
4606  if (!args) SWIG_fail;
4607  swig_obj[0] = args;
4608  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4609  if (!SWIG_IsOK(ecode1)) {
4610  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4611  }
4612  arg1 = (PLINT)(val1);
4613  plsxwin(arg1);
4614  resultobj = SWIG_Py_Void();
4615  return resultobj;
4616 fail:
4617  return NULL;
4618 }
4619 
4620 
4621 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4622  PyObject *resultobj = 0;
4623  PLINT arg1 ;
4624  PLINT arg2 ;
4625  int val1 ;
4626  int ecode1 = 0 ;
4627  int val2 ;
4628  int ecode2 = 0 ;
4629  PyObject *swig_obj[2] ;
4630 
4631  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
4632  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4633  if (!SWIG_IsOK(ecode1)) {
4634  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4635  }
4636  arg1 = (PLINT)(val1);
4637  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4638  if (!SWIG_IsOK(ecode2)) {
4639  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4640  }
4641  arg2 = (PLINT)(val2);
4642  pl_setcontlabelformat(arg1,arg2);
4643  resultobj = SWIG_Py_Void();
4644  return resultobj;
4645 fail:
4646  return NULL;
4647 }
4648 
4649 
4650 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651  PyObject *resultobj = 0;
4652  PLFLT arg1 ;
4653  PLFLT arg2 ;
4654  PLFLT arg3 ;
4655  PLINT arg4 ;
4656  double val1 ;
4657  int ecode1 = 0 ;
4658  double val2 ;
4659  int ecode2 = 0 ;
4660  double val3 ;
4661  int ecode3 = 0 ;
4662  int val4 ;
4663  int ecode4 = 0 ;
4664  PyObject *swig_obj[4] ;
4665 
4666  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
4667  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4668  if (!SWIG_IsOK(ecode1)) {
4669  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4670  }
4671  arg1 = (PLFLT)(val1);
4672  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4673  if (!SWIG_IsOK(ecode2)) {
4674  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4675  }
4676  arg2 = (PLFLT)(val2);
4677  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4678  if (!SWIG_IsOK(ecode3)) {
4679  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4680  }
4681  arg3 = (PLFLT)(val3);
4682  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
4683  if (!SWIG_IsOK(ecode4)) {
4684  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4685  }
4686  arg4 = (PLINT)(val4);
4687  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4688  resultobj = SWIG_Py_Void();
4689  return resultobj;
4690 fail:
4691  return NULL;
4692 }
4693 
4694 
4695 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696  PyObject *resultobj = 0;
4697  PLINT arg1 ;
4698  int val1 ;
4699  int ecode1 = 0 ;
4700  PyObject *swig_obj[1] ;
4701 
4702  if (!args) SWIG_fail;
4703  swig_obj[0] = args;
4704  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4705  if (!SWIG_IsOK(ecode1)) {
4706  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4707  }
4708  arg1 = (PLINT)(val1);
4709  pladv(arg1);
4710  resultobj = SWIG_Py_Void();
4711  return resultobj;
4712 fail:
4713  return NULL;
4714 }
4715 
4716 
4717 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4718  PyObject *resultobj = 0;
4719  PLFLT arg1 ;
4720  PLFLT arg2 ;
4721  PLFLT arg3 ;
4722  PLFLT arg4 ;
4723  PLFLT arg5 ;
4724  PLFLT arg6 ;
4725  PLFLT arg7 ;
4726  PLBOOL arg8 ;
4727  double val1 ;
4728  int ecode1 = 0 ;
4729  double val2 ;
4730  int ecode2 = 0 ;
4731  double val3 ;
4732  int ecode3 = 0 ;
4733  double val4 ;
4734  int ecode4 = 0 ;
4735  double val5 ;
4736  int ecode5 = 0 ;
4737  double val6 ;
4738  int ecode6 = 0 ;
4739  double val7 ;
4740  int ecode7 = 0 ;
4741  int val8 ;
4742  int ecode8 = 0 ;
4743  PyObject *swig_obj[8] ;
4744 
4745  if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
4746  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4747  if (!SWIG_IsOK(ecode1)) {
4748  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4749  }
4750  arg1 = (PLFLT)(val1);
4751  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4752  if (!SWIG_IsOK(ecode2)) {
4753  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4754  }
4755  arg2 = (PLFLT)(val2);
4756  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4757  if (!SWIG_IsOK(ecode3)) {
4758  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4759  }
4760  arg3 = (PLFLT)(val3);
4761  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4762  if (!SWIG_IsOK(ecode4)) {
4763  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4764  }
4765  arg4 = (PLFLT)(val4);
4766  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
4767  if (!SWIG_IsOK(ecode5)) {
4768  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4769  }
4770  arg5 = (PLFLT)(val5);
4771  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
4772  if (!SWIG_IsOK(ecode6)) {
4773  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4774  }
4775  arg6 = (PLFLT)(val6);
4776  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4777  if (!SWIG_IsOK(ecode7)) {
4778  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4779  }
4780  arg7 = (PLFLT)(val7);
4781  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4782  if (!SWIG_IsOK(ecode8)) {
4783  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4784  }
4785  arg8 = (PLBOOL)(val8);
4786  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4787  resultobj = SWIG_Py_Void();
4788  return resultobj;
4789 fail:
4790  return NULL;
4791 }
4792 
4793 
4794 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4795  PyObject *resultobj = 0;
4796  PLFLT arg1 ;
4797  PLFLT arg2 ;
4798  char *arg3 = (char *) 0 ;
4799  PLFLT arg4 ;
4800  PLINT arg5 ;
4801  char *arg6 = (char *) 0 ;
4802  PLFLT arg7 ;
4803  PLINT arg8 ;
4804  double val1 ;
4805  int ecode1 = 0 ;
4806  double val2 ;
4807  int ecode2 = 0 ;
4808  int res3 ;
4809  char *buf3 = 0 ;
4810  int alloc3 = 0 ;
4811  double val4 ;
4812  int ecode4 = 0 ;
4813  int val5 ;
4814  int ecode5 = 0 ;
4815  int res6 ;
4816  char *buf6 = 0 ;
4817  int alloc6 = 0 ;
4818  double val7 ;
4819  int ecode7 = 0 ;
4820  int val8 ;
4821  int ecode8 = 0 ;
4822  PyObject *swig_obj[8] ;
4823 
4824  if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
4825  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4826  if (!SWIG_IsOK(ecode1)) {
4827  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
4828  }
4829  arg1 = (PLFLT)(val1);
4830  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4831  if (!SWIG_IsOK(ecode2)) {
4832  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
4833  }
4834  arg2 = (PLFLT)(val2);
4835  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
4836  if (!SWIG_IsOK(res3)) {
4837  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
4838  }
4839  arg3 = (char *)(buf3);
4840  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4841  if (!SWIG_IsOK(ecode4)) {
4842  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
4843  }
4844  arg4 = (PLFLT)(val4);
4845  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
4846  if (!SWIG_IsOK(ecode5)) {
4847  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
4848  }
4849  arg5 = (PLINT)(val5);
4850  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
4851  if (!SWIG_IsOK(res6)) {
4852  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
4853  }
4854  arg6 = (char *)(buf6);
4855  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4856  if (!SWIG_IsOK(ecode7)) {
4857  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
4858  }
4859  arg7 = (PLFLT)(val7);
4860  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4861  if (!SWIG_IsOK(ecode8)) {
4862  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
4863  }
4864  arg8 = (PLINT)(val8);
4865  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4866  resultobj = SWIG_Py_Void();
4867  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4868  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4869  return resultobj;
4870 fail:
4871  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4872  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4873  return NULL;
4874 }
4875 
4876 
4877 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4878  PyObject *resultobj = 0;
4879  PLINT arg1 ;
4880  PLFLT *arg2 = (PLFLT *) 0 ;
4881  PLFLT *arg3 = (PLFLT *) 0 ;
4882  PLINT arg4 ;
4883  PyArrayObject *tmp1 = NULL ;
4884  PyArrayObject *tmp3 = NULL ;
4885  int val4 ;
4886  int ecode4 = 0 ;
4887  PyObject *swig_obj[3] ;
4888 
4889  if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
4890  {
4891  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
4892  if ( tmp1 == NULL )
4893  return NULL;
4894  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
4895  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
4896  }
4897  {
4898  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
4899  if ( tmp3 == NULL )
4900  return NULL;
4901  if ( PyArray_DIMS( tmp3 )[0] != Alen )
4902  {
4903  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
4904  return NULL;
4905  }
4906  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
4907  }
4908  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
4909  if (!SWIG_IsOK(ecode4)) {
4910  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
4911  }
4912  arg4 = (PLINT)(val4);
4913  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4914  resultobj = SWIG_Py_Void();
4915  {
4916  Py_CLEAR( tmp1 );
4917  }
4918  {
4919  Py_CLEAR( tmp3 );
4920  }
4921  return resultobj;
4922 fail:
4923  {
4924  Py_CLEAR( tmp1 );
4925  }
4926  {
4927  Py_CLEAR( tmp3 );
4928  }
4929  return NULL;
4930 }
4931 
4932 
4933 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934  PyObject *resultobj = 0;
4935  PLINT *arg1 = (PLINT *) 0 ;
4936  PLINT *arg2 = (PLINT *) 0 ;
4937  PLINT *arg3 = (PLINT *) 0 ;
4938  PLINT *arg4 = (PLINT *) 0 ;
4939  PLINT *arg5 = (PLINT *) 0 ;
4940  PLFLT *arg6 = (PLFLT *) 0 ;
4941  PLFLT arg7 ;
4942  PLINT temp1 ;
4943  int res1 = SWIG_TMPOBJ ;
4944  PLINT temp2 ;
4945  int res2 = SWIG_TMPOBJ ;
4946  PLINT temp3 ;
4947  int res3 = SWIG_TMPOBJ ;
4948  PLINT temp4 ;
4949  int res4 = SWIG_TMPOBJ ;
4950  PLINT temp5 ;
4951  int res5 = SWIG_TMPOBJ ;
4952  PLFLT temp6 ;
4953  int res6 = SWIG_TMPOBJ ;
4954  double val7 ;
4955  int ecode7 = 0 ;
4956  PyObject *swig_obj[1] ;
4957 
4958  arg1 = &temp1;
4959  arg2 = &temp2;
4960  arg3 = &temp3;
4961  arg4 = &temp4;
4962  arg5 = &temp5;
4963  arg6 = &temp6;
4964  if (!args) SWIG_fail;
4965  swig_obj[0] = args;
4966  ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
4967  if (!SWIG_IsOK(ecode7)) {
4968  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
4969  }
4970  arg7 = (PLFLT)(val7);
4971  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4972  resultobj = SWIG_Py_Void();
4973  if (SWIG_IsTmpObj(res1)) {
4974  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
4975  } else {
4976  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4977  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
4978  }
4979  if (SWIG_IsTmpObj(res2)) {
4980  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
4981  } else {
4982  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4983  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
4984  }
4985  if (SWIG_IsTmpObj(res3)) {
4986  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
4987  } else {
4988  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4989  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
4990  }
4991  if (SWIG_IsTmpObj(res4)) {
4992  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
4993  } else {
4994  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4995  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
4996  }
4997  if (SWIG_IsTmpObj(res5)) {
4998  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
4999  } else {
5000  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5001  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5002  }
5003  if (SWIG_IsTmpObj(res6)) {
5004  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5005  } else {
5006  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5007  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5008  }
5009  return resultobj;
5010 fail:
5011  return NULL;
5012 }
5013 
5014 
5015 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5016  PyObject *resultobj = 0;
5017 
5018  if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5019  plbop();
5020  resultobj = SWIG_Py_Void();
5021  return resultobj;
5022 fail:
5023  return NULL;
5024 }
5025 
5026 
5027 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5028  PyObject *resultobj = 0;
5029  char *arg1 = (char *) 0 ;
5030  PLFLT arg2 ;
5031  PLINT arg3 ;
5032  char *arg4 = (char *) 0 ;
5033  PLFLT arg5 ;
5034  PLINT arg6 ;
5035  int res1 ;
5036  char *buf1 = 0 ;
5037  int alloc1 = 0 ;
5038  double val2 ;
5039  int ecode2 = 0 ;
5040  int val3 ;
5041  int ecode3 = 0 ;
5042  int res4 ;
5043  char *buf4 = 0 ;
5044  int alloc4 = 0 ;
5045  double val5 ;
5046  int ecode5 = 0 ;
5047  int val6 ;
5048  int ecode6 = 0 ;
5049  PyObject *swig_obj[6] ;
5050 
5051  if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5052  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5053  if (!SWIG_IsOK(res1)) {
5054  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5055  }
5056  arg1 = (char *)(buf1);
5057  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5058  if (!SWIG_IsOK(ecode2)) {
5059  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5060  }
5061  arg2 = (PLFLT)(val2);
5062  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5063  if (!SWIG_IsOK(ecode3)) {
5064  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5065  }
5066  arg3 = (PLINT)(val3);
5067  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5068  if (!SWIG_IsOK(res4)) {
5069  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5070  }
5071  arg4 = (char *)(buf4);
5072  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5073  if (!SWIG_IsOK(ecode5)) {
5074  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5075  }
5076  arg5 = (PLFLT)(val5);
5077  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5078  if (!SWIG_IsOK(ecode6)) {
5079  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5080  }
5081  arg6 = (PLINT)(val6);
5082  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5083  resultobj = SWIG_Py_Void();
5084  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5085  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5086  return resultobj;
5087 fail:
5088  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5089  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5090  return NULL;
5091 }
5092 
5093 
5094 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095  PyObject *resultobj = 0;
5096  char *arg1 = (char *) 0 ;
5097  char *arg2 = (char *) 0 ;
5098  PLFLT arg3 ;
5099  PLINT arg4 ;
5100  char *arg5 = (char *) 0 ;
5101  char *arg6 = (char *) 0 ;
5102  PLFLT arg7 ;
5103  PLINT arg8 ;
5104  char *arg9 = (char *) 0 ;
5105  char *arg10 = (char *) 0 ;
5106  PLFLT arg11 ;
5107  PLINT arg12 ;
5108  int res1 ;
5109  char *buf1 = 0 ;
5110  int alloc1 = 0 ;
5111  int res2 ;
5112  char *buf2 = 0 ;
5113  int alloc2 = 0 ;
5114  double val3 ;
5115  int ecode3 = 0 ;
5116  int val4 ;
5117  int ecode4 = 0 ;
5118  int res5 ;
5119  char *buf5 = 0 ;
5120  int alloc5 = 0 ;
5121  int res6 ;
5122  char *buf6 = 0 ;
5123  int alloc6 = 0 ;
5124  double val7 ;
5125  int ecode7 = 0 ;
5126  int val8 ;
5127  int ecode8 = 0 ;
5128  int res9 ;
5129  char *buf9 = 0 ;
5130  int alloc9 = 0 ;
5131  int res10 ;
5132  char *buf10 = 0 ;
5133  int alloc10 = 0 ;
5134  double val11 ;
5135  int ecode11 = 0 ;
5136  int val12 ;
5137  int ecode12 = 0 ;
5138  PyObject *swig_obj[12] ;
5139 
5140  if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5141  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5142  if (!SWIG_IsOK(res1)) {
5143  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5144  }
5145  arg1 = (char *)(buf1);
5146  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5147  if (!SWIG_IsOK(res2)) {
5148  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5149  }
5150  arg2 = (char *)(buf2);
5151  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5152  if (!SWIG_IsOK(ecode3)) {
5153  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5154  }
5155  arg3 = (PLFLT)(val3);
5156  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5157  if (!SWIG_IsOK(ecode4)) {
5158  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5159  }
5160  arg4 = (PLINT)(val4);
5161  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5162  if (!SWIG_IsOK(res5)) {
5163  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5164  }
5165  arg5 = (char *)(buf5);
5166  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5167  if (!SWIG_IsOK(res6)) {
5168  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5169  }
5170  arg6 = (char *)(buf6);
5171  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5172  if (!SWIG_IsOK(ecode7)) {
5173  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5174  }
5175  arg7 = (PLFLT)(val7);
5176  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5177  if (!SWIG_IsOK(ecode8)) {
5178  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5179  }
5180  arg8 = (PLINT)(val8);
5181  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5182  if (!SWIG_IsOK(res9)) {
5183  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5184  }
5185  arg9 = (char *)(buf9);
5186  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5187  if (!SWIG_IsOK(res10)) {
5188  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5189  }
5190  arg10 = (char *)(buf10);
5191  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5192  if (!SWIG_IsOK(ecode11)) {
5193  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5194  }
5195  arg11 = (PLFLT)(val11);
5196  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5197  if (!SWIG_IsOK(ecode12)) {
5198  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5199  }
5200  arg12 = (PLINT)(val12);
5201  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);
5202  resultobj = SWIG_Py_Void();
5203  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5204  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5205  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5206  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5207  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5208  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5209  return resultobj;
5210 fail:
5211  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5212  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5213  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5214  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5215  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5216  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5217  return NULL;
5218 }
5219 
5220 
5221 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5222  PyObject *resultobj = 0;
5223  PLFLT arg1 ;
5224  PLFLT arg2 ;
5225  PLFLT *arg3 = (PLFLT *) 0 ;
5226  PLFLT *arg4 = (PLFLT *) 0 ;
5227  PLINT *arg5 = (PLINT *) 0 ;
5228  double val1 ;
5229  int ecode1 = 0 ;
5230  double val2 ;
5231  int ecode2 = 0 ;
5232  PLFLT temp3 ;
5233  int res3 = SWIG_TMPOBJ ;
5234  PLFLT temp4 ;
5235  int res4 = SWIG_TMPOBJ ;
5236  PLINT temp5 ;
5237  int res5 = SWIG_TMPOBJ ;
5238  PyObject *swig_obj[2] ;
5239 
5240  arg3 = &temp3;
5241  arg4 = &temp4;
5242  arg5 = &temp5;
5243  if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5244  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5245  if (!SWIG_IsOK(ecode1)) {
5246  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5247  }
5248  arg1 = (PLFLT)(val1);
5249  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5250  if (!SWIG_IsOK(ecode2)) {
5251  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5252  }
5253  arg2 = (PLFLT)(val2);
5254  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5255  resultobj = SWIG_Py_Void();
5256  if (SWIG_IsTmpObj(res3)) {
5257  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5258  } else {
5259  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5260  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5261  }
5262  if (SWIG_IsTmpObj(res4)) {
5263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5264  } else {
5265  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5267  }
5268  if (SWIG_IsTmpObj(res5)) {
5269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5270  } else {
5271  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5272  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5273  }
5274  return resultobj;
5275 fail:
5276  return NULL;
5277 }
5278 
5279 
5280 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5281  PyObject *resultobj = 0;
5282 
5283  if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5284  plclear();
5285  resultobj = SWIG_Py_Void();
5286  return resultobj;
5287 fail:
5288  return NULL;
5289 }
5290 
5291 
5292 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293  PyObject *resultobj = 0;
5294  PLINT arg1 ;
5295  int val1 ;
5296  int ecode1 = 0 ;
5297  PyObject *swig_obj[1] ;
5298 
5299  if (!args) SWIG_fail;
5300  swig_obj[0] = args;
5301  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5302  if (!SWIG_IsOK(ecode1)) {
5303  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5304  }
5305  arg1 = (PLINT)(val1);
5306  plcol0(arg1);
5307  resultobj = SWIG_Py_Void();
5308  return resultobj;
5309 fail:
5310  return NULL;
5311 }
5312 
5313 
5314 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5315  PyObject *resultobj = 0;
5316  PLFLT arg1 ;
5317  double val1 ;
5318  int ecode1 = 0 ;
5319  PyObject *swig_obj[1] ;
5320 
5321  if (!args) SWIG_fail;
5322  swig_obj[0] = args;
5323  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5324  if (!SWIG_IsOK(ecode1)) {
5325  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5326  }
5327  arg1 = (PLFLT)(val1);
5328  plcol1(arg1);
5329  resultobj = SWIG_Py_Void();
5330  return resultobj;
5331 fail:
5332  return NULL;
5333 }
5334 
5335 
5336 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337  PyObject *resultobj = 0;
5338  PLFLT arg1 ;
5339  PLFLT arg2 ;
5340  PLFLT arg3 ;
5341  PLINT arg4 ;
5342  PLBOOL arg5 ;
5343  PLINT arg6 ;
5344  PLINT arg7 ;
5345  PLINT arg8 ;
5346  PLINT arg9 ;
5347  PLINT arg10 ;
5348  PLFLT arg11 ;
5349  double val1 ;
5350  int ecode1 = 0 ;
5351  double val2 ;
5352  int ecode2 = 0 ;
5353  double val3 ;
5354  int ecode3 = 0 ;
5355  int val4 ;
5356  int ecode4 = 0 ;
5357  int val5 ;
5358  int ecode5 = 0 ;
5359  int val6 ;
5360  int ecode6 = 0 ;
5361  int val7 ;
5362  int ecode7 = 0 ;
5363  int val8 ;
5364  int ecode8 = 0 ;
5365  int val9 ;
5366  int ecode9 = 0 ;
5367  int val10 ;
5368  int ecode10 = 0 ;
5369  double val11 ;
5370  int ecode11 = 0 ;
5371  PyObject *swig_obj[11] ;
5372 
5373  if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5374  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5375  if (!SWIG_IsOK(ecode1)) {
5376  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5377  }
5378  arg1 = (PLFLT)(val1);
5379  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5380  if (!SWIG_IsOK(ecode2)) {
5381  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5382  }
5383  arg2 = (PLFLT)(val2);
5384  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5385  if (!SWIG_IsOK(ecode3)) {
5386  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5387  }
5388  arg3 = (PLFLT)(val3);
5389  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5390  if (!SWIG_IsOK(ecode4)) {
5391  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5392  }
5393  arg4 = (PLINT)(val4);
5394  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5395  if (!SWIG_IsOK(ecode5)) {
5396  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5397  }
5398  arg5 = (PLBOOL)(val5);
5399  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5400  if (!SWIG_IsOK(ecode6)) {
5401  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5402  }
5403  arg6 = (PLINT)(val6);
5404  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5405  if (!SWIG_IsOK(ecode7)) {
5406  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5407  }
5408  arg7 = (PLINT)(val7);
5409  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5410  if (!SWIG_IsOK(ecode8)) {
5411  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5412  }
5413  arg8 = (PLINT)(val8);
5414  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5415  if (!SWIG_IsOK(ecode9)) {
5416  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5417  }
5418  arg9 = (PLINT)(val9);
5419  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5420  if (!SWIG_IsOK(ecode10)) {
5421  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5422  }
5423  arg10 = (PLINT)(val10);
5424  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5425  if (!SWIG_IsOK(ecode11)) {
5426  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5427  }
5428  arg11 = (PLFLT)(val11);
5429  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5430  resultobj = SWIG_Py_Void();
5431  return resultobj;
5432 fail:
5433  return NULL;
5434 }
5435 
5436 
5437 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5438  PyObject *resultobj = 0;
5439  PLFLT **arg1 = (PLFLT **) 0 ;
5440  PLINT arg2 ;
5441  PLINT arg3 ;
5442  PLINT arg4 ;
5443  PLINT arg5 ;
5444  PLINT arg6 ;
5445  PLINT arg7 ;
5446  PLFLT *arg8 = (PLFLT *) 0 ;
5447  PLINT arg9 ;
5448  pltr_func arg10 = (pltr_func) 0 ;
5449  PLPointer arg11 = (PLPointer) 0 ;
5450  PyArrayObject *tmp1 = NULL ;
5451  int val4 ;
5452  int ecode4 = 0 ;
5453  int val5 ;
5454  int ecode5 = 0 ;
5455  int val6 ;
5456  int ecode6 = 0 ;
5457  int val7 ;
5458  int ecode7 = 0 ;
5459  PyArrayObject *tmp8 = NULL ;
5460  PyObject *swig_obj[8] ;
5461 
5462  {
5463  python_pltr = 0;
5464  arg10 = NULL;
5465  }
5466  {
5467  arg11 = NULL;
5468  }
5469  if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5470  {
5471  int i, size;
5472  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
5473  if ( tmp1 == NULL )
5474  return NULL;
5475  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5476  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5477  size = arg3;
5478  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5479  for ( i = 0; i < arg2; i++ )
5480  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5481  }
5482  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
5483  if (!SWIG_IsOK(ecode4)) {
5484  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5485  }
5486  arg4 = (PLINT)(val4);
5487  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
5488  if (!SWIG_IsOK(ecode5)) {
5489  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5490  }
5491  arg5 = (PLINT)(val5);
5492  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
5493  if (!SWIG_IsOK(ecode6)) {
5494  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5495  }
5496  arg6 = (PLINT)(val6);
5497  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
5498  if (!SWIG_IsOK(ecode7)) {
5499  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5500  }
5501  arg7 = (PLINT)(val7);
5502  {
5503  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
5504  if ( tmp8 == NULL )
5505  return NULL;
5506  arg9 = PyArray_DIMS( tmp8 )[0];
5507  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5508  }
5509  if (swig_obj[6]) {
5510  {
5511  // it must be a callable or None
5512  if ( swig_obj[6] == Py_None )
5513  {
5514  arg10 = NULL;
5515  }
5516  else
5517  {
5518  if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
5519  {
5520  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5521  return NULL;
5522  }
5523  arg10 = marshal_pltr( swig_obj[6] );
5524  }
5525  }
5526  }
5527  if (swig_obj[7]) {
5528  {
5529  if ( swig_obj[7] == Py_None )
5530  arg11 = NULL;
5531  else
5532  {
5533  arg11 = marshal_PLPointer( swig_obj[7], 0 );
5534  }
5535  }
5536  }
5537  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5538  resultobj = SWIG_Py_Void();
5539  {
5540  Py_CLEAR( tmp1 );
5541  free( arg1 );
5542  }
5543  {
5544  Py_CLEAR( tmp8 );
5545  }
5546  {
5547  cleanup_pltr();
5548  }
5549  {
5551  }
5552  return resultobj;
5553 fail:
5554  {
5555  Py_CLEAR( tmp1 );
5556  free( arg1 );
5557  }
5558  {
5559  Py_CLEAR( tmp8 );
5560  }
5561  {
5562  cleanup_pltr();
5563  }
5564  {
5566  }
5567  return NULL;
5568 }
5569 
5570 
5571 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5572  PyObject *resultobj = 0;
5573  PLINT arg1 ;
5574  PLINT arg2 ;
5575  PLINT arg3 ;
5576  PLINT arg4 ;
5577  PLINT arg5 ;
5578  PLFLT arg6 ;
5579  PLFLT *arg7 = (PLFLT *) 0 ;
5580  int val1 ;
5581  int ecode1 = 0 ;
5582  int val2 ;
5583  int ecode2 = 0 ;
5584  int val3 ;
5585  int ecode3 = 0 ;
5586  int val4 ;
5587  int ecode4 = 0 ;
5588  int val5 ;
5589  int ecode5 = 0 ;
5590  double val6 ;
5591  int ecode6 = 0 ;
5592  PLFLT temp7 ;
5593  int res7 = SWIG_TMPOBJ ;
5594  PyObject *swig_obj[6] ;
5595 
5596  arg7 = &temp7;
5597  if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
5598  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5599  if (!SWIG_IsOK(ecode1)) {
5600  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5601  }
5602  arg1 = (PLINT)(val1);
5603  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5604  if (!SWIG_IsOK(ecode2)) {
5605  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5606  }
5607  arg2 = (PLINT)(val2);
5608  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5609  if (!SWIG_IsOK(ecode3)) {
5610  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5611  }
5612  arg3 = (PLINT)(val3);
5613  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5614  if (!SWIG_IsOK(ecode4)) {
5615  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5616  }
5617  arg4 = (PLINT)(val4);
5618  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5619  if (!SWIG_IsOK(ecode5)) {
5620  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5621  }
5622  arg5 = (PLINT)(val5);
5623  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5624  if (!SWIG_IsOK(ecode6)) {
5625  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5626  }
5627  arg6 = (PLFLT)(val6);
5628  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5629  resultobj = SWIG_Py_Void();
5630  if (SWIG_IsTmpObj(res7)) {
5631  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5632  } else {
5633  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5634  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5635  }
5636  return resultobj;
5637 fail:
5638  return NULL;
5639 }
5640 
5641 
5642 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5643  PyObject *resultobj = 0;
5644  PLINT arg1 ;
5645  PLBOOL arg2 ;
5646  int val1 ;
5647  int ecode1 = 0 ;
5648  int val2 ;
5649  int ecode2 = 0 ;
5650  PyObject *swig_obj[2] ;
5651 
5652  if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
5653  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5654  if (!SWIG_IsOK(ecode1)) {
5655  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5656  }
5657  arg1 = (PLINT)(val1);
5658  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5659  if (!SWIG_IsOK(ecode2)) {
5660  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5661  }
5662  arg2 = (PLBOOL)(val2);
5663  plcpstrm(arg1,arg2);
5664  resultobj = SWIG_Py_Void();
5665  return resultobj;
5666 fail:
5667  return NULL;
5668 }
5669 
5670 
5671 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672  PyObject *resultobj = 0;
5673 
5674  if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
5675  plend();
5676  resultobj = SWIG_Py_Void();
5677  return resultobj;
5678 fail:
5679  return NULL;
5680 }
5681 
5682 
5683 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5684  PyObject *resultobj = 0;
5685 
5686  if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
5687  plend1();
5688  resultobj = SWIG_Py_Void();
5689  return resultobj;
5690 fail:
5691  return NULL;
5692 }
5693 
5694 
5695 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696  PyObject *resultobj = 0;
5697  PLFLT arg1 ;
5698  PLFLT arg2 ;
5699  PLFLT arg3 ;
5700  PLFLT arg4 ;
5701  PLINT arg5 ;
5702  PLINT arg6 ;
5703  double val1 ;
5704  int ecode1 = 0 ;
5705  double val2 ;
5706  int ecode2 = 0 ;
5707  double val3 ;
5708  int ecode3 = 0 ;
5709  double val4 ;
5710  int ecode4 = 0 ;
5711  int val5 ;
5712  int ecode5 = 0 ;
5713  int val6 ;
5714  int ecode6 = 0 ;
5715  PyObject *swig_obj[6] ;
5716 
5717  if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
5718  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5719  if (!SWIG_IsOK(ecode1)) {
5720  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5721  }
5722  arg1 = (PLFLT)(val1);
5723  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5724  if (!SWIG_IsOK(ecode2)) {
5725  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5726  }
5727  arg2 = (PLFLT)(val2);
5728  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5729  if (!SWIG_IsOK(ecode3)) {
5730  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5731  }
5732  arg3 = (PLFLT)(val3);
5733  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5734  if (!SWIG_IsOK(ecode4)) {
5735  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5736  }
5737  arg4 = (PLFLT)(val4);
5738  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5739  if (!SWIG_IsOK(ecode5)) {
5740  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5741  }
5742  arg5 = (PLINT)(val5);
5743  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5744  if (!SWIG_IsOK(ecode6)) {
5745  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5746  }
5747  arg6 = (PLINT)(val6);
5748  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5749  resultobj = SWIG_Py_Void();
5750  return resultobj;
5751 fail:
5752  return NULL;
5753 }
5754 
5755 
5756 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5757  PyObject *resultobj = 0;
5758  PLFLT arg1 ;
5759  PLFLT arg2 ;
5760  PLFLT arg3 ;
5761  PLFLT arg4 ;
5762  PLINT arg5 ;
5763  PLINT arg6 ;
5764  double val1 ;
5765  int ecode1 = 0 ;
5766  double val2 ;
5767  int ecode2 = 0 ;
5768  double val3 ;
5769  int ecode3 = 0 ;
5770  double val4 ;
5771  int ecode4 = 0 ;
5772  int val5 ;
5773  int ecode5 = 0 ;
5774  int val6 ;
5775  int ecode6 = 0 ;
5776  PyObject *swig_obj[6] ;
5777 
5778  if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
5779  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5780  if (!SWIG_IsOK(ecode1)) {
5781  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
5782  }
5783  arg1 = (PLFLT)(val1);
5784  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5785  if (!SWIG_IsOK(ecode2)) {
5786  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
5787  }
5788  arg2 = (PLFLT)(val2);
5789  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5790  if (!SWIG_IsOK(ecode3)) {
5791  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
5792  }
5793  arg3 = (PLFLT)(val3);
5794  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5795  if (!SWIG_IsOK(ecode4)) {
5796  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
5797  }
5798  arg4 = (PLFLT)(val4);
5799  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5800  if (!SWIG_IsOK(ecode5)) {
5801  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
5802  }
5803  arg5 = (PLINT)(val5);
5804  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5805  if (!SWIG_IsOK(ecode6)) {
5806  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
5807  }
5808  arg6 = (PLINT)(val6);
5809  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
5810  resultobj = SWIG_Py_Void();
5811  return resultobj;
5812 fail:
5813  return NULL;
5814 }
5815 
5816 
5817 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5818  PyObject *resultobj = 0;
5819 
5820  if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
5821  pleop();
5822  resultobj = SWIG_Py_Void();
5823  return resultobj;
5824 fail:
5825  return NULL;
5826 }
5827 
5828 
5829 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5830  PyObject *resultobj = 0;
5831  PLINT arg1 ;
5832  PLFLT *arg2 = (PLFLT *) 0 ;
5833  PLFLT *arg3 = (PLFLT *) 0 ;
5834  PLFLT *arg4 = (PLFLT *) 0 ;
5835  PyArrayObject *tmp1 = NULL ;
5836  PyArrayObject *tmp3 = NULL ;
5837  PyArrayObject *tmp4 = NULL ;
5838  PyObject *swig_obj[3] ;
5839 
5840  if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
5841  {
5842  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5843  if ( tmp1 == NULL )
5844  return NULL;
5845  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5846  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5847  }
5848  {
5849  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5850  if ( tmp3 == NULL )
5851  return NULL;
5852  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5853  {
5854  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5855  return NULL;
5856  }
5857  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5858  }
5859  {
5860  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5861  if ( tmp4 == NULL )
5862  return NULL;
5863  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5864  {
5865  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5866  return NULL;
5867  }
5868  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5869  }
5870  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5871  resultobj = SWIG_Py_Void();
5872  {
5873  Py_CLEAR( tmp1 );
5874  }
5875  {
5876  Py_CLEAR( tmp3 );
5877  }
5878  {
5879  Py_CLEAR( tmp4 );
5880  }
5881  return resultobj;
5882 fail:
5883  {
5884  Py_CLEAR( tmp1 );
5885  }
5886  {
5887  Py_CLEAR( tmp3 );
5888  }
5889  {
5890  Py_CLEAR( tmp4 );
5891  }
5892  return NULL;
5893 }
5894 
5895 
5896 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5897  PyObject *resultobj = 0;
5898  PLINT arg1 ;
5899  PLFLT *arg2 = (PLFLT *) 0 ;
5900  PLFLT *arg3 = (PLFLT *) 0 ;
5901  PLFLT *arg4 = (PLFLT *) 0 ;
5902  PyArrayObject *tmp1 = NULL ;
5903  PyArrayObject *tmp3 = NULL ;
5904  PyArrayObject *tmp4 = NULL ;
5905  PyObject *swig_obj[3] ;
5906 
5907  if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
5908  {
5909  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5910  if ( tmp1 == NULL )
5911  return NULL;
5912  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5913  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5914  }
5915  {
5916  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5917  if ( tmp3 == NULL )
5918  return NULL;
5919  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5920  {
5921  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5922  return NULL;
5923  }
5924  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5925  }
5926  {
5927  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5928  if ( tmp4 == NULL )
5929  return NULL;
5930  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5931  {
5932  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5933  return NULL;
5934  }
5935  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5936  }
5937  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5938  resultobj = SWIG_Py_Void();
5939  {
5940  Py_CLEAR( tmp1 );
5941  }
5942  {
5943  Py_CLEAR( tmp3 );
5944  }
5945  {
5946  Py_CLEAR( tmp4 );
5947  }
5948  return resultobj;
5949 fail:
5950  {
5951  Py_CLEAR( tmp1 );
5952  }
5953  {
5954  Py_CLEAR( tmp3 );
5955  }
5956  {
5957  Py_CLEAR( tmp4 );
5958  }
5959  return NULL;
5960 }
5961 
5962 
5963 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5964  PyObject *resultobj = 0;
5965 
5966  if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
5967  plfamadv();
5968  resultobj = SWIG_Py_Void();
5969  return resultobj;
5970 fail:
5971  return NULL;
5972 }
5973 
5974 
5975 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5976  PyObject *resultobj = 0;
5977  PLINT arg1 ;
5978  PLFLT *arg2 = (PLFLT *) 0 ;
5979  PLFLT *arg3 = (PLFLT *) 0 ;
5980  PyArrayObject *tmp1 = NULL ;
5981  PyArrayObject *tmp3 = NULL ;
5982  PyObject *swig_obj[2] ;
5983 
5984  if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
5985  {
5986  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5987  if ( tmp1 == NULL )
5988  return NULL;
5989  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5990  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5991  }
5992  {
5993  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5994  if ( tmp3 == NULL )
5995  return NULL;
5996  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5997  {
5998  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5999  return NULL;
6000  }
6001  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6002  }
6003  plfill(arg1,(double const *)arg2,(double const *)arg3);
6004  resultobj = SWIG_Py_Void();
6005  {
6006  Py_CLEAR( tmp1 );
6007  }
6008  {
6009  Py_CLEAR( tmp3 );
6010  }
6011  return resultobj;
6012 fail:
6013  {
6014  Py_CLEAR( tmp1 );
6015  }
6016  {
6017  Py_CLEAR( tmp3 );
6018  }
6019  return NULL;
6020 }
6021 
6022 
6023 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6024  PyObject *resultobj = 0;
6025  PLINT arg1 ;
6026  PLFLT *arg2 = (PLFLT *) 0 ;
6027  PLFLT *arg3 = (PLFLT *) 0 ;
6028  PLFLT *arg4 = (PLFLT *) 0 ;
6029  PyArrayObject *tmp1 = NULL ;
6030  PyArrayObject *tmp3 = NULL ;
6031  PyArrayObject *tmp4 = NULL ;
6032  PyObject *swig_obj[3] ;
6033 
6034  if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6035  {
6036  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6037  if ( tmp1 == NULL )
6038  return NULL;
6039  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6040  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6041  }
6042  {
6043  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6044  if ( tmp3 == NULL )
6045  return NULL;
6046  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6047  {
6048  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6049  return NULL;
6050  }
6051  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6052  }
6053  {
6054  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6055  if ( tmp4 == NULL )
6056  return NULL;
6057  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6058  {
6059  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6060  return NULL;
6061  }
6062  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6063  }
6064  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6065  resultobj = SWIG_Py_Void();
6066  {
6067  Py_CLEAR( tmp1 );
6068  }
6069  {
6070  Py_CLEAR( tmp3 );
6071  }
6072  {
6073  Py_CLEAR( tmp4 );
6074  }
6075  return resultobj;
6076 fail:
6077  {
6078  Py_CLEAR( tmp1 );
6079  }
6080  {
6081  Py_CLEAR( tmp3 );
6082  }
6083  {
6084  Py_CLEAR( tmp4 );
6085  }
6086  return NULL;
6087 }
6088 
6089 
6090 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6091  PyObject *resultobj = 0;
6092  PLINT arg1 ;
6093  PLFLT *arg2 = (PLFLT *) 0 ;
6094  PLFLT *arg3 = (PLFLT *) 0 ;
6095  PLFLT arg4 ;
6096  PyArrayObject *tmp1 = NULL ;
6097  PyArrayObject *tmp3 = NULL ;
6098  double val4 ;
6099  int ecode4 = 0 ;
6100  PyObject *swig_obj[3] ;
6101 
6102  if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6103  {
6104  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6105  if ( tmp1 == NULL )
6106  return NULL;
6107  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6108  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6109  }
6110  {
6111  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6112  if ( tmp3 == NULL )
6113  return NULL;
6114  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6115  {
6116  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6117  return NULL;
6118  }
6119  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6120  }
6121  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6122  if (!SWIG_IsOK(ecode4)) {
6123  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6124  }
6125  arg4 = (PLFLT)(val4);
6126  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6127  resultobj = SWIG_Py_Void();
6128  {
6129  Py_CLEAR( tmp1 );
6130  }
6131  {
6132  Py_CLEAR( tmp3 );
6133  }
6134  return resultobj;
6135 fail:
6136  {
6137  Py_CLEAR( tmp1 );
6138  }
6139  {
6140  Py_CLEAR( tmp3 );
6141  }
6142  return NULL;
6143 }
6144 
6145 
6146 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6147  PyObject *resultobj = 0;
6148 
6149  if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6150  plflush();
6151  resultobj = SWIG_Py_Void();
6152  return resultobj;
6153 fail:
6154  return NULL;
6155 }
6156 
6157 
6158 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159  PyObject *resultobj = 0;
6160  PLINT arg1 ;
6161  int val1 ;
6162  int ecode1 = 0 ;
6163  PyObject *swig_obj[1] ;
6164 
6165  if (!args) SWIG_fail;
6166  swig_obj[0] = args;
6167  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6168  if (!SWIG_IsOK(ecode1)) {
6169  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6170  }
6171  arg1 = (PLINT)(val1);
6172  plfont(arg1);
6173  resultobj = SWIG_Py_Void();
6174  return resultobj;
6175 fail:
6176  return NULL;
6177 }
6178 
6179 
6180 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181  PyObject *resultobj = 0;
6182  PLINT arg1 ;
6183  int val1 ;
6184  int ecode1 = 0 ;
6185  PyObject *swig_obj[1] ;
6186 
6187  if (!args) SWIG_fail;
6188  swig_obj[0] = args;
6189  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6190  if (!SWIG_IsOK(ecode1)) {
6191  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6192  }
6193  arg1 = (PLINT)(val1);
6194  plfontld(arg1);
6195  resultobj = SWIG_Py_Void();
6196  return resultobj;
6197 fail:
6198  return NULL;
6199 }
6200 
6201 
6202 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6203  PyObject *resultobj = 0;
6204  PLFLT *arg1 = (PLFLT *) 0 ;
6205  PLFLT *arg2 = (PLFLT *) 0 ;
6206  PLFLT temp1 ;
6207  int res1 = SWIG_TMPOBJ ;
6208  PLFLT temp2 ;
6209  int res2 = SWIG_TMPOBJ ;
6210 
6211  arg1 = &temp1;
6212  arg2 = &temp2;
6213  if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6214  plgchr(arg1,arg2);
6215  resultobj = SWIG_Py_Void();
6216  if (SWIG_IsTmpObj(res1)) {
6217  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6218  } else {
6219  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6220  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6221  }
6222  if (SWIG_IsTmpObj(res2)) {
6223  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6224  } else {
6225  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6226  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6227  }
6228  return resultobj;
6229 fail:
6230  return NULL;
6231 }
6232 
6233 
6234 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235  PyObject *resultobj = 0;
6236  PLINT arg1 ;
6237  PLINT *arg2 = (PLINT *) 0 ;
6238  PLINT *arg3 = (PLINT *) 0 ;
6239  PLINT *arg4 = (PLINT *) 0 ;
6240  int val1 ;
6241  int ecode1 = 0 ;
6242  PLINT temp2 ;
6243  int res2 = SWIG_TMPOBJ ;
6244  PLINT temp3 ;
6245  int res3 = SWIG_TMPOBJ ;
6246  PLINT temp4 ;
6247  int res4 = SWIG_TMPOBJ ;
6248  PyObject *swig_obj[1] ;
6249 
6250  arg2 = &temp2;
6251  arg3 = &temp3;
6252  arg4 = &temp4;
6253  if (!args) SWIG_fail;
6254  swig_obj[0] = args;
6255  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6256  if (!SWIG_IsOK(ecode1)) {
6257  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6258  }
6259  arg1 = (PLINT)(val1);
6260  plgcol0(arg1,arg2,arg3,arg4);
6261  resultobj = SWIG_Py_Void();
6262  if (SWIG_IsTmpObj(res2)) {
6263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6264  } else {
6265  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6267  }
6268  if (SWIG_IsTmpObj(res3)) {
6269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6270  } else {
6271  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6272  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6273  }
6274  if (SWIG_IsTmpObj(res4)) {
6275  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6276  } else {
6277  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6278  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6279  }
6280  return resultobj;
6281 fail:
6282  return NULL;
6283 }
6284 
6285 
6286 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6287  PyObject *resultobj = 0;
6288  PLINT arg1 ;
6289  PLINT *arg2 = (PLINT *) 0 ;
6290  PLINT *arg3 = (PLINT *) 0 ;
6291  PLINT *arg4 = (PLINT *) 0 ;
6292  PLFLT *arg5 = (PLFLT *) 0 ;
6293  int val1 ;
6294  int ecode1 = 0 ;
6295  PLINT temp2 ;
6296  int res2 = SWIG_TMPOBJ ;
6297  PLINT temp3 ;
6298  int res3 = SWIG_TMPOBJ ;
6299  PLINT temp4 ;
6300  int res4 = SWIG_TMPOBJ ;
6301  PLFLT temp5 ;
6302  int res5 = SWIG_TMPOBJ ;
6303  PyObject *swig_obj[1] ;
6304 
6305  arg2 = &temp2;
6306  arg3 = &temp3;
6307  arg4 = &temp4;
6308  arg5 = &temp5;
6309  if (!args) SWIG_fail;
6310  swig_obj[0] = args;
6311  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6312  if (!SWIG_IsOK(ecode1)) {
6313  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6314  }
6315  arg1 = (PLINT)(val1);
6316  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6317  resultobj = SWIG_Py_Void();
6318  if (SWIG_IsTmpObj(res2)) {
6319  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6320  } else {
6321  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6322  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6323  }
6324  if (SWIG_IsTmpObj(res3)) {
6325  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6326  } else {
6327  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6328  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6329  }
6330  if (SWIG_IsTmpObj(res4)) {
6331  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6332  } else {
6333  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6334  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6335  }
6336  if (SWIG_IsTmpObj(res5)) {
6337  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6338  } else {
6339  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6340  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6341  }
6342  return resultobj;
6343 fail:
6344  return NULL;
6345 }
6346 
6347 
6348 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6349  PyObject *resultobj = 0;
6350  PLINT *arg1 = (PLINT *) 0 ;
6351  PLINT *arg2 = (PLINT *) 0 ;
6352  PLINT *arg3 = (PLINT *) 0 ;
6353  PLINT temp1 ;
6354  int res1 = SWIG_TMPOBJ ;
6355  PLINT temp2 ;
6356  int res2 = SWIG_TMPOBJ ;
6357  PLINT temp3 ;
6358  int res3 = SWIG_TMPOBJ ;
6359 
6360  arg1 = &temp1;
6361  arg2 = &temp2;
6362  arg3 = &temp3;
6363  if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6364  plgcolbg(arg1,arg2,arg3);
6365  resultobj = SWIG_Py_Void();
6366  if (SWIG_IsTmpObj(res1)) {
6367  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6368  } else {
6369  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6370  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6371  }
6372  if (SWIG_IsTmpObj(res2)) {
6373  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6374  } else {
6375  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6376  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6377  }
6378  if (SWIG_IsTmpObj(res3)) {
6379  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6380  } else {
6381  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6382  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6383  }
6384  return resultobj;
6385 fail:
6386  return NULL;
6387 }
6388 
6389 
6390 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6391  PyObject *resultobj = 0;
6392  PLINT *arg1 = (PLINT *) 0 ;
6393  PLINT *arg2 = (PLINT *) 0 ;
6394  PLINT *arg3 = (PLINT *) 0 ;
6395  PLFLT *arg4 = (PLFLT *) 0 ;
6396  PLINT temp1 ;
6397  int res1 = SWIG_TMPOBJ ;
6398  PLINT temp2 ;
6399  int res2 = SWIG_TMPOBJ ;
6400  PLINT temp3 ;
6401  int res3 = SWIG_TMPOBJ ;
6402  PLFLT temp4 ;
6403  int res4 = SWIG_TMPOBJ ;
6404 
6405  arg1 = &temp1;
6406  arg2 = &temp2;
6407  arg3 = &temp3;
6408  arg4 = &temp4;
6409  if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6410  plgcolbga(arg1,arg2,arg3,arg4);
6411  resultobj = SWIG_Py_Void();
6412  if (SWIG_IsTmpObj(res1)) {
6413  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6414  } else {
6415  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6416  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6417  }
6418  if (SWIG_IsTmpObj(res2)) {
6419  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6420  } else {
6421  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6422  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6423  }
6424  if (SWIG_IsTmpObj(res3)) {
6425  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6426  } else {
6427  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6428  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6429  }
6430  if (SWIG_IsTmpObj(res4)) {
6431  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6432  } else {
6433  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6434  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6435  }
6436  return resultobj;
6437 fail:
6438  return NULL;
6439 }
6440 
6441 
6442 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6443  PyObject *resultobj = 0;
6444  PLINT *arg1 = (PLINT *) 0 ;
6445  PLINT temp1 ;
6446  int res1 = SWIG_TMPOBJ ;
6447 
6448  arg1 = &temp1;
6449  if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
6450  plgcompression(arg1);
6451  resultobj = SWIG_Py_Void();
6452  if (SWIG_IsTmpObj(res1)) {
6453  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6454  } else {
6455  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6456  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6457  }
6458  return resultobj;
6459 fail:
6460  return NULL;
6461 }
6462 
6463 
6464 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6465  PyObject *resultobj = 0;
6466  char *arg1 = (char *) 0 ;
6467  char buff1[1000] ;
6468 
6469  {
6470  arg1 = buff1;
6471  }
6472  if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
6473  plgdev(arg1);
6474  resultobj = SWIG_Py_Void();
6475  {
6476  PyObject *o = PyString_FromString( arg1 );
6477  resultobj = t_output_helper( resultobj, o );
6478  }
6479  return resultobj;
6480 fail:
6481  return NULL;
6482 }
6483 
6484 
6485 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6486  PyObject *resultobj = 0;
6487  PLFLT *arg1 = (PLFLT *) 0 ;
6488  PLFLT *arg2 = (PLFLT *) 0 ;
6489  PLFLT *arg3 = (PLFLT *) 0 ;
6490  PLFLT *arg4 = (PLFLT *) 0 ;
6491  PLFLT temp1 ;
6492  int res1 = SWIG_TMPOBJ ;
6493  PLFLT temp2 ;
6494  int res2 = SWIG_TMPOBJ ;
6495  PLFLT temp3 ;
6496  int res3 = SWIG_TMPOBJ ;
6497  PLFLT temp4 ;
6498  int res4 = SWIG_TMPOBJ ;
6499 
6500  arg1 = &temp1;
6501  arg2 = &temp2;
6502  arg3 = &temp3;
6503  arg4 = &temp4;
6504  if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
6505  plgdidev(arg1,arg2,arg3,arg4);
6506  resultobj = SWIG_Py_Void();
6507  if (SWIG_IsTmpObj(res1)) {
6508  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6509  } else {
6510  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6511  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6512  }
6513  if (SWIG_IsTmpObj(res2)) {
6514  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6515  } else {
6516  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6517  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6518  }
6519  if (SWIG_IsTmpObj(res3)) {
6520  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6521  } else {
6522  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6523  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6524  }
6525  if (SWIG_IsTmpObj(res4)) {
6526  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6527  } else {
6528  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6529  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6530  }
6531  return resultobj;
6532 fail:
6533  return NULL;
6534 }
6535 
6536 
6537 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6538  PyObject *resultobj = 0;
6539  PLFLT *arg1 = (PLFLT *) 0 ;
6540  PLFLT temp1 ;
6541  int res1 = SWIG_TMPOBJ ;
6542 
6543  arg1 = &temp1;
6544  if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
6545  plgdiori(arg1);
6546  resultobj = SWIG_Py_Void();
6547  if (SWIG_IsTmpObj(res1)) {
6548  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6549  } else {
6550  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6551  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6552  }
6553  return resultobj;
6554 fail:
6555  return NULL;
6556 }
6557 
6558 
6559 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6560  PyObject *resultobj = 0;
6561  PLFLT *arg1 = (PLFLT *) 0 ;
6562  PLFLT *arg2 = (PLFLT *) 0 ;
6563  PLFLT *arg3 = (PLFLT *) 0 ;
6564  PLFLT *arg4 = (PLFLT *) 0 ;
6565  PLFLT temp1 ;
6566  int res1 = SWIG_TMPOBJ ;
6567  PLFLT temp2 ;
6568  int res2 = SWIG_TMPOBJ ;
6569  PLFLT temp3 ;
6570  int res3 = SWIG_TMPOBJ ;
6571  PLFLT temp4 ;
6572  int res4 = SWIG_TMPOBJ ;
6573 
6574  arg1 = &temp1;
6575  arg2 = &temp2;
6576  arg3 = &temp3;
6577  arg4 = &temp4;
6578  if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
6579  plgdiplt(arg1,arg2,arg3,arg4);
6580  resultobj = SWIG_Py_Void();
6581  if (SWIG_IsTmpObj(res1)) {
6582  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6583  } else {
6584  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6585  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6586  }
6587  if (SWIG_IsTmpObj(res2)) {
6588  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6589  } else {
6590  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6591  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6592  }
6593  if (SWIG_IsTmpObj(res3)) {
6594  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6595  } else {
6596  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6597  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6598  }
6599  if (SWIG_IsTmpObj(res4)) {
6600  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6601  } else {
6602  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6603  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6604  }
6605  return resultobj;
6606 fail:
6607  return NULL;
6608 }
6609 
6610 
6611 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6612  PyObject *resultobj = 0;
6613  PLINT *arg1 = (PLINT *) 0 ;
6614  PLINT *arg2 = (PLINT *) 0 ;
6615  PLINT *arg3 = (PLINT *) 0 ;
6616  PLINT temp1 ;
6617  int res1 = SWIG_TMPOBJ ;
6618  PLINT temp2 ;
6619  int res2 = SWIG_TMPOBJ ;
6620  PLINT temp3 ;
6621  int res3 = SWIG_TMPOBJ ;
6622 
6623  arg1 = &temp1;
6624  arg2 = &temp2;
6625  arg3 = &temp3;
6626  if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
6627  plgfam(arg1,arg2,arg3);
6628  resultobj = SWIG_Py_Void();
6629  if (SWIG_IsTmpObj(res1)) {
6630  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6631  } else {
6632  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6633  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6634  }
6635  if (SWIG_IsTmpObj(res2)) {
6636  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6637  } else {
6638  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6639  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6640  }
6641  if (SWIG_IsTmpObj(res3)) {
6642  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6643  } else {
6644  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6645  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6646  }
6647  return resultobj;
6648 fail:
6649  return NULL;
6650 }
6651 
6652 
6653 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6654  PyObject *resultobj = 0;
6655  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6656  PLUNICODE temp1 ;
6657  int res1 = SWIG_TMPOBJ ;
6658 
6659  arg1 = &temp1;
6660  if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
6661  plgfci(arg1);
6662  resultobj = SWIG_Py_Void();
6663  if (SWIG_IsTmpObj(res1)) {
6664  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6665  } else {
6666  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6667  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6668  }
6669  return resultobj;
6670 fail:
6671  return NULL;
6672 }
6673 
6674 
6675 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6676  PyObject *resultobj = 0;
6677  char *arg1 = (char *) 0 ;
6678  char buff1[1000] ;
6679 
6680  {
6681  arg1 = buff1;
6682  }
6683  if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
6684  plgfnam(arg1);
6685  resultobj = SWIG_Py_Void();
6686  {
6687  PyObject *o = PyString_FromString( arg1 );
6688  resultobj = t_output_helper( resultobj, o );
6689  }
6690  return resultobj;
6691 fail:
6692  return NULL;
6693 }
6694 
6695 
6696 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697  PyObject *resultobj = 0;
6698  PLINT *arg1 = (PLINT *) 0 ;
6699  PLINT *arg2 = (PLINT *) 0 ;
6700  PLINT *arg3 = (PLINT *) 0 ;
6701  PLINT temp1 ;
6702  int res1 = SWIG_TMPOBJ ;
6703  PLINT temp2 ;
6704  int res2 = SWIG_TMPOBJ ;
6705  PLINT temp3 ;
6706  int res3 = SWIG_TMPOBJ ;
6707 
6708  arg1 = &temp1;
6709  arg2 = &temp2;
6710  arg3 = &temp3;
6711  if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
6712  plgfont(arg1,arg2,arg3);
6713  resultobj = SWIG_Py_Void();
6714  if (SWIG_IsTmpObj(res1)) {
6715  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6716  } else {
6717  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6718  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6719  }
6720  if (SWIG_IsTmpObj(res2)) {
6721  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6722  } else {
6723  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6724  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6725  }
6726  if (SWIG_IsTmpObj(res3)) {
6727  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6728  } else {
6729  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6730  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6731  }
6732  return resultobj;
6733 fail:
6734  return NULL;
6735 }
6736 
6737 
6738 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6739  PyObject *resultobj = 0;
6740  PLINT *arg1 = (PLINT *) 0 ;
6741  PLINT temp1 ;
6742  int res1 = SWIG_TMPOBJ ;
6743 
6744  arg1 = &temp1;
6745  if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
6746  plglevel(arg1);
6747  resultobj = SWIG_Py_Void();
6748  if (SWIG_IsTmpObj(res1)) {
6749  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6750  } else {
6751  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6752  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6753  }
6754  return resultobj;
6755 fail:
6756  return NULL;
6757 }
6758 
6759 
6760 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761  PyObject *resultobj = 0;
6762  PLFLT *arg1 = (PLFLT *) 0 ;
6763  PLFLT *arg2 = (PLFLT *) 0 ;
6764  PLINT *arg3 = (PLINT *) 0 ;
6765  PLINT *arg4 = (PLINT *) 0 ;
6766  PLINT *arg5 = (PLINT *) 0 ;
6767  PLINT *arg6 = (PLINT *) 0 ;
6768  PLFLT temp1 ;
6769  int res1 = SWIG_TMPOBJ ;
6770  PLFLT temp2 ;
6771  int res2 = SWIG_TMPOBJ ;
6772  PLINT temp3 ;
6773  int res3 = SWIG_TMPOBJ ;
6774  PLINT temp4 ;
6775  int res4 = SWIG_TMPOBJ ;
6776  PLINT temp5 ;
6777  int res5 = SWIG_TMPOBJ ;
6778  PLINT temp6 ;
6779  int res6 = SWIG_TMPOBJ ;
6780 
6781  arg1 = &temp1;
6782  arg2 = &temp2;
6783  arg3 = &temp3;
6784  arg4 = &temp4;
6785  arg5 = &temp5;
6786  arg6 = &temp6;
6787  if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
6788  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
6789  resultobj = SWIG_Py_Void();
6790  if (SWIG_IsTmpObj(res1)) {
6791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6792  } else {
6793  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6794  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6795  }
6796  if (SWIG_IsTmpObj(res2)) {
6797  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6798  } else {
6799  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6800  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6801  }
6802  if (SWIG_IsTmpObj(res3)) {
6803  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6804  } else {
6805  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6806  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6807  }
6808  if (SWIG_IsTmpObj(res4)) {
6809  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6810  } else {
6811  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6812  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6813  }
6814  if (SWIG_IsTmpObj(res5)) {
6815  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
6816  } else {
6817  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6818  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
6819  }
6820  if (SWIG_IsTmpObj(res6)) {
6821  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
6822  } else {
6823  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6824  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
6825  }
6826  return resultobj;
6827 fail:
6828  return NULL;
6829 }
6830 
6831 
6832 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6833  PyObject *resultobj = 0;
6834 
6835  if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
6836  plgra();
6837  resultobj = SWIG_Py_Void();
6838  return resultobj;
6839 fail:
6840  return NULL;
6841 }
6842 
6843 
6844 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845  PyObject *resultobj = 0;
6846  PLFLT *arg1 = (PLFLT *) 0 ;
6847  PLFLT *arg2 = (PLFLT *) 0 ;
6848  PLFLT *arg3 = (PLFLT *) 0 ;
6849  PLINT arg4 ;
6850  PLFLT *arg5 = (PLFLT *) 0 ;
6851  PLINT arg6 ;
6852  PLFLT *arg7 = (PLFLT *) 0 ;
6853  PLINT arg8 ;
6854  PLFLT **arg9 = (PLFLT **) 0 ;
6855  PLINT arg10 ;
6856  PLFLT arg11 ;
6857  PyArrayObject *tmp1 = NULL ;
6858  PyArrayObject *tmp2 = NULL ;
6859  PyArrayObject *tmp3 = NULL ;
6860  PyArrayObject *tmp5 = NULL ;
6861  PyArrayObject *tmp7 = NULL ;
6862  PyObject *array7 = NULL ;
6863  int val10 ;
6864  int ecode10 = 0 ;
6865  double val11 ;
6866  int ecode11 = 0 ;
6867  PyObject *swig_obj[7] ;
6868 
6869  if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
6870  {
6871  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6872  if ( tmp1 == NULL )
6873  return NULL;
6874  Alen = PyArray_DIMS( tmp1 )[0];
6875  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
6876  }
6877  {
6878  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6879  if ( tmp2 == NULL )
6880  return NULL;
6881  if ( PyArray_DIMS( tmp2 )[0] != Alen )
6882  {
6883  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6884  return NULL;
6885  }
6886  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
6887  }
6888  {
6889  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6890  if ( tmp3 == NULL )
6891  return NULL;
6892  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6893  {
6894  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6895  return NULL;
6896  }
6897  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6898  arg4 = PyArray_DIMS( tmp3 )[0];
6899  }
6900  {
6901  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
6902  if ( tmp5 == NULL )
6903  return NULL;
6904  Xlen = PyArray_DIMS( tmp5 )[0];
6905  arg6 = Xlen;
6906  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
6907  }
6908  {
6909  int i, size;
6910  npy_intp dims[2];
6911  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
6912  if ( tmp7 == NULL )
6913  return NULL;
6914  Ylen = PyArray_DIMS( tmp7 )[0];
6915  arg8 = Ylen;
6916  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
6917  // Make created 2D array7 have dimensions from prior ArrayX in the argument
6918  // list and this ArrayY.
6919  dims[0] = Xlen;
6920  dims[1] = Ylen;
6921  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
6922  if ( !array7 )
6923  return NULL;
6924  size = Ylen;
6925  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
6926  for ( i = 0; i < Xlen; i++ )
6927  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
6928  }
6929  ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
6930  if (!SWIG_IsOK(ecode10)) {
6931  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
6932  }
6933  arg10 = (PLINT)(val10);
6934  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
6935  if (!SWIG_IsOK(ecode11)) {
6936  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
6937  }
6938  arg11 = (PLFLT)(val11);
6939  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
6940  resultobj = SWIG_Py_Void();
6941  {
6942  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
6943  }
6944  {
6945  Py_CLEAR( tmp1 );
6946  }
6947  {
6948  Py_CLEAR( tmp2 );
6949  }
6950  {
6951  Py_CLEAR( tmp3 );
6952  }
6953  {
6954  Py_CLEAR( tmp5 );
6955  }
6956  {
6957  Py_CLEAR( tmp7 );
6958  free( arg9 );
6959  }
6960  return resultobj;
6961 fail:
6962  {
6963  Py_CLEAR( tmp1 );
6964  }
6965  {
6966  Py_CLEAR( tmp2 );
6967  }
6968  {
6969  Py_CLEAR( tmp3 );
6970  }
6971  {
6972  Py_CLEAR( tmp5 );
6973  }
6974  {
6975  Py_CLEAR( tmp7 );
6976  free( arg9 );
6977  }
6978  return NULL;
6979 }
6980 
6981 
6982 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6983  PyObject *resultobj = 0;
6984  PLFLT *arg1 = (PLFLT *) 0 ;
6985  PLFLT *arg2 = (PLFLT *) 0 ;
6986  PLFLT *arg3 = (PLFLT *) 0 ;
6987  PLFLT *arg4 = (PLFLT *) 0 ;
6988  PLFLT temp1 ;
6989  int res1 = SWIG_TMPOBJ ;
6990  PLFLT temp2 ;
6991  int res2 = SWIG_TMPOBJ ;
6992  PLFLT temp3 ;
6993  int res3 = SWIG_TMPOBJ ;
6994  PLFLT temp4 ;
6995  int res4 = SWIG_TMPOBJ ;
6996 
6997  arg1 = &temp1;
6998  arg2 = &temp2;
6999  arg3 = &temp3;
7000  arg4 = &temp4;
7001  if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7002  plgspa(arg1,arg2,arg3,arg4);
7003  resultobj = SWIG_Py_Void();
7004  if (SWIG_IsTmpObj(res1)) {
7005  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7006  } else {
7007  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7008  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7009  }
7010  if (SWIG_IsTmpObj(res2)) {
7011  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7012  } else {
7013  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7015  }
7016  if (SWIG_IsTmpObj(res3)) {
7017  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7018  } else {
7019  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7020  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7021  }
7022  if (SWIG_IsTmpObj(res4)) {
7023  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7024  } else {
7025  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7026  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7027  }
7028  return resultobj;
7029 fail:
7030  return NULL;
7031 }
7032 
7033 
7034 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035  PyObject *resultobj = 0;
7036  PLINT *arg1 = (PLINT *) 0 ;
7037  PLINT temp1 ;
7038  int res1 = SWIG_TMPOBJ ;
7039 
7040  arg1 = &temp1;
7041  if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7042  plgstrm(arg1);
7043  resultobj = SWIG_Py_Void();
7044  if (SWIG_IsTmpObj(res1)) {
7045  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7046  } else {
7047  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7048  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7049  }
7050  return resultobj;
7051 fail:
7052  return NULL;
7053 }
7054 
7055 
7056 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7057  PyObject *resultobj = 0;
7058  char *arg1 = (char *) 0 ;
7059  char buff1[1000] ;
7060 
7061  {
7062  arg1 = buff1;
7063  }
7064  if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7065  plgver(arg1);
7066  resultobj = SWIG_Py_Void();
7067  {
7068  PyObject *o = PyString_FromString( arg1 );
7069  resultobj = t_output_helper( resultobj, o );
7070  }
7071  return resultobj;
7072 fail:
7073  return NULL;
7074 }
7075 
7076 
7077 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7078  PyObject *resultobj = 0;
7079  PLFLT *arg1 = (PLFLT *) 0 ;
7080  PLFLT *arg2 = (PLFLT *) 0 ;
7081  PLFLT *arg3 = (PLFLT *) 0 ;
7082  PLFLT *arg4 = (PLFLT *) 0 ;
7083  PLFLT temp1 ;
7084  int res1 = SWIG_TMPOBJ ;
7085  PLFLT temp2 ;
7086  int res2 = SWIG_TMPOBJ ;
7087  PLFLT temp3 ;
7088  int res3 = SWIG_TMPOBJ ;
7089  PLFLT temp4 ;
7090  int res4 = SWIG_TMPOBJ ;
7091 
7092  arg1 = &temp1;
7093  arg2 = &temp2;
7094  arg3 = &temp3;
7095  arg4 = &temp4;
7096  if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7097  plgvpd(arg1,arg2,arg3,arg4);
7098  resultobj = SWIG_Py_Void();
7099  if (SWIG_IsTmpObj(res1)) {
7100  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7101  } else {
7102  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7103  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7104  }
7105  if (SWIG_IsTmpObj(res2)) {
7106  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7107  } else {
7108  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7109  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7110  }
7111  if (SWIG_IsTmpObj(res3)) {
7112  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7113  } else {
7114  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7115  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7116  }
7117  if (SWIG_IsTmpObj(res4)) {
7118  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7119  } else {
7120  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7121  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7122  }
7123  return resultobj;
7124 fail:
7125  return NULL;
7126 }
7127 
7128 
7129 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7130  PyObject *resultobj = 0;
7131  PLFLT *arg1 = (PLFLT *) 0 ;
7132  PLFLT *arg2 = (PLFLT *) 0 ;
7133  PLFLT *arg3 = (PLFLT *) 0 ;
7134  PLFLT *arg4 = (PLFLT *) 0 ;
7135  PLFLT temp1 ;
7136  int res1 = SWIG_TMPOBJ ;
7137  PLFLT temp2 ;
7138  int res2 = SWIG_TMPOBJ ;
7139  PLFLT temp3 ;
7140  int res3 = SWIG_TMPOBJ ;
7141  PLFLT temp4 ;
7142  int res4 = SWIG_TMPOBJ ;
7143 
7144  arg1 = &temp1;
7145  arg2 = &temp2;
7146  arg3 = &temp3;
7147  arg4 = &temp4;
7148  if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7149  plgvpw(arg1,arg2,arg3,arg4);
7150  resultobj = SWIG_Py_Void();
7151  if (SWIG_IsTmpObj(res1)) {
7152  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7153  } else {
7154  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7155  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7156  }
7157  if (SWIG_IsTmpObj(res2)) {
7158  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7159  } else {
7160  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7161  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7162  }
7163  if (SWIG_IsTmpObj(res3)) {
7164  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7165  } else {
7166  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7167  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7168  }
7169  if (SWIG_IsTmpObj(res4)) {
7170  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7171  } else {
7172  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7173  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7174  }
7175  return resultobj;
7176 fail:
7177  return NULL;
7178 }
7179 
7180 
7181 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7182  PyObject *resultobj = 0;
7183  PLINT *arg1 = (PLINT *) 0 ;
7184  PLINT *arg2 = (PLINT *) 0 ;
7185  PLINT temp1 ;
7186  int res1 = SWIG_TMPOBJ ;
7187  PLINT temp2 ;
7188  int res2 = SWIG_TMPOBJ ;
7189 
7190  arg1 = &temp1;
7191  arg2 = &temp2;
7192  if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7193  plgxax(arg1,arg2);
7194  resultobj = SWIG_Py_Void();
7195  if (SWIG_IsTmpObj(res1)) {
7196  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7197  } else {
7198  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7199  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7200  }
7201  if (SWIG_IsTmpObj(res2)) {
7202  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7203  } else {
7204  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7205  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7206  }
7207  return resultobj;
7208 fail:
7209  return NULL;
7210 }
7211 
7212 
7213 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7214  PyObject *resultobj = 0;
7215  PLINT *arg1 = (PLINT *) 0 ;
7216  PLINT *arg2 = (PLINT *) 0 ;
7217  PLINT temp1 ;
7218  int res1 = SWIG_TMPOBJ ;
7219  PLINT temp2 ;
7220  int res2 = SWIG_TMPOBJ ;
7221 
7222  arg1 = &temp1;
7223  arg2 = &temp2;
7224  if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7225  plgyax(arg1,arg2);
7226  resultobj = SWIG_Py_Void();
7227  if (SWIG_IsTmpObj(res1)) {
7228  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7229  } else {
7230  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7231  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7232  }
7233  if (SWIG_IsTmpObj(res2)) {
7234  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7235  } else {
7236  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7237  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7238  }
7239  return resultobj;
7240 fail:
7241  return NULL;
7242 }
7243 
7244 
7245 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7246  PyObject *resultobj = 0;
7247  PLINT *arg1 = (PLINT *) 0 ;
7248  PLINT *arg2 = (PLINT *) 0 ;
7249  PLINT temp1 ;
7250  int res1 = SWIG_TMPOBJ ;
7251  PLINT temp2 ;
7252  int res2 = SWIG_TMPOBJ ;
7253 
7254  arg1 = &temp1;
7255  arg2 = &temp2;
7256  if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7257  plgzax(arg1,arg2);
7258  resultobj = SWIG_Py_Void();
7259  if (SWIG_IsTmpObj(res1)) {
7260  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7261  } else {
7262  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7263  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7264  }
7265  if (SWIG_IsTmpObj(res2)) {
7266  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7267  } else {
7268  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7269  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7270  }
7271  return resultobj;
7272 fail:
7273  return NULL;
7274 }
7275 
7276 
7277 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7278  PyObject *resultobj = 0;
7279  PLINT arg1 ;
7280  PLFLT *arg2 = (PLFLT *) 0 ;
7281  PLFLT arg3 ;
7282  PLFLT arg4 ;
7283  PLINT arg5 ;
7284  PLINT arg6 ;
7285  PyArrayObject *tmp1 = NULL ;
7286  double val3 ;
7287  int ecode3 = 0 ;
7288  double val4 ;
7289  int ecode4 = 0 ;
7290  int val5 ;
7291  int ecode5 = 0 ;
7292  int val6 ;
7293  int ecode6 = 0 ;
7294  PyObject *swig_obj[5] ;
7295 
7296  if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7297  {
7298  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7299  if ( tmp1 == NULL )
7300  return NULL;
7301  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7302  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7303  }
7304  ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7305  if (!SWIG_IsOK(ecode3)) {
7306  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7307  }
7308  arg3 = (PLFLT)(val3);
7309  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7310  if (!SWIG_IsOK(ecode4)) {
7311  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7312  }
7313  arg4 = (PLFLT)(val4);
7314  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7315  if (!SWIG_IsOK(ecode5)) {
7316  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7317  }
7318  arg5 = (PLINT)(val5);
7319  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7320  if (!SWIG_IsOK(ecode6)) {
7321  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7322  }
7323  arg6 = (PLINT)(val6);
7324  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7325  resultobj = SWIG_Py_Void();
7326  {
7327  Py_CLEAR( tmp1 );
7328  }
7329  return resultobj;
7330 fail:
7331  {
7332  Py_CLEAR( tmp1 );
7333  }
7334  return NULL;
7335 }
7336 
7337 
7338 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7339  PyObject *resultobj = 0;
7340  PLFLT arg1 ;
7341  PLFLT arg2 ;
7342  PLFLT arg3 ;
7343  PLFLT *arg4 = (PLFLT *) 0 ;
7344  PLFLT *arg5 = (PLFLT *) 0 ;
7345  PLFLT *arg6 = (PLFLT *) 0 ;
7346  double val1 ;
7347  int ecode1 = 0 ;
7348  double val2 ;
7349  int ecode2 = 0 ;
7350  double val3 ;
7351  int ecode3 = 0 ;
7352  PLFLT temp4 ;
7353  int res4 = SWIG_TMPOBJ ;
7354  PLFLT temp5 ;
7355  int res5 = SWIG_TMPOBJ ;
7356  PLFLT temp6 ;
7357  int res6 = SWIG_TMPOBJ ;
7358  PyObject *swig_obj[3] ;
7359 
7360  arg4 = &temp4;
7361  arg5 = &temp5;
7362  arg6 = &temp6;
7363  if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7364  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7365  if (!SWIG_IsOK(ecode1)) {
7366  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7367  }
7368  arg1 = (PLFLT)(val1);
7369  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7370  if (!SWIG_IsOK(ecode2)) {
7371  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7372  }
7373  arg2 = (PLFLT)(val2);
7374  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7375  if (!SWIG_IsOK(ecode3)) {
7376  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7377  }
7378  arg3 = (PLFLT)(val3);
7379  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7380  resultobj = SWIG_Py_Void();
7381  if (SWIG_IsTmpObj(res4)) {
7382  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7383  } else {
7384  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7385  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7386  }
7387  if (SWIG_IsTmpObj(res5)) {
7388  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7389  } else {
7390  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7391  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7392  }
7393  if (SWIG_IsTmpObj(res6)) {
7394  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7395  } else {
7396  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7397  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7398  }
7399  return resultobj;
7400 fail:
7401  return NULL;
7402 }
7403 
7404 
7405 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7406  PyObject *resultobj = 0;
7407 
7408  if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7409  plinit();
7410  resultobj = SWIG_Py_Void();
7411  return resultobj;
7412 fail:
7413  return NULL;
7414 }
7415 
7416 
7417 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7418  PyObject *resultobj = 0;
7419  PLFLT arg1 ;
7420  PLFLT arg2 ;
7421  PLFLT arg3 ;
7422  PLFLT arg4 ;
7423  double val1 ;
7424  int ecode1 = 0 ;
7425  double val2 ;
7426  int ecode2 = 0 ;
7427  double val3 ;
7428  int ecode3 = 0 ;
7429  double val4 ;
7430  int ecode4 = 0 ;
7431  PyObject *swig_obj[4] ;
7432 
7433  if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
7434  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7435  if (!SWIG_IsOK(ecode1)) {
7436  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7437  }
7438  arg1 = (PLFLT)(val1);
7439  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7440  if (!SWIG_IsOK(ecode2)) {
7441  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7442  }
7443  arg2 = (PLFLT)(val2);
7444  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7445  if (!SWIG_IsOK(ecode3)) {
7446  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7447  }
7448  arg3 = (PLFLT)(val3);
7449  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
7450  if (!SWIG_IsOK(ecode4)) {
7451  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7452  }
7453  arg4 = (PLFLT)(val4);
7454  pljoin(arg1,arg2,arg3,arg4);
7455  resultobj = SWIG_Py_Void();
7456  return resultobj;
7457 fail:
7458  return NULL;
7459 }
7460 
7461 
7462 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7463  PyObject *resultobj = 0;
7464  char *arg1 = (char *) 0 ;
7465  char *arg2 = (char *) 0 ;
7466  char *arg3 = (char *) 0 ;
7467  int res1 ;
7468  char *buf1 = 0 ;
7469  int alloc1 = 0 ;
7470  int res2 ;
7471  char *buf2 = 0 ;
7472  int alloc2 = 0 ;
7473  int res3 ;
7474  char *buf3 = 0 ;
7475  int alloc3 = 0 ;
7476  PyObject *swig_obj[3] ;
7477 
7478  if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
7479  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7480  if (!SWIG_IsOK(res1)) {
7481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7482  }
7483  arg1 = (char *)(buf1);
7484  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7485  if (!SWIG_IsOK(res2)) {
7486  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7487  }
7488  arg2 = (char *)(buf2);
7489  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7490  if (!SWIG_IsOK(res3)) {
7491  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7492  }
7493  arg3 = (char *)(buf3);
7494  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7495  resultobj = SWIG_Py_Void();
7496  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7497  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7498  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7499  return resultobj;
7500 fail:
7501  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7502  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7503  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7504  return NULL;
7505 }
7506 
7507 
7508 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7509  PyObject *resultobj = 0;
7510  PLFLT *arg1 = (PLFLT *) 0 ;
7511  PLFLT *arg2 = (PLFLT *) 0 ;
7512  PLINT arg3 ;
7513  PLINT arg4 ;
7514  PLFLT arg5 ;
7515  PLFLT arg6 ;
7516  PLFLT arg7 ;
7517  PLINT arg8 ;
7518  PLINT arg9 ;
7519  PLINT arg10 ;
7520  PLINT arg11 ;
7521  PLINT arg12 ;
7522  PLINT arg13 ;
7523  PLINT *arg14 = (PLINT *) 0 ;
7524  PLFLT arg15 ;
7525  PLFLT arg16 ;
7526  PLFLT arg17 ;
7527  PLFLT arg18 ;
7528  PLINT *arg19 = (PLINT *) 0 ;
7529  char **arg20 = (char **) 0 ;
7530  PLINT *arg21 = (PLINT *) 0 ;
7531  PLINT *arg22 = (PLINT *) 0 ;
7532  PLFLT *arg23 = (PLFLT *) 0 ;
7533  PLFLT *arg24 = (PLFLT *) 0 ;
7534  PLINT *arg25 = (PLINT *) 0 ;
7535  PLINT *arg26 = (PLINT *) 0 ;
7536  PLFLT *arg27 = (PLFLT *) 0 ;
7537  PLINT *arg28 = (PLINT *) 0 ;
7538  PLFLT *arg29 = (PLFLT *) 0 ;
7539  PLINT *arg30 = (PLINT *) 0 ;
7540  char **arg31 = (char **) 0 ;
7541  PLFLT temp1 ;
7542  int res1 = SWIG_TMPOBJ ;
7543  PLFLT temp2 ;
7544  int res2 = SWIG_TMPOBJ ;
7545  int val3 ;
7546  int ecode3 = 0 ;
7547  int val4 ;
7548  int ecode4 = 0 ;
7549  double val5 ;
7550  int ecode5 = 0 ;
7551  double val6 ;
7552  int ecode6 = 0 ;
7553  double val7 ;
7554  int ecode7 = 0 ;
7555  int val8 ;
7556  int ecode8 = 0 ;
7557  int val9 ;
7558  int ecode9 = 0 ;
7559  int val10 ;
7560  int ecode10 = 0 ;
7561  int val11 ;
7562  int ecode11 = 0 ;
7563  int val12 ;
7564  int ecode12 = 0 ;
7565  PyArrayObject *tmp13 = NULL ;
7566  double val15 ;
7567  int ecode15 = 0 ;
7568  double val16 ;
7569  int ecode16 = 0 ;
7570  double val17 ;
7571  int ecode17 = 0 ;
7572  double val18 ;
7573  int ecode18 = 0 ;
7574  PyArrayObject *tmp19 = NULL ;
7575  PyArrayObject *tmp20 = NULL ;
7576  PyArrayObject *tmp21 = NULL ;
7577  PyArrayObject *tmp22 = NULL ;
7578  PyArrayObject *tmp23 = NULL ;
7579  PyArrayObject *tmp24 = NULL ;
7580  PyArrayObject *tmp25 = NULL ;
7581  PyArrayObject *tmp26 = NULL ;
7582  PyArrayObject *tmp27 = NULL ;
7583  PyArrayObject *tmp28 = NULL ;
7584  PyArrayObject *tmp29 = NULL ;
7585  PyArrayObject *tmp30 = NULL ;
7586  PyArrayObject *tmp31 = NULL ;
7587  PyObject *swig_obj[28] ;
7588 
7589  arg1 = &temp1;
7590  arg2 = &temp2;
7591  if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
7592  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
7593  if (!SWIG_IsOK(ecode3)) {
7594  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7595  }
7596  arg3 = (PLINT)(val3);
7597  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
7598  if (!SWIG_IsOK(ecode4)) {
7599  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7600  }
7601  arg4 = (PLINT)(val4);
7602  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
7603  if (!SWIG_IsOK(ecode5)) {
7604  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7605  }
7606  arg5 = (PLFLT)(val5);
7607  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
7608  if (!SWIG_IsOK(ecode6)) {
7609  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7610  }
7611  arg6 = (PLFLT)(val6);
7612  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
7613  if (!SWIG_IsOK(ecode7)) {
7614  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7615  }
7616  arg7 = (PLFLT)(val7);
7617  ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
7618  if (!SWIG_IsOK(ecode8)) {
7619  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7620  }
7621  arg8 = (PLINT)(val8);
7622  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
7623  if (!SWIG_IsOK(ecode9)) {
7624  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7625  }
7626  arg9 = (PLINT)(val9);
7627  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
7628  if (!SWIG_IsOK(ecode10)) {
7629  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7630  }
7631  arg10 = (PLINT)(val10);
7632  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
7633  if (!SWIG_IsOK(ecode11)) {
7634  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7635  }
7636  arg11 = (PLINT)(val11);
7637  ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
7638  if (!SWIG_IsOK(ecode12)) {
7639  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7640  }
7641  arg12 = (PLINT)(val12);
7642  {
7643  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
7644  if ( tmp13 == NULL )
7645  return NULL;
7646  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7647  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7648  }
7649  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
7650  if (!SWIG_IsOK(ecode15)) {
7651  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7652  }
7653  arg15 = (PLFLT)(val15);
7654  ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
7655  if (!SWIG_IsOK(ecode16)) {
7656  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7657  }
7658  arg16 = (PLFLT)(val16);
7659  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
7660  if (!SWIG_IsOK(ecode17)) {
7661  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7662  }
7663  arg17 = (PLFLT)(val17);
7664  ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
7665  if (!SWIG_IsOK(ecode18)) {
7666  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7667  }
7668  arg18 = (PLFLT)(val18);
7669  {
7670  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
7671  if ( tmp19 == NULL )
7672  return NULL;
7673  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7674  {
7675  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7676  return NULL;
7677  }
7678  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7679  }
7680  {
7681  int i;
7682  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
7683  if ( tmp20 == NULL )
7684  return NULL;
7685  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7686  {
7687  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7688  return NULL;
7689  }
7690  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7691  for ( i = 0; i < Alen; i++ )
7692  {
7693  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7694  if ( arg20[i] == NULL )
7695  {
7696  free( arg20 );
7697  return NULL;
7698  }
7699  }
7700  }
7701  {
7702  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
7703  if ( tmp21 == NULL )
7704  return NULL;
7705  if ( PyArray_DIMS( tmp21 )[0] != Alen )
7706  {
7707  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7708  return NULL;
7709  }
7710  arg21 = (PLINT *) PyArray_DATA( tmp21 );
7711  }
7712  {
7713  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
7714  if ( tmp22 == NULL )
7715  return NULL;
7716  if ( PyArray_DIMS( tmp22 )[0] != Alen )
7717  {
7718  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7719  return NULL;
7720  }
7721  arg22 = (PLINT *) PyArray_DATA( tmp22 );
7722  }
7723  {
7724  if ( swig_obj[19] != Py_None )
7725  {
7726  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
7727  if ( tmp23 == NULL )
7728  return NULL;
7729  if ( PyArray_DIMS( tmp23 )[0] != Alen )
7730  {
7731  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7732  return NULL;
7733  }
7734  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
7735  }
7736  else
7737  {
7738  arg23 = NULL;
7739  }
7740  }
7741  {
7742  if ( swig_obj[20] != Py_None )
7743  {
7744  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
7745  if ( tmp24 == NULL )
7746  return NULL;
7747  if ( PyArray_DIMS( tmp24 )[0] != Alen )
7748  {
7749  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7750  return NULL;
7751  }
7752  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
7753  }
7754  else
7755  {
7756  arg24 = NULL;
7757  }
7758  }
7759  {
7760  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
7761  if ( tmp25 == NULL )
7762  return NULL;
7763  if ( PyArray_DIMS( tmp25 )[0] != Alen )
7764  {
7765  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7766  return NULL;
7767  }
7768  arg25 = (PLINT *) PyArray_DATA( tmp25 );
7769  }
7770  {
7771  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
7772  if ( tmp26 == NULL )
7773  return NULL;
7774  if ( PyArray_DIMS( tmp26 )[0] != Alen )
7775  {
7776  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7777  return NULL;
7778  }
7779  arg26 = (PLINT *) PyArray_DATA( tmp26 );
7780  }
7781  {
7782  if ( swig_obj[23] != Py_None )
7783  {
7784  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
7785  if ( tmp27 == NULL )
7786  return NULL;
7787  if ( PyArray_DIMS( tmp27 )[0] != Alen )
7788  {
7789  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7790  return NULL;
7791  }
7792  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
7793  }
7794  else
7795  {
7796  arg27 = NULL;
7797  }
7798  }
7799  {
7800  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
7801  if ( tmp28 == NULL )
7802  return NULL;
7803  if ( PyArray_DIMS( tmp28 )[0] != Alen )
7804  {
7805  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7806  return NULL;
7807  }
7808  arg28 = (PLINT *) PyArray_DATA( tmp28 );
7809  }
7810  {
7811  if ( swig_obj[25] != Py_None )
7812  {
7813  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
7814  if ( tmp29 == NULL )
7815  return NULL;
7816  if ( PyArray_DIMS( tmp29 )[0] != Alen )
7817  {
7818  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7819  return NULL;
7820  }
7821  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
7822  }
7823  else
7824  {
7825  arg29 = NULL;
7826  }
7827  }
7828  {
7829  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
7830  if ( tmp30 == NULL )
7831  return NULL;
7832  if ( PyArray_DIMS( tmp30 )[0] != Alen )
7833  {
7834  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7835  return NULL;
7836  }
7837  arg30 = (PLINT *) PyArray_DATA( tmp30 );
7838  }
7839  {
7840  int i;
7841  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
7842  if ( tmp31 == NULL )
7843  return NULL;
7844  if ( PyArray_DIMS( tmp31 )[0] != Alen )
7845  {
7846  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7847  return NULL;
7848  }
7849  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7850  for ( i = 0; i < Alen; i++ )
7851  {
7852  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
7853  if ( arg31[i] == NULL )
7854  {
7855  free( arg31 );
7856  return NULL;
7857  }
7858  }
7859  }
7860  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);
7861  resultobj = SWIG_Py_Void();
7862  if (SWIG_IsTmpObj(res1)) {
7863  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7864  } else {
7865  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7866  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7867  }
7868  if (SWIG_IsTmpObj(res2)) {
7869  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7870  } else {
7871  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7872  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7873  }
7874  {
7875  Py_CLEAR( tmp13 );
7876  }
7877  {
7878  Py_CLEAR( tmp19 );
7879  }
7880  {
7881  Py_CLEAR( tmp20 ); free( arg20 );
7882  }
7883  {
7884  Py_CLEAR( tmp21 );
7885  }
7886  {
7887  Py_CLEAR( tmp22 );
7888  }
7889  {
7890  Py_CLEAR( tmp23 );
7891  }
7892  {
7893  Py_CLEAR( tmp24 );
7894  }
7895  {
7896  Py_CLEAR( tmp25 );
7897  }
7898  {
7899  Py_CLEAR( tmp26 );
7900  }
7901  {
7902  Py_CLEAR( tmp27 );
7903  }
7904  {
7905  Py_CLEAR( tmp28 );
7906  }
7907  {
7908  Py_CLEAR( tmp29 );
7909  }
7910  {
7911  Py_CLEAR( tmp30 );
7912  }
7913  {
7914  Py_CLEAR( tmp31 ); free( arg31 );
7915  }
7916  return resultobj;
7917 fail:
7918  {
7919  Py_CLEAR( tmp13 );
7920  }
7921  {
7922  Py_CLEAR( tmp19 );
7923  }
7924  {
7925  Py_CLEAR( tmp20 ); free( arg20 );
7926  }
7927  {
7928  Py_CLEAR( tmp21 );
7929  }
7930  {
7931  Py_CLEAR( tmp22 );
7932  }
7933  {
7934  Py_CLEAR( tmp23 );
7935  }
7936  {
7937  Py_CLEAR( tmp24 );
7938  }
7939  {
7940  Py_CLEAR( tmp25 );
7941  }
7942  {
7943  Py_CLEAR( tmp26 );
7944  }
7945  {
7946  Py_CLEAR( tmp27 );
7947  }
7948  {
7949  Py_CLEAR( tmp28 );
7950  }
7951  {
7952  Py_CLEAR( tmp29 );
7953  }
7954  {
7955  Py_CLEAR( tmp30 );
7956  }
7957  {
7958  Py_CLEAR( tmp31 ); free( arg31 );
7959  }
7960  return NULL;
7961 }
7962 
7963 
7964 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965  PyObject *resultobj = 0;
7966  PLFLT *arg1 = (PLFLT *) 0 ;
7967  PLFLT *arg2 = (PLFLT *) 0 ;
7968  PLINT arg3 ;
7969  PLINT arg4 ;
7970  PLFLT arg5 ;
7971  PLFLT arg6 ;
7972  PLFLT arg7 ;
7973  PLFLT arg8 ;
7974  PLINT arg9 ;
7975  PLINT arg10 ;
7976  PLINT arg11 ;
7977  PLFLT arg12 ;
7978  PLFLT arg13 ;
7979  PLINT arg14 ;
7980  PLFLT arg15 ;
7981  PLINT arg16 ;
7982  PLINT *arg17 = (PLINT *) 0 ;
7983  char **arg18 = (char **) 0 ;
7984  PLINT arg19 ;
7985  char **arg20 = (char **) 0 ;
7986  PLFLT *arg21 = (PLFLT *) 0 ;
7987  PLINT *arg22 = (PLINT *) 0 ;
7988  PLINT *arg23 = (PLINT *) 0 ;
7989  PLFLT **arg24 = (PLFLT **) 0 ;
7990  PLFLT temp1 ;
7991  int res1 = SWIG_TMPOBJ ;
7992  PLFLT temp2 ;
7993  int res2 = SWIG_TMPOBJ ;
7994  int val3 ;
7995  int ecode3 = 0 ;
7996  int val4 ;
7997  int ecode4 = 0 ;
7998  double val5 ;
7999  int ecode5 = 0 ;
8000  double val6 ;
8001  int ecode6 = 0 ;
8002  double val7 ;
8003  int ecode7 = 0 ;
8004  double val8 ;
8005  int ecode8 = 0 ;
8006  int val9 ;
8007  int ecode9 = 0 ;
8008  int val10 ;
8009  int ecode10 = 0 ;
8010  int val11 ;
8011  int ecode11 = 0 ;
8012  double val12 ;
8013  int ecode12 = 0 ;
8014  double val13 ;
8015  int ecode13 = 0 ;
8016  int val14 ;
8017  int ecode14 = 0 ;
8018  double val15 ;
8019  int ecode15 = 0 ;
8020  PyArrayObject *tmp16 = NULL ;
8021  PyArrayObject *tmp18 = NULL ;
8022  PyArrayObject *tmp19 = NULL ;
8023  PyArrayObject *tmp21 = NULL ;
8024  PyArrayObject *tmp22 = NULL ;
8025  PyArrayObject *tmp23 = NULL ;
8026  PyArrayObject *tmp24 = NULL ;
8027  PyObject *swig_obj[20] ;
8028 
8029  arg1 = &temp1;
8030  arg2 = &temp2;
8031  if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8032  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8033  if (!SWIG_IsOK(ecode3)) {
8034  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8035  }
8036  arg3 = (PLINT)(val3);
8037  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8038  if (!SWIG_IsOK(ecode4)) {
8039  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8040  }
8041  arg4 = (PLINT)(val4);
8042  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8043  if (!SWIG_IsOK(ecode5)) {
8044  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8045  }
8046  arg5 = (PLFLT)(val5);
8047  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8048  if (!SWIG_IsOK(ecode6)) {
8049  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8050  }
8051  arg6 = (PLFLT)(val6);
8052  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8053  if (!SWIG_IsOK(ecode7)) {
8054  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8055  }
8056  arg7 = (PLFLT)(val7);
8057  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8058  if (!SWIG_IsOK(ecode8)) {
8059  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8060  }
8061  arg8 = (PLFLT)(val8);
8062  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8063  if (!SWIG_IsOK(ecode9)) {
8064  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8065  }
8066  arg9 = (PLINT)(val9);
8067  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8068  if (!SWIG_IsOK(ecode10)) {
8069  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8070  }
8071  arg10 = (PLINT)(val10);
8072  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8073  if (!SWIG_IsOK(ecode11)) {
8074  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8075  }
8076  arg11 = (PLINT)(val11);
8077  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8078  if (!SWIG_IsOK(ecode12)) {
8079  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8080  }
8081  arg12 = (PLFLT)(val12);
8082  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8083  if (!SWIG_IsOK(ecode13)) {
8084  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8085  }
8086  arg13 = (PLFLT)(val13);
8087  ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8088  if (!SWIG_IsOK(ecode14)) {
8089  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8090  }
8091  arg14 = (PLINT)(val14);
8092  ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8093  if (!SWIG_IsOK(ecode15)) {
8094  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8095  }
8096  arg15 = (PLFLT)(val15);
8097  {
8098  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8099  if ( tmp16 == NULL )
8100  return NULL;
8101  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8102  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8103  }
8104  {
8105  int i;
8106  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8107  if ( tmp18 == NULL )
8108  return NULL;
8109  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8110  {
8111  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8112  return NULL;
8113  }
8114  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8115  for ( i = 0; i < Alen; i++ )
8116  {
8117  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8118  if ( arg18[i] == NULL )
8119  {
8120  free( arg18 );
8121  return NULL;
8122  }
8123  }
8124  }
8125  {
8126  int i;
8127  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8128  if ( tmp19 == NULL )
8129  return NULL;
8130  Alen = PyArray_DIMS( tmp19 )[0];
8131  arg19 = Alen;
8132  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8133  for ( i = 0; i < Alen; i++ )
8134  {
8135  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8136  if ( arg20[i] == NULL )
8137  {
8138  free( arg20 );
8139  return NULL;
8140  }
8141  }
8142  }
8143  {
8144  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8145  if ( tmp21 == NULL )
8146  return NULL;
8147  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8148  {
8149  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8150  return NULL;
8151  }
8152  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8153  }
8154  {
8155  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8156  if ( tmp22 == NULL )
8157  return NULL;
8158  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8159  {
8160  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8161  return NULL;
8162  }
8163  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8164  }
8165  {
8166  int i;
8167  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8168  if ( tmp23 == NULL )
8169  return NULL;
8170  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8171  {
8172  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8173  return NULL;
8174  }
8175  Xlen = PyArray_DIMS( tmp23 )[0];
8176  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8177  Ylen = -1;
8178  for ( i = 0; i < Xlen; i++ )
8179  if ( arg23[i] > Ylen )
8180  Ylen = arg23[i];
8181  }
8182  {
8183  int i, size;
8184  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8185  if ( tmp24 == NULL )
8186  return NULL;
8187  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8188  {
8189  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8190  return NULL;
8191  }
8192  size = Ylen;
8193  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8194  for ( i = 0; i < Xlen; i++ )
8195  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8196  }
8197  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);
8198  resultobj = SWIG_Py_Void();
8199  if (SWIG_IsTmpObj(res1)) {
8200  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8201  } else {
8202  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8203  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8204  }
8205  if (SWIG_IsTmpObj(res2)) {
8206  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8207  } else {
8208  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8209  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8210  }
8211  {
8212  Py_CLEAR( tmp16 );
8213  }
8214  {
8215  Py_CLEAR( tmp18 ); free( arg18 );
8216  }
8217  {
8218  Py_CLEAR( tmp19 ); free( arg20 );
8219  }
8220  {
8221  Py_CLEAR( tmp21 );
8222  }
8223  {
8224  Py_CLEAR( tmp22 );
8225  }
8226  {
8227  Py_CLEAR( tmp23 );
8228  }
8229  {
8230  Py_CLEAR( tmp24 );
8231  free( arg24 );
8232  }
8233  return resultobj;
8234 fail:
8235  {
8236  Py_CLEAR( tmp16 );
8237  }
8238  {
8239  Py_CLEAR( tmp18 ); free( arg18 );
8240  }
8241  {
8242  Py_CLEAR( tmp19 ); free( arg20 );
8243  }
8244  {
8245  Py_CLEAR( tmp21 );
8246  }
8247  {
8248  Py_CLEAR( tmp22 );
8249  }
8250  {
8251  Py_CLEAR( tmp23 );
8252  }
8253  {
8254  Py_CLEAR( tmp24 );
8255  free( arg24 );
8256  }
8257  return NULL;
8258 }
8259 
8260 
8261 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8262  PyObject *resultobj = 0;
8263  PLFLT arg1 ;
8264  PLFLT arg2 ;
8265  PLFLT arg3 ;
8266  double val1 ;
8267  int ecode1 = 0 ;
8268  double val2 ;
8269  int ecode2 = 0 ;
8270  double val3 ;
8271  int ecode3 = 0 ;
8272  PyObject *swig_obj[3] ;
8273 
8274  if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8275  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8276  if (!SWIG_IsOK(ecode1)) {
8277  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8278  }
8279  arg1 = (PLFLT)(val1);
8280  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8281  if (!SWIG_IsOK(ecode2)) {
8282  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8283  }
8284  arg2 = (PLFLT)(val2);
8285  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8286  if (!SWIG_IsOK(ecode3)) {
8287  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8288  }
8289  arg3 = (PLFLT)(val3);
8290  pllightsource(arg1,arg2,arg3);
8291  resultobj = SWIG_Py_Void();
8292  return resultobj;
8293 fail:
8294  return NULL;
8295 }
8296 
8297 
8298 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8299  PyObject *resultobj = 0;
8300  PLINT arg1 ;
8301  PLFLT *arg2 = (PLFLT *) 0 ;
8302  PLFLT *arg3 = (PLFLT *) 0 ;
8303  PyArrayObject *tmp1 = NULL ;
8304  PyArrayObject *tmp3 = NULL ;
8305  PyObject *swig_obj[2] ;
8306 
8307  if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8308  {
8309  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8310  if ( tmp1 == NULL )
8311  return NULL;
8312  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8313  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8314  }
8315  {
8316  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8317  if ( tmp3 == NULL )
8318  return NULL;
8319  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8320  {
8321  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8322  return NULL;
8323  }
8324  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8325  }
8326  plline(arg1,(double const *)arg2,(double const *)arg3);
8327  resultobj = SWIG_Py_Void();
8328  {
8329  Py_CLEAR( tmp1 );
8330  }
8331  {
8332  Py_CLEAR( tmp3 );
8333  }
8334  return resultobj;
8335 fail:
8336  {
8337  Py_CLEAR( tmp1 );
8338  }
8339  {
8340  Py_CLEAR( tmp3 );
8341  }
8342  return NULL;
8343 }
8344 
8345 
8346 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8347  PyObject *resultobj = 0;
8348  PLINT arg1 ;
8349  PLFLT *arg2 = (PLFLT *) 0 ;
8350  PLFLT *arg3 = (PLFLT *) 0 ;
8351  PLFLT *arg4 = (PLFLT *) 0 ;
8352  PyArrayObject *tmp1 = NULL ;
8353  PyArrayObject *tmp3 = NULL ;
8354  PyArrayObject *tmp4 = NULL ;
8355  PyObject *swig_obj[3] ;
8356 
8357  if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8358  {
8359  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8360  if ( tmp1 == NULL )
8361  return NULL;
8362  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8363  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8364  }
8365  {
8366  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8367  if ( tmp3 == NULL )
8368  return NULL;
8369  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8370  {
8371  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8372  return NULL;
8373  }
8374  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8375  }
8376  {
8377  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8378  if ( tmp4 == NULL )
8379  return NULL;
8380  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8381  {
8382  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8383  return NULL;
8384  }
8385  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8386  }
8387  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8388  resultobj = SWIG_Py_Void();
8389  {
8390  Py_CLEAR( tmp1 );
8391  }
8392  {
8393  Py_CLEAR( tmp3 );
8394  }
8395  {
8396  Py_CLEAR( tmp4 );
8397  }
8398  return resultobj;
8399 fail:
8400  {
8401  Py_CLEAR( tmp1 );
8402  }
8403  {
8404  Py_CLEAR( tmp3 );
8405  }
8406  {
8407  Py_CLEAR( tmp4 );
8408  }
8409  return NULL;
8410 }
8411 
8412 
8413 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414  PyObject *resultobj = 0;
8415  PLINT arg1 ;
8416  int val1 ;
8417  int ecode1 = 0 ;
8418  PyObject *swig_obj[1] ;
8419 
8420  if (!args) SWIG_fail;
8421  swig_obj[0] = args;
8422  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
8423  if (!SWIG_IsOK(ecode1)) {
8424  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8425  }
8426  arg1 = (PLINT)(val1);
8427  pllsty(arg1);
8428  resultobj = SWIG_Py_Void();
8429  return resultobj;
8430 fail:
8431  return NULL;
8432 }
8433 
8434 
8435 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436  PyObject *resultobj = 0;
8437  PLFLT *arg1 = (PLFLT *) 0 ;
8438  PLFLT *arg2 = (PLFLT *) 0 ;
8439  PLFLT **arg3 = (PLFLT **) 0 ;
8440  PLINT arg4 ;
8441  PLINT arg5 ;
8442  PLINT arg6 ;
8443  PyArrayObject *tmp1 = NULL ;
8444  PyArrayObject *tmp2 = NULL ;
8445  PyArrayObject *tmp3 = NULL ;
8446  int val6 ;
8447  int ecode6 = 0 ;
8448  PyObject *swig_obj[4] ;
8449 
8450  if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
8451  {
8452  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8453  if ( tmp1 == NULL )
8454  return NULL;
8455  Xlen = PyArray_DIMS( tmp1 )[0];
8456  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8457  }
8458  {
8459  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8460  if ( tmp2 == NULL )
8461  return NULL;
8462  Ylen = PyArray_DIMS( tmp2 )[0];
8463  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8464  }
8465  {
8466  int i, size;
8467  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8468  if ( tmp3 == NULL )
8469  return NULL;
8470  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8471  {
8472  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8473  return NULL;
8474  }
8475  arg4 = PyArray_DIMS( tmp3 )[0];
8476  arg5 = PyArray_DIMS( tmp3 )[1];
8477  size = arg5;
8478  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8479  for ( i = 0; i < arg4; i++ )
8480  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8481  }
8482  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8483  if (!SWIG_IsOK(ecode6)) {
8484  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8485  }
8486  arg6 = (PLINT)(val6);
8487  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8488  resultobj = SWIG_Py_Void();
8489  {
8490  Py_CLEAR( tmp1 );
8491  }
8492  {
8493  Py_CLEAR( tmp2 );
8494  }
8495  {
8496  Py_CLEAR( tmp3 );
8497  free( arg3 );
8498  }
8499  return resultobj;
8500 fail:
8501  {
8502  Py_CLEAR( tmp1 );
8503  }
8504  {
8505  Py_CLEAR( tmp2 );
8506  }
8507  {
8508  Py_CLEAR( tmp3 );
8509  free( arg3 );
8510  }
8511  return NULL;
8512 }
8513 
8514 
8515 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8516  PyObject *resultobj = 0;
8517  PLFLT *arg1 = (PLFLT *) 0 ;
8518  PLFLT *arg2 = (PLFLT *) 0 ;
8519  PLFLT **arg3 = (PLFLT **) 0 ;
8520  PLINT arg4 ;
8521  PLINT arg5 ;
8522  PLINT arg6 ;
8523  PLFLT *arg7 = (PLFLT *) 0 ;
8524  PLINT arg8 ;
8525  PyArrayObject *tmp1 = NULL ;
8526  PyArrayObject *tmp2 = NULL ;
8527  PyArrayObject *tmp3 = NULL ;
8528  int val6 ;
8529  int ecode6 = 0 ;
8530  PyArrayObject *tmp7 = NULL ;
8531  PyObject *swig_obj[5] ;
8532 
8533  if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
8534  {
8535  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8536  if ( tmp1 == NULL )
8537  return NULL;
8538  Xlen = PyArray_DIMS( tmp1 )[0];
8539  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8540  }
8541  {
8542  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8543  if ( tmp2 == NULL )
8544  return NULL;
8545  Ylen = PyArray_DIMS( tmp2 )[0];
8546  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8547  }
8548  {
8549  int i, size;
8550  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8551  if ( tmp3 == NULL )
8552  return NULL;
8553  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8554  {
8555  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8556  return NULL;
8557  }
8558  arg4 = PyArray_DIMS( tmp3 )[0];
8559  arg5 = PyArray_DIMS( tmp3 )[1];
8560  size = arg5;
8561  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8562  for ( i = 0; i < arg4; i++ )
8563  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8564  }
8565  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8566  if (!SWIG_IsOK(ecode6)) {
8567  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8568  }
8569  arg6 = (PLINT)(val6);
8570  {
8571  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8572  if ( tmp7 == NULL )
8573  return NULL;
8574  arg8 = PyArray_DIMS( tmp7 )[0];
8575  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8576  }
8577  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8578  resultobj = SWIG_Py_Void();
8579  {
8580  Py_CLEAR( tmp1 );
8581  }
8582  {
8583  Py_CLEAR( tmp2 );
8584  }
8585  {
8586  Py_CLEAR( tmp3 );
8587  free( arg3 );
8588  }
8589  {
8590  Py_CLEAR( tmp7 );
8591  }
8592  return resultobj;
8593 fail:
8594  {
8595  Py_CLEAR( tmp1 );
8596  }
8597  {
8598  Py_CLEAR( tmp2 );
8599  }
8600  {
8601  Py_CLEAR( tmp3 );
8602  free( arg3 );
8603  }
8604  {
8605  Py_CLEAR( tmp7 );
8606  }
8607  return NULL;
8608 }
8609 
8610 
8611 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8612  PyObject *resultobj = 0;
8613  PLINT *arg1 = (PLINT *) 0 ;
8614  PLINT temp1 ;
8615  int res1 = SWIG_TMPOBJ ;
8616 
8617  arg1 = &temp1;
8618  if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
8619  plmkstrm(arg1);
8620  resultobj = SWIG_Py_Void();
8621  if (SWIG_IsTmpObj(res1)) {
8622  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8623  } else {
8624  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8625  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8626  }
8627  return resultobj;
8628 fail:
8629  return NULL;
8630 }
8631 
8632 
8633 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8634  PyObject *resultobj = 0;
8635  char *arg1 = (char *) 0 ;
8636  PLFLT arg2 ;
8637  PLFLT arg3 ;
8638  PLFLT arg4 ;
8639  char *arg5 = (char *) 0 ;
8640  int res1 ;
8641  char *buf1 = 0 ;
8642  int alloc1 = 0 ;
8643  double val2 ;
8644  int ecode2 = 0 ;
8645  double val3 ;
8646  int ecode3 = 0 ;
8647  double val4 ;
8648  int ecode4 = 0 ;
8649  int res5 ;
8650  char *buf5 = 0 ;
8651  int alloc5 = 0 ;
8652  PyObject *swig_obj[5] ;
8653 
8654  if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
8655  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8656  if (!SWIG_IsOK(res1)) {
8657  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8658  }
8659  arg1 = (char *)(buf1);
8660  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8661  if (!SWIG_IsOK(ecode2)) {
8662  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8663  }
8664  arg2 = (PLFLT)(val2);
8665  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8666  if (!SWIG_IsOK(ecode3)) {
8667  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8668  }
8669  arg3 = (PLFLT)(val3);
8670  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8671  if (!SWIG_IsOK(ecode4)) {
8672  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8673  }
8674  arg4 = (PLFLT)(val4);
8675  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8676  if (!SWIG_IsOK(res5)) {
8677  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8678  }
8679  arg5 = (char *)(buf5);
8680  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8681  resultobj = SWIG_Py_Void();
8682  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8683  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8684  return resultobj;
8685 fail:
8686  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8687  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8688  return NULL;
8689 }
8690 
8691 
8692 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8693  PyObject *resultobj = 0;
8694  char *arg1 = (char *) 0 ;
8695  PLFLT arg2 ;
8696  PLFLT arg3 ;
8697  PLFLT arg4 ;
8698  char *arg5 = (char *) 0 ;
8699  int res1 ;
8700  char *buf1 = 0 ;
8701  int alloc1 = 0 ;
8702  double val2 ;
8703  int ecode2 = 0 ;
8704  double val3 ;
8705  int ecode3 = 0 ;
8706  double val4 ;
8707  int ecode4 = 0 ;
8708  int res5 ;
8709  char *buf5 = 0 ;
8710  int alloc5 = 0 ;
8711  PyObject *swig_obj[5] ;
8712 
8713  if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
8714  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8715  if (!SWIG_IsOK(res1)) {
8716  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
8717  }
8718  arg1 = (char *)(buf1);
8719  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8720  if (!SWIG_IsOK(ecode2)) {
8721  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
8722  }
8723  arg2 = (PLFLT)(val2);
8724  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8725  if (!SWIG_IsOK(ecode3)) {
8726  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
8727  }
8728  arg3 = (PLFLT)(val3);
8729  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8730  if (!SWIG_IsOK(ecode4)) {
8731  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
8732  }
8733  arg4 = (PLFLT)(val4);
8734  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8735  if (!SWIG_IsOK(res5)) {
8736  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
8737  }
8738  arg5 = (char *)(buf5);
8739  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8740  resultobj = SWIG_Py_Void();
8741  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8742  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8743  return resultobj;
8744 fail:
8745  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8746  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8747  return NULL;
8748 }
8749 
8750 
8751 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752  PyObject *resultobj = 0;
8753  PLFLT *arg1 = (PLFLT *) 0 ;
8754  PLFLT *arg2 = (PLFLT *) 0 ;
8755  PLFLT **arg3 = (PLFLT **) 0 ;
8756  PLINT arg4 ;
8757  PLINT arg5 ;
8758  PLINT arg6 ;
8759  PLBOOL arg7 ;
8760  PyArrayObject *tmp1 = NULL ;
8761  PyArrayObject *tmp2 = NULL ;
8762  PyArrayObject *tmp3 = NULL ;
8763  int val6 ;
8764  int ecode6 = 0 ;
8765  int val7 ;
8766  int ecode7 = 0 ;
8767  PyObject *swig_obj[5] ;
8768 
8769  if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
8770  {
8771  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8772  if ( tmp1 == NULL )
8773  return NULL;
8774  Xlen = PyArray_DIMS( tmp1 )[0];
8775  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8776  }
8777  {
8778  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8779  if ( tmp2 == NULL )
8780  return NULL;
8781  Ylen = PyArray_DIMS( tmp2 )[0];
8782  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8783  }
8784  {
8785  int i, size;
8786  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8787  if ( tmp3 == NULL )
8788  return NULL;
8789  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8790  {
8791  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8792  return NULL;
8793  }
8794  arg4 = PyArray_DIMS( tmp3 )[0];
8795  arg5 = PyArray_DIMS( tmp3 )[1];
8796  size = arg5;
8797  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8798  for ( i = 0; i < arg4; i++ )
8799  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8800  }
8801  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8802  if (!SWIG_IsOK(ecode6)) {
8803  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
8804  }
8805  arg6 = (PLINT)(val6);
8806  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
8807  if (!SWIG_IsOK(ecode7)) {
8808  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
8809  }
8810  arg7 = (PLBOOL)(val7);
8811  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
8812  resultobj = SWIG_Py_Void();
8813  {
8814  Py_CLEAR( tmp1 );
8815  }
8816  {
8817  Py_CLEAR( tmp2 );
8818  }
8819  {
8820  Py_CLEAR( tmp3 );
8821  free( arg3 );
8822  }
8823  return resultobj;
8824 fail:
8825  {
8826  Py_CLEAR( tmp1 );
8827  }
8828  {
8829  Py_CLEAR( tmp2 );
8830  }
8831  {
8832  Py_CLEAR( tmp3 );
8833  free( arg3 );
8834  }
8835  return NULL;
8836 }
8837 
8838 
8839 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8840  PyObject *resultobj = 0;
8841  PLFLT *arg1 = (PLFLT *) 0 ;
8842  PLFLT *arg2 = (PLFLT *) 0 ;
8843  PLFLT **arg3 = (PLFLT **) 0 ;
8844  PLINT arg4 ;
8845  PLINT arg5 ;
8846  PLINT arg6 ;
8847  PLFLT *arg7 = (PLFLT *) 0 ;
8848  PLINT arg8 ;
8849  PyArrayObject *tmp1 = NULL ;
8850  PyArrayObject *tmp2 = NULL ;
8851  PyArrayObject *tmp3 = NULL ;
8852  int val6 ;
8853  int ecode6 = 0 ;
8854  PyArrayObject *tmp7 = NULL ;
8855  PyObject *swig_obj[5] ;
8856 
8857  if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
8858  {
8859  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8860  if ( tmp1 == NULL )
8861  return NULL;
8862  Xlen = PyArray_DIMS( tmp1 )[0];
8863  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8864  }
8865  {
8866  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8867  if ( tmp2 == NULL )
8868  return NULL;
8869  Ylen = PyArray_DIMS( tmp2 )[0];
8870  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8871  }
8872  {
8873  int i, size;
8874  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8875  if ( tmp3 == NULL )
8876  return NULL;
8877  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8878  {
8879  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8880  return NULL;
8881  }
8882  arg4 = PyArray_DIMS( tmp3 )[0];
8883  arg5 = PyArray_DIMS( tmp3 )[1];
8884  size = arg5;
8885  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8886  for ( i = 0; i < arg4; i++ )
8887  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8888  }
8889  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8890  if (!SWIG_IsOK(ecode6)) {
8891  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
8892  }
8893  arg6 = (PLINT)(val6);
8894  {
8895  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8896  if ( tmp7 == NULL )
8897  return NULL;
8898  arg8 = PyArray_DIMS( tmp7 )[0];
8899  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8900  }
8901  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8902  resultobj = SWIG_Py_Void();
8903  {
8904  Py_CLEAR( tmp1 );
8905  }
8906  {
8907  Py_CLEAR( tmp2 );
8908  }
8909  {
8910  Py_CLEAR( tmp3 );
8911  free( arg3 );
8912  }
8913  {
8914  Py_CLEAR( tmp7 );
8915  }
8916  return resultobj;
8917 fail:
8918  {
8919  Py_CLEAR( tmp1 );
8920  }
8921  {
8922  Py_CLEAR( tmp2 );
8923  }
8924  {
8925  Py_CLEAR( tmp3 );
8926  free( arg3 );
8927  }
8928  {
8929  Py_CLEAR( tmp7 );
8930  }
8931  return NULL;
8932 }
8933 
8934 
8935 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8936  PyObject *resultobj = 0;
8937  PLFLT *arg1 = (PLFLT *) 0 ;
8938  PLFLT *arg2 = (PLFLT *) 0 ;
8939  PLFLT **arg3 = (PLFLT **) 0 ;
8940  PLINT arg4 ;
8941  PLINT arg5 ;
8942  PLINT arg6 ;
8943  PLFLT *arg7 = (PLFLT *) 0 ;
8944  PLINT arg8 ;
8945  PLINT arg9 ;
8946  PLINT arg10 ;
8947  PLINT *arg11 = (PLINT *) 0 ;
8948  PLINT *arg12 = (PLINT *) 0 ;
8949  PyArrayObject *tmp1 = NULL ;
8950  PyArrayObject *tmp2 = NULL ;
8951  PyArrayObject *tmp3 = NULL ;
8952  int val6 ;
8953  int ecode6 = 0 ;
8954  PyArrayObject *tmp7 = NULL ;
8955  int val9 ;
8956  int ecode9 = 0 ;
8957  PyArrayObject *tmp10 = NULL ;
8958  PyArrayObject *tmp12 = NULL ;
8959  PyObject *swig_obj[8] ;
8960 
8961  if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
8962  {
8963  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8964  if ( tmp1 == NULL )
8965  return NULL;
8966  Xlen = PyArray_DIMS( tmp1 )[0];
8967  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8968  }
8969  {
8970  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8971  if ( tmp2 == NULL )
8972  return NULL;
8973  Ylen = PyArray_DIMS( tmp2 )[0];
8974  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8975  }
8976  {
8977  int i, size;
8978  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8979  if ( tmp3 == NULL )
8980  return NULL;
8981  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8982  {
8983  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8984  return NULL;
8985  }
8986  arg4 = PyArray_DIMS( tmp3 )[0];
8987  arg5 = PyArray_DIMS( tmp3 )[1];
8988  size = arg5;
8989  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8990  for ( i = 0; i < arg4; i++ )
8991  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8992  }
8993  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8994  if (!SWIG_IsOK(ecode6)) {
8995  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
8996  }
8997  arg6 = (PLINT)(val6);
8998  {
8999  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9000  if ( tmp7 == NULL )
9001  return NULL;
9002  arg8 = PyArray_DIMS( tmp7 )[0];
9003  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9004  }
9005  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9006  if (!SWIG_IsOK(ecode9)) {
9007  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9008  }
9009  arg9 = (PLINT)(val9);
9010  {
9011  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9012  if ( tmp10 == NULL )
9013  return NULL;
9014  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9015  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9016  }
9017  {
9018  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9019  if ( tmp12 == NULL )
9020  return NULL;
9021  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9022  {
9023  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9024  return NULL;
9025  }
9026  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9027  }
9028  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);
9029  resultobj = SWIG_Py_Void();
9030  {
9031  Py_CLEAR( tmp1 );
9032  }
9033  {
9034  Py_CLEAR( tmp2 );
9035  }
9036  {
9037  Py_CLEAR( tmp3 );
9038  free( arg3 );
9039  }
9040  {
9041  Py_CLEAR( tmp7 );
9042  }
9043  {
9044  Py_CLEAR( tmp10 );
9045  }
9046  {
9047  Py_CLEAR( tmp12 );
9048  }
9049  return resultobj;
9050 fail:
9051  {
9052  Py_CLEAR( tmp1 );
9053  }
9054  {
9055  Py_CLEAR( tmp2 );
9056  }
9057  {
9058  Py_CLEAR( tmp3 );
9059  free( arg3 );
9060  }
9061  {
9062  Py_CLEAR( tmp7 );
9063  }
9064  {
9065  Py_CLEAR( tmp10 );
9066  }
9067  {
9068  Py_CLEAR( tmp12 );
9069  }
9070  return NULL;
9071 }
9072 
9073 
9074 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075  PyObject *resultobj = 0;
9076  PLFLT *arg1 = (PLFLT *) 0 ;
9077  PLFLT *arg2 = (PLFLT *) 0 ;
9078  PLFLT **arg3 = (PLFLT **) 0 ;
9079  PLINT arg4 ;
9080  PLINT arg5 ;
9081  PLINT arg6 ;
9082  PLFLT *arg7 = (PLFLT *) 0 ;
9083  PLINT arg8 ;
9084  PyArrayObject *tmp1 = NULL ;
9085  PyArrayObject *tmp2 = NULL ;
9086  PyArrayObject *tmp3 = NULL ;
9087  int val6 ;
9088  int ecode6 = 0 ;
9089  PyArrayObject *tmp7 = NULL ;
9090  PyObject *swig_obj[5] ;
9091 
9092  if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9093  {
9094  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9095  if ( tmp1 == NULL )
9096  return NULL;
9097  Xlen = PyArray_DIMS( tmp1 )[0];
9098  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9099  }
9100  {
9101  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9102  if ( tmp2 == NULL )
9103  return NULL;
9104  Ylen = PyArray_DIMS( tmp2 )[0];
9105  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9106  }
9107  {
9108  int i, size;
9109  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9110  if ( tmp3 == NULL )
9111  return NULL;
9112  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9113  {
9114  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9115  return NULL;
9116  }
9117  arg4 = PyArray_DIMS( tmp3 )[0];
9118  arg5 = PyArray_DIMS( tmp3 )[1];
9119  size = arg5;
9120  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9121  for ( i = 0; i < arg4; i++ )
9122  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9123  }
9124  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9125  if (!SWIG_IsOK(ecode6)) {
9126  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9127  }
9128  arg6 = (PLINT)(val6);
9129  {
9130  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9131  if ( tmp7 == NULL )
9132  return NULL;
9133  arg8 = PyArray_DIMS( tmp7 )[0];
9134  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9135  }
9136  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9137  resultobj = SWIG_Py_Void();
9138  {
9139  Py_CLEAR( tmp1 );
9140  }
9141  {
9142  Py_CLEAR( tmp2 );
9143  }
9144  {
9145  Py_CLEAR( tmp3 );
9146  free( arg3 );
9147  }
9148  {
9149  Py_CLEAR( tmp7 );
9150  }
9151  return resultobj;
9152 fail:
9153  {
9154  Py_CLEAR( tmp1 );
9155  }
9156  {
9157  Py_CLEAR( tmp2 );
9158  }
9159  {
9160  Py_CLEAR( tmp3 );
9161  free( arg3 );
9162  }
9163  {
9164  Py_CLEAR( tmp7 );
9165  }
9166  return NULL;
9167 }
9168 
9169 
9170 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171  PyObject *resultobj = 0;
9172  PLFLT *arg1 = (PLFLT *) 0 ;
9173  PLFLT *arg2 = (PLFLT *) 0 ;
9174  PLFLT **arg3 = (PLFLT **) 0 ;
9175  PLINT arg4 ;
9176  PLINT arg5 ;
9177  PLINT arg6 ;
9178  PLFLT *arg7 = (PLFLT *) 0 ;
9179  PLINT arg8 ;
9180  PLINT arg9 ;
9181  PLINT arg10 ;
9182  PLINT *arg11 = (PLINT *) 0 ;
9183  PLINT *arg12 = (PLINT *) 0 ;
9184  PyArrayObject *tmp1 = NULL ;
9185  PyArrayObject *tmp2 = NULL ;
9186  PyArrayObject *tmp3 = NULL ;
9187  int val6 ;
9188  int ecode6 = 0 ;
9189  PyArrayObject *tmp7 = NULL ;
9190  int val9 ;
9191  int ecode9 = 0 ;
9192  PyArrayObject *tmp10 = NULL ;
9193  PyArrayObject *tmp12 = NULL ;
9194  PyObject *swig_obj[8] ;
9195 
9196  if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9197  {
9198  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9199  if ( tmp1 == NULL )
9200  return NULL;
9201  Xlen = PyArray_DIMS( tmp1 )[0];
9202  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9203  }
9204  {
9205  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9206  if ( tmp2 == NULL )
9207  return NULL;
9208  Ylen = PyArray_DIMS( tmp2 )[0];
9209  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9210  }
9211  {
9212  int i, size;
9213  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9214  if ( tmp3 == NULL )
9215  return NULL;
9216  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9217  {
9218  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9219  return NULL;
9220  }
9221  arg4 = PyArray_DIMS( tmp3 )[0];
9222  arg5 = PyArray_DIMS( tmp3 )[1];
9223  size = arg5;
9224  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9225  for ( i = 0; i < arg4; i++ )
9226  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9227  }
9228  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9229  if (!SWIG_IsOK(ecode6)) {
9230  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9231  }
9232  arg6 = (PLINT)(val6);
9233  {
9234  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9235  if ( tmp7 == NULL )
9236  return NULL;
9237  arg8 = PyArray_DIMS( tmp7 )[0];
9238  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9239  }
9240  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9241  if (!SWIG_IsOK(ecode9)) {
9242  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9243  }
9244  arg9 = (PLINT)(val9);
9245  {
9246  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9247  if ( tmp10 == NULL )
9248  return NULL;
9249  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9250  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9251  }
9252  {
9253  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9254  if ( tmp12 == NULL )
9255  return NULL;
9256  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9257  {
9258  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9259  return NULL;
9260  }
9261  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9262  }
9263  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);
9264  resultobj = SWIG_Py_Void();
9265  {
9266  Py_CLEAR( tmp1 );
9267  }
9268  {
9269  Py_CLEAR( tmp2 );
9270  }
9271  {
9272  Py_CLEAR( tmp3 );
9273  free( arg3 );
9274  }
9275  {
9276  Py_CLEAR( tmp7 );
9277  }
9278  {
9279  Py_CLEAR( tmp10 );
9280  }
9281  {
9282  Py_CLEAR( tmp12 );
9283  }
9284  return resultobj;
9285 fail:
9286  {
9287  Py_CLEAR( tmp1 );
9288  }
9289  {
9290  Py_CLEAR( tmp2 );
9291  }
9292  {
9293  Py_CLEAR( tmp3 );
9294  free( arg3 );
9295  }
9296  {
9297  Py_CLEAR( tmp7 );
9298  }
9299  {
9300  Py_CLEAR( tmp10 );
9301  }
9302  {
9303  Py_CLEAR( tmp12 );
9304  }
9305  return NULL;
9306 }
9307 
9308 
9309 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310  PyObject *resultobj = 0;
9311  int *arg1 = (int *) 0 ;
9312  char **arg2 = (char **) 0 ;
9313  PLINT arg3 ;
9314  int tmp1 ;
9315  int val3 ;
9316  int ecode3 = 0 ;
9317  PyObject *swig_obj[2] ;
9318  PLINT result;
9319 
9320  if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9321  {
9322  int i;
9323  PyObject *unicode_string;
9324 
9325  if ( !PyList_Check( swig_obj[0] ) )
9326  {
9327  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9328  return NULL;
9329  }
9330  tmp1 = PyList_Size( swig_obj[0] );
9331  arg1 = &tmp1;
9332  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9333  for ( i = 0; i < tmp1; i++ )
9334  {
9335  PyObject *s = PyList_GetItem( swig_obj[0], i );
9336  if ( PyString_Check( s ) )
9337  {
9338  arg2[i] = PyString_AsString( s );
9339  }
9340  else if ( PyUnicode_Check( s ) )
9341  {
9342  // unicode_string is never freed? memory leak here?
9343  unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9344  arg2[i] = PyBytes_AS_STRING( unicode_string );
9345  }
9346  else
9347  {
9348  free( arg2 );
9349  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9350  return NULL;
9351  }
9352  }
9353  arg2[i] = 0;
9354  }
9355  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9356  if (!SWIG_IsOK(ecode3)) {
9357  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9358  }
9359  arg3 = (PLINT)(val3);
9360  result = (PLINT)plparseopts(arg1,arg2,arg3);
9361  resultobj = SWIG_From_int((int)(result));
9362  {
9363  if ( arg2 )
9364  free( arg2 );
9365  }
9366  return resultobj;
9367 fail:
9368  {
9369  if ( arg2 )
9370  free( arg2 );
9371  }
9372  return NULL;
9373 }
9374 
9375 
9376 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9377  PyObject *resultobj = 0;
9378  PLINT arg1 ;
9379  PLINT *arg2 = (PLINT *) 0 ;
9380  PLINT *arg3 = (PLINT *) 0 ;
9381  PyArrayObject *tmp1 = NULL ;
9382  PyArrayObject *tmp3 = NULL ;
9383  PyObject *swig_obj[2] ;
9384 
9385  if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9386  {
9387  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9388  if ( tmp1 == NULL )
9389  return NULL;
9390  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9391  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9392  }
9393  {
9394  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9395  if ( tmp3 == NULL )
9396  return NULL;
9397  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9398  {
9399  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9400  return NULL;
9401  }
9402  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9403  }
9404  plpat(arg1,(int const *)arg2,(int const *)arg3);
9405  resultobj = SWIG_Py_Void();
9406  {
9407  Py_CLEAR( tmp1 );
9408  }
9409  {
9410  Py_CLEAR( tmp3 );
9411  }
9412  return resultobj;
9413 fail:
9414  {
9415  Py_CLEAR( tmp1 );
9416  }
9417  {
9418  Py_CLEAR( tmp3 );
9419  }
9420  return NULL;
9421 }
9422 
9423 
9424 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9425  PyObject *resultobj = 0;
9426  PLINT arg1 ;
9427  PLFLT arg2 ;
9428  PLFLT arg3 ;
9429  PLFLT arg4 ;
9430  PLFLT arg5 ;
9431  int val1 ;
9432  int ecode1 = 0 ;
9433  double val2 ;
9434  int ecode2 = 0 ;
9435  double val3 ;
9436  int ecode3 = 0 ;
9437  double val4 ;
9438  int ecode4 = 0 ;
9439  double val5 ;
9440  int ecode5 = 0 ;
9441  PyObject *swig_obj[5] ;
9442 
9443  if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
9444  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9445  if (!SWIG_IsOK(ecode1)) {
9446  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9447  }
9448  arg1 = (PLINT)(val1);
9449  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9450  if (!SWIG_IsOK(ecode2)) {
9451  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9452  }
9453  arg2 = (PLFLT)(val2);
9454  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9455  if (!SWIG_IsOK(ecode3)) {
9456  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9457  }
9458  arg3 = (PLFLT)(val3);
9459  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9460  if (!SWIG_IsOK(ecode4)) {
9461  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9462  }
9463  arg4 = (PLFLT)(val4);
9464  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9465  if (!SWIG_IsOK(ecode5)) {
9466  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9467  }
9468  arg5 = (PLFLT)(val5);
9469  plpath(arg1,arg2,arg3,arg4,arg5);
9470  resultobj = SWIG_Py_Void();
9471  return resultobj;
9472 fail:
9473  return NULL;
9474 }
9475 
9476 
9477 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9478  PyObject *resultobj = 0;
9479  PLINT arg1 ;
9480  PLFLT *arg2 = (PLFLT *) 0 ;
9481  PLFLT *arg3 = (PLFLT *) 0 ;
9482  PLINT arg4 ;
9483  PyArrayObject *tmp1 = NULL ;
9484  PyArrayObject *tmp3 = NULL ;
9485  int val4 ;
9486  int ecode4 = 0 ;
9487  PyObject *swig_obj[3] ;
9488 
9489  if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
9490  {
9491  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9492  if ( tmp1 == NULL )
9493  return NULL;
9494  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9495  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9496  }
9497  {
9498  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9499  if ( tmp3 == NULL )
9500  return NULL;
9501  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9502  {
9503  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9504  return NULL;
9505  }
9506  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9507  }
9508  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
9509  if (!SWIG_IsOK(ecode4)) {
9510  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9511  }
9512  arg4 = (PLINT)(val4);
9513  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9514  resultobj = SWIG_Py_Void();
9515  {
9516  Py_CLEAR( tmp1 );
9517  }
9518  {
9519  Py_CLEAR( tmp3 );
9520  }
9521  return resultobj;
9522 fail:
9523  {
9524  Py_CLEAR( tmp1 );
9525  }
9526  {
9527  Py_CLEAR( tmp3 );
9528  }
9529  return NULL;
9530 }
9531 
9532 
9533 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534  PyObject *resultobj = 0;
9535  PLINT arg1 ;
9536  PLFLT *arg2 = (PLFLT *) 0 ;
9537  PLFLT *arg3 = (PLFLT *) 0 ;
9538  PLFLT *arg4 = (PLFLT *) 0 ;
9539  PLINT arg5 ;
9540  PyArrayObject *tmp1 = NULL ;
9541  PyArrayObject *tmp3 = NULL ;
9542  PyArrayObject *tmp4 = NULL ;
9543  int val5 ;
9544  int ecode5 = 0 ;
9545  PyObject *swig_obj[4] ;
9546 
9547  if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
9548  {
9549  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9550  if ( tmp1 == NULL )
9551  return NULL;
9552  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9553  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9554  }
9555  {
9556  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9557  if ( tmp3 == NULL )
9558  return NULL;
9559  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9560  {
9561  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9562  return NULL;
9563  }
9564  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9565  }
9566  {
9567  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9568  if ( tmp4 == NULL )
9569  return NULL;
9570  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9571  {
9572  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9573  return NULL;
9574  }
9575  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9576  }
9577  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
9578  if (!SWIG_IsOK(ecode5)) {
9579  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9580  }
9581  arg5 = (PLINT)(val5);
9582  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9583  resultobj = SWIG_Py_Void();
9584  {
9585  Py_CLEAR( tmp1 );
9586  }
9587  {
9588  Py_CLEAR( tmp3 );
9589  }
9590  {
9591  Py_CLEAR( tmp4 );
9592  }
9593  return resultobj;
9594 fail:
9595  {
9596  Py_CLEAR( tmp1 );
9597  }
9598  {
9599  Py_CLEAR( tmp3 );
9600  }
9601  {
9602  Py_CLEAR( tmp4 );
9603  }
9604  return NULL;
9605 }
9606 
9607 
9608 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609  PyObject *resultobj = 0;
9610  PLINT arg1 ;
9611  PLFLT *arg2 = (PLFLT *) 0 ;
9612  PLFLT *arg3 = (PLFLT *) 0 ;
9613  PLFLT *arg4 = (PLFLT *) 0 ;
9614  PLBOOL *arg5 = (PLBOOL *) 0 ;
9615  PLBOOL arg6 ;
9616  PyArrayObject *tmp1 = NULL ;
9617  PyArrayObject *tmp3 = NULL ;
9618  PyArrayObject *tmp4 = NULL ;
9619  PyArrayObject *tmp5 = NULL ;
9620  int val6 ;
9621  int ecode6 = 0 ;
9622  PyObject *swig_obj[5] ;
9623 
9624  if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
9625  {
9626  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9627  if ( tmp1 == NULL )
9628  return NULL;
9629  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9630  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9631  }
9632  {
9633  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9634  if ( tmp3 == NULL )
9635  return NULL;
9636  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9637  {
9638  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9639  return NULL;
9640  }
9641  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9642  }
9643  {
9644  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9645  if ( tmp4 == NULL )
9646  return NULL;
9647  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9648  {
9649  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9650  return NULL;
9651  }
9652  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9653  }
9654  {
9655  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
9656  if ( tmp5 == NULL )
9657  return NULL;
9658  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9659  {
9660  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9661  return NULL;
9662  }
9663  arg5 = (PLINT *) PyArray_DATA( tmp5 );
9664  }
9665  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
9666  if (!SWIG_IsOK(ecode6)) {
9667  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9668  }
9669  arg6 = (PLBOOL)(val6);
9670  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9671  resultobj = SWIG_Py_Void();
9672  {
9673  Py_CLEAR( tmp1 );
9674  }
9675  {
9676  Py_CLEAR( tmp3 );
9677  }
9678  {
9679  Py_CLEAR( tmp4 );
9680  }
9681  {
9682  Py_CLEAR( tmp5 );
9683  }
9684  return resultobj;
9685 fail:
9686  {
9687  Py_CLEAR( tmp1 );
9688  }
9689  {
9690  Py_CLEAR( tmp3 );
9691  }
9692  {
9693  Py_CLEAR( tmp4 );
9694  }
9695  {
9696  Py_CLEAR( tmp5 );
9697  }
9698  return NULL;
9699 }
9700 
9701 
9702 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9703  PyObject *resultobj = 0;
9704  PLINT arg1 ;
9705  PLINT arg2 ;
9706  int val1 ;
9707  int ecode1 = 0 ;
9708  int val2 ;
9709  int ecode2 = 0 ;
9710  PyObject *swig_obj[2] ;
9711 
9712  if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
9713  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9714  if (!SWIG_IsOK(ecode1)) {
9715  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9716  }
9717  arg1 = (PLINT)(val1);
9718  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
9719  if (!SWIG_IsOK(ecode2)) {
9720  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
9721  }
9722  arg2 = (PLINT)(val2);
9723  plprec(arg1,arg2);
9724  resultobj = SWIG_Py_Void();
9725  return resultobj;
9726 fail:
9727  return NULL;
9728 }
9729 
9730 
9731 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9732  PyObject *resultobj = 0;
9733  PLINT arg1 ;
9734  int val1 ;
9735  int ecode1 = 0 ;
9736  PyObject *swig_obj[1] ;
9737 
9738  if (!args) SWIG_fail;
9739  swig_obj[0] = args;
9740  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9741  if (!SWIG_IsOK(ecode1)) {
9742  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
9743  }
9744  arg1 = (PLINT)(val1);
9745  plpsty(arg1);
9746  resultobj = SWIG_Py_Void();
9747  return resultobj;
9748 fail:
9749  return NULL;
9750 }
9751 
9752 
9753 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9754  PyObject *resultobj = 0;
9755  PLFLT arg1 ;
9756  PLFLT arg2 ;
9757  PLFLT arg3 ;
9758  PLFLT arg4 ;
9759  PLFLT arg5 ;
9760  char *arg6 = (char *) 0 ;
9761  double val1 ;
9762  int ecode1 = 0 ;
9763  double val2 ;
9764  int ecode2 = 0 ;
9765  double val3 ;
9766  int ecode3 = 0 ;
9767  double val4 ;
9768  int ecode4 = 0 ;
9769  double val5 ;
9770  int ecode5 = 0 ;
9771  int res6 ;
9772  char *buf6 = 0 ;
9773  int alloc6 = 0 ;
9774  PyObject *swig_obj[6] ;
9775 
9776  if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
9777  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9778  if (!SWIG_IsOK(ecode1)) {
9779  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
9780  }
9781  arg1 = (PLFLT)(val1);
9782  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9783  if (!SWIG_IsOK(ecode2)) {
9784  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
9785  }
9786  arg2 = (PLFLT)(val2);
9787  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9788  if (!SWIG_IsOK(ecode3)) {
9789  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
9790  }
9791  arg3 = (PLFLT)(val3);
9792  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9793  if (!SWIG_IsOK(ecode4)) {
9794  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
9795  }
9796  arg4 = (PLFLT)(val4);
9797  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9798  if (!SWIG_IsOK(ecode5)) {
9799  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
9800  }
9801  arg5 = (PLFLT)(val5);
9802  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
9803  if (!SWIG_IsOK(res6)) {
9804  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
9805  }
9806  arg6 = (char *)(buf6);
9807  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
9808  resultobj = SWIG_Py_Void();
9809  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9810  return resultobj;
9811 fail:
9812  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9813  return NULL;
9814 }
9815 
9816 
9817 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818  PyObject *resultobj = 0;
9819  PLFLT arg1 ;
9820  PLFLT arg2 ;
9821  PLFLT arg3 ;
9822  PLFLT arg4 ;
9823  PLFLT arg5 ;
9824  PLFLT arg6 ;
9825  PLFLT arg7 ;
9826  PLFLT arg8 ;
9827  PLFLT arg9 ;
9828  PLFLT arg10 ;
9829  char *arg11 = (char *) 0 ;
9830  double val1 ;
9831  int ecode1 = 0 ;
9832  double val2 ;
9833  int ecode2 = 0 ;
9834  double val3 ;
9835  int ecode3 = 0 ;
9836  double val4 ;
9837  int ecode4 = 0 ;
9838  double val5 ;
9839  int ecode5 = 0 ;
9840  double val6 ;
9841  int ecode6 = 0 ;
9842  double val7 ;
9843  int ecode7 = 0 ;
9844  double val8 ;
9845  int ecode8 = 0 ;
9846  double val9 ;
9847  int ecode9 = 0 ;
9848  double val10 ;
9849  int ecode10 = 0 ;
9850  int res11 ;
9851  char *buf11 = 0 ;
9852  int alloc11 = 0 ;
9853  PyObject *swig_obj[11] ;
9854 
9855  if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
9856  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9857  if (!SWIG_IsOK(ecode1)) {
9858  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
9859  }
9860  arg1 = (PLFLT)(val1);
9861  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9862  if (!SWIG_IsOK(ecode2)) {
9863  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
9864  }
9865  arg2 = (PLFLT)(val2);
9866  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9867  if (!SWIG_IsOK(ecode3)) {
9868  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
9869  }
9870  arg3 = (PLFLT)(val3);
9871  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9872  if (!SWIG_IsOK(ecode4)) {
9873  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
9874  }
9875  arg4 = (PLFLT)(val4);
9876  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9877  if (!SWIG_IsOK(ecode5)) {
9878  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
9879  }
9880  arg5 = (PLFLT)(val5);
9881  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
9882  if (!SWIG_IsOK(ecode6)) {
9883  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
9884  }
9885  arg6 = (PLFLT)(val6);
9886  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
9887  if (!SWIG_IsOK(ecode7)) {
9888  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
9889  }
9890  arg7 = (PLFLT)(val7);
9891  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
9892  if (!SWIG_IsOK(ecode8)) {
9893  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
9894  }
9895  arg8 = (PLFLT)(val8);
9896  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
9897  if (!SWIG_IsOK(ecode9)) {
9898  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
9899  }
9900  arg9 = (PLFLT)(val9);
9901  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
9902  if (!SWIG_IsOK(ecode10)) {
9903  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
9904  }
9905  arg10 = (PLFLT)(val10);
9906  res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
9907  if (!SWIG_IsOK(res11)) {
9908  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
9909  }
9910  arg11 = (char *)(buf11);
9911  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
9912  resultobj = SWIG_Py_Void();
9913  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9914  return resultobj;
9915 fail:
9916  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9917  return NULL;
9918 }
9919 
9920 
9921 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9922  PyObject *resultobj = 0;
9923  PLFLT result;
9924 
9925  if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
9926  result = (PLFLT)plrandd();
9927  resultobj = SWIG_From_double((double)(result));
9928  return resultobj;
9929 fail:
9930  return NULL;
9931 }
9932 
9933 
9934 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935  PyObject *resultobj = 0;
9936 
9937  if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
9938  plreplot();
9939  resultobj = SWIG_Py_Void();
9940  return resultobj;
9941 fail:
9942  return NULL;
9943 }
9944 
9945 
9946 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947  PyObject *resultobj = 0;
9948  PLFLT arg1 ;
9949  PLFLT arg2 ;
9950  PLFLT arg3 ;
9951  PLFLT *arg4 = (PLFLT *) 0 ;
9952  PLFLT *arg5 = (PLFLT *) 0 ;
9953  PLFLT *arg6 = (PLFLT *) 0 ;
9954  double val1 ;
9955  int ecode1 = 0 ;
9956  double val2 ;
9957  int ecode2 = 0 ;
9958  double val3 ;
9959  int ecode3 = 0 ;
9960  PLFLT temp4 ;
9961  int res4 = SWIG_TMPOBJ ;
9962  PLFLT temp5 ;
9963  int res5 = SWIG_TMPOBJ ;
9964  PLFLT temp6 ;
9965  int res6 = SWIG_TMPOBJ ;
9966  PyObject *swig_obj[3] ;
9967 
9968  arg4 = &temp4;
9969  arg5 = &temp5;
9970  arg6 = &temp6;
9971  if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
9972  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9973  if (!SWIG_IsOK(ecode1)) {
9974  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
9975  }
9976  arg1 = (PLFLT)(val1);
9977  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9978  if (!SWIG_IsOK(ecode2)) {
9979  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
9980  }
9981  arg2 = (PLFLT)(val2);
9982  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9983  if (!SWIG_IsOK(ecode3)) {
9984  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
9985  }
9986  arg3 = (PLFLT)(val3);
9987  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
9988  resultobj = SWIG_Py_Void();
9989  if (SWIG_IsTmpObj(res4)) {
9990  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
9991  } else {
9992  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9993  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
9994  }
9995  if (SWIG_IsTmpObj(res5)) {
9996  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
9997  } else {
9998  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9999  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10000  }
10001  if (SWIG_IsTmpObj(res6)) {
10002  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10003  } else {
10004  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10005  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10006  }
10007  return resultobj;
10008 fail:
10009  return NULL;
10010 }
10011 
10012 
10013 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10014  PyObject *resultobj = 0;
10015  PLFLT arg1 ;
10016  PLFLT arg2 ;
10017  double val1 ;
10018  int ecode1 = 0 ;
10019  double val2 ;
10020  int ecode2 = 0 ;
10021  PyObject *swig_obj[2] ;
10022 
10023  if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10024  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10025  if (!SWIG_IsOK(ecode1)) {
10026  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10027  }
10028  arg1 = (PLFLT)(val1);
10029  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10030  if (!SWIG_IsOK(ecode2)) {
10031  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10032  }
10033  arg2 = (PLFLT)(val2);
10034  plschr(arg1,arg2);
10035  resultobj = SWIG_Py_Void();
10036  return resultobj;
10037 fail:
10038  return NULL;
10039 }
10040 
10041 
10042 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043  PyObject *resultobj = 0;
10044  PLINT *arg1 = (PLINT *) 0 ;
10045  PLINT *arg2 = (PLINT *) 0 ;
10046  PLINT *arg3 = (PLINT *) 0 ;
10047  PLINT arg4 ;
10048  PyArrayObject *tmp1 = NULL ;
10049  PyArrayObject *tmp2 = NULL ;
10050  PyArrayObject *tmp3 = NULL ;
10051  PyObject *swig_obj[3] ;
10052 
10053  if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10054  {
10055  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10056  if ( tmp1 == NULL )
10057  return NULL;
10058  Alen = PyArray_DIMS( tmp1 )[0];
10059  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10060  }
10061  {
10062  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10063  if ( tmp2 == NULL )
10064  return NULL;
10065  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10066  {
10067  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10068  return NULL;
10069  }
10070  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10071  }
10072  {
10073  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10074  if ( tmp3 == NULL )
10075  return NULL;
10076  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10077  {
10078  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10079  return NULL;
10080  }
10081  arg4 = PyArray_DIMS( tmp3 )[0];
10082  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10083  }
10084  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10085  resultobj = SWIG_Py_Void();
10086  {
10087  Py_CLEAR( tmp1 );
10088  }
10089  {
10090  Py_CLEAR( tmp2 );
10091  }
10092  {
10093  Py_CLEAR( tmp3 );
10094  }
10095  return resultobj;
10096 fail:
10097  {
10098  Py_CLEAR( tmp1 );
10099  }
10100  {
10101  Py_CLEAR( tmp2 );
10102  }
10103  {
10104  Py_CLEAR( tmp3 );
10105  }
10106  return NULL;
10107 }
10108 
10109 
10110 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10111  PyObject *resultobj = 0;
10112  PLINT *arg1 = (PLINT *) 0 ;
10113  PLINT *arg2 = (PLINT *) 0 ;
10114  PLINT *arg3 = (PLINT *) 0 ;
10115  PLFLT *arg4 = (PLFLT *) 0 ;
10116  PLINT arg5 ;
10117  PyArrayObject *tmp1 = NULL ;
10118  PyArrayObject *tmp2 = NULL ;
10119  PyArrayObject *tmp3 = NULL ;
10120  PyArrayObject *tmp4 = NULL ;
10121  PyObject *swig_obj[4] ;
10122 
10123  if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10124  {
10125  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10126  if ( tmp1 == NULL )
10127  return NULL;
10128  Alen = PyArray_DIMS( tmp1 )[0];
10129  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10130  }
10131  {
10132  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10133  if ( tmp2 == NULL )
10134  return NULL;
10135  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10136  {
10137  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10138  return NULL;
10139  }
10140  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10141  }
10142  {
10143  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10144  if ( tmp3 == NULL )
10145  return NULL;
10146  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10147  {
10148  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10149  return NULL;
10150  }
10151  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10152  }
10153  {
10154  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10155  if ( tmp4 == NULL )
10156  return NULL;
10157  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10158  {
10159  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10160  return NULL;
10161  }
10162  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10163  arg5 = PyArray_DIMS( tmp4 )[0];
10164  }
10165  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10166  resultobj = SWIG_Py_Void();
10167  {
10168  Py_CLEAR( tmp1 );
10169  }
10170  {
10171  Py_CLEAR( tmp2 );
10172  }
10173  {
10174  Py_CLEAR( tmp3 );
10175  }
10176  {
10177  Py_CLEAR( tmp4 );
10178  }
10179  return resultobj;
10180 fail:
10181  {
10182  Py_CLEAR( tmp1 );
10183  }
10184  {
10185  Py_CLEAR( tmp2 );
10186  }
10187  {
10188  Py_CLEAR( tmp3 );
10189  }
10190  {
10191  Py_CLEAR( tmp4 );
10192  }
10193  return NULL;
10194 }
10195 
10196 
10197 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198  PyObject *resultobj = 0;
10199  PLINT arg1 ;
10200  int val1 ;
10201  int ecode1 = 0 ;
10202  PyObject *swig_obj[1] ;
10203 
10204  if (!args) SWIG_fail;
10205  swig_obj[0] = args;
10206  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10207  if (!SWIG_IsOK(ecode1)) {
10208  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10209  }
10210  arg1 = (PLINT)(val1);
10211  plscmap0n(arg1);
10212  resultobj = SWIG_Py_Void();
10213  return resultobj;
10214 fail:
10215  return NULL;
10216 }
10217 
10218 
10219 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10220  PyObject *resultobj = 0;
10221  PLINT *arg1 = (PLINT *) 0 ;
10222  PLINT *arg2 = (PLINT *) 0 ;
10223  PLINT *arg3 = (PLINT *) 0 ;
10224  PLINT arg4 ;
10225  PyArrayObject *tmp1 = NULL ;
10226  PyArrayObject *tmp2 = NULL ;
10227  PyArrayObject *tmp3 = NULL ;
10228  PyObject *swig_obj[3] ;
10229 
10230  if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10231  {
10232  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10233  if ( tmp1 == NULL )
10234  return NULL;
10235  Alen = PyArray_DIMS( tmp1 )[0];
10236  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10237  }
10238  {
10239  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10240  if ( tmp2 == NULL )
10241  return NULL;
10242  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10243  {
10244  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10245  return NULL;
10246  }
10247  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10248  }
10249  {
10250  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10251  if ( tmp3 == NULL )
10252  return NULL;
10253  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10254  {
10255  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10256  return NULL;
10257  }
10258  arg4 = PyArray_DIMS( tmp3 )[0];
10259  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10260  }
10261  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10262  resultobj = SWIG_Py_Void();
10263  {
10264  Py_CLEAR( tmp1 );
10265  }
10266  {
10267  Py_CLEAR( tmp2 );
10268  }
10269  {
10270  Py_CLEAR( tmp3 );
10271  }
10272  return resultobj;
10273 fail:
10274  {
10275  Py_CLEAR( tmp1 );
10276  }
10277  {
10278  Py_CLEAR( tmp2 );
10279  }
10280  {
10281  Py_CLEAR( tmp3 );
10282  }
10283  return NULL;
10284 }
10285 
10286 
10287 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10288  PyObject *resultobj = 0;
10289  PLINT *arg1 = (PLINT *) 0 ;
10290  PLINT *arg2 = (PLINT *) 0 ;
10291  PLINT *arg3 = (PLINT *) 0 ;
10292  PLFLT *arg4 = (PLFLT *) 0 ;
10293  PLINT arg5 ;
10294  PyArrayObject *tmp1 = NULL ;
10295  PyArrayObject *tmp2 = NULL ;
10296  PyArrayObject *tmp3 = NULL ;
10297  PyArrayObject *tmp4 = NULL ;
10298  PyObject *swig_obj[4] ;
10299 
10300  if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10301  {
10302  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10303  if ( tmp1 == NULL )
10304  return NULL;
10305  Alen = PyArray_DIMS( tmp1 )[0];
10306  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10307  }
10308  {
10309  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10310  if ( tmp2 == NULL )
10311  return NULL;
10312  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10313  {
10314  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10315  return NULL;
10316  }
10317  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10318  }
10319  {
10320  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10321  if ( tmp3 == NULL )
10322  return NULL;
10323  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10324  {
10325  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10326  return NULL;
10327  }
10328  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10329  }
10330  {
10331  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10332  if ( tmp4 == NULL )
10333  return NULL;
10334  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10335  {
10336  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10337  return NULL;
10338  }
10339  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10340  arg5 = PyArray_DIMS( tmp4 )[0];
10341  }
10342  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10343  resultobj = SWIG_Py_Void();
10344  {
10345  Py_CLEAR( tmp1 );
10346  }
10347  {
10348  Py_CLEAR( tmp2 );
10349  }
10350  {
10351  Py_CLEAR( tmp3 );
10352  }
10353  {
10354  Py_CLEAR( tmp4 );
10355  }
10356  return resultobj;
10357 fail:
10358  {
10359  Py_CLEAR( tmp1 );
10360  }
10361  {
10362  Py_CLEAR( tmp2 );
10363  }
10364  {
10365  Py_CLEAR( tmp3 );
10366  }
10367  {
10368  Py_CLEAR( tmp4 );
10369  }
10370  return NULL;
10371 }
10372 
10373 
10374 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10375  PyObject *resultobj = 0;
10376  PLBOOL arg1 ;
10377  PLINT arg2 ;
10378  PLFLT *arg3 = (PLFLT *) 0 ;
10379  PLFLT *arg4 = (PLFLT *) 0 ;
10380  PLFLT *arg5 = (PLFLT *) 0 ;
10381  PLFLT *arg6 = (PLFLT *) 0 ;
10382  PLBOOL *arg7 = (PLBOOL *) 0 ;
10383  int val1 ;
10384  int ecode1 = 0 ;
10385  PyArrayObject *tmp2 = NULL ;
10386  PyArrayObject *tmp4 = NULL ;
10387  PyArrayObject *tmp5 = NULL ;
10388  PyArrayObject *tmp6 = NULL ;
10389  PyArrayObject *tmp7 = NULL ;
10390  PyObject *swig_obj[6] ;
10391 
10392  if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
10393  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10394  if (!SWIG_IsOK(ecode1)) {
10395  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10396  }
10397  arg1 = (PLBOOL)(val1);
10398  {
10399  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10400  if ( tmp2 == NULL )
10401  return NULL;
10402  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10403  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10404  }
10405  {
10406  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10407  if ( tmp4 == NULL )
10408  return NULL;
10409  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10410  {
10411  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10412  return NULL;
10413  }
10414  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10415  }
10416  {
10417  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10418  if ( tmp5 == NULL )
10419  return NULL;
10420  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10421  {
10422  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10423  return NULL;
10424  }
10425  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10426  }
10427  {
10428  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10429  if ( tmp6 == NULL )
10430  return NULL;
10431  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10432  {
10433  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10434  return NULL;
10435  }
10436  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10437  }
10438  {
10439  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
10440  if ( tmp7 == NULL )
10441  return NULL;
10442  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10443  {
10444  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10445  return NULL;
10446  }
10447  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10448  }
10449  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10450  resultobj = SWIG_Py_Void();
10451  {
10452  Py_CLEAR( tmp2 );
10453  }
10454  {
10455  Py_CLEAR( tmp4 );
10456  }
10457  {
10458  Py_CLEAR( tmp5 );
10459  }
10460  {
10461  Py_CLEAR( tmp6 );
10462  }
10463  {
10464  Py_CLEAR( tmp7 );
10465  }
10466  return resultobj;
10467 fail:
10468  {
10469  Py_CLEAR( tmp2 );
10470  }
10471  {
10472  Py_CLEAR( tmp4 );
10473  }
10474  {
10475  Py_CLEAR( tmp5 );
10476  }
10477  {
10478  Py_CLEAR( tmp6 );
10479  }
10480  {
10481  Py_CLEAR( tmp7 );
10482  }
10483  return NULL;
10484 }
10485 
10486 
10487 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10488  PyObject *resultobj = 0;
10489  PLBOOL arg1 ;
10490  PLINT arg2 ;
10491  PLFLT *arg3 = (PLFLT *) 0 ;
10492  PLFLT *arg4 = (PLFLT *) 0 ;
10493  PLFLT *arg5 = (PLFLT *) 0 ;
10494  PLFLT *arg6 = (PLFLT *) 0 ;
10495  PLFLT *arg7 = (PLFLT *) 0 ;
10496  PLBOOL *arg8 = (PLBOOL *) 0 ;
10497  int val1 ;
10498  int ecode1 = 0 ;
10499  PyArrayObject *tmp2 = NULL ;
10500  PyArrayObject *tmp4 = NULL ;
10501  PyArrayObject *tmp5 = NULL ;
10502  PyArrayObject *tmp6 = NULL ;
10503  PyArrayObject *tmp7 = NULL ;
10504  PyArrayObject *tmp8 = NULL ;
10505  PyObject *swig_obj[7] ;
10506 
10507  if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
10508  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10509  if (!SWIG_IsOK(ecode1)) {
10510  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10511  }
10512  arg1 = (PLBOOL)(val1);
10513  {
10514  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10515  if ( tmp2 == NULL )
10516  return NULL;
10517  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10518  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10519  }
10520  {
10521  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10522  if ( tmp4 == NULL )
10523  return NULL;
10524  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10525  {
10526  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10527  return NULL;
10528  }
10529  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10530  }
10531  {
10532  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10533  if ( tmp5 == NULL )
10534  return NULL;
10535  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10536  {
10537  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10538  return NULL;
10539  }
10540  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10541  }
10542  {
10543  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10544  if ( tmp6 == NULL )
10545  return NULL;
10546  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10547  {
10548  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10549  return NULL;
10550  }
10551  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10552  }
10553  {
10554  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
10555  if ( tmp7 == NULL )
10556  return NULL;
10557  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10558  {
10559  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10560  return NULL;
10561  }
10562  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10563  }
10564  {
10565  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
10566  if ( tmp8 == NULL )
10567  return NULL;
10568  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10569  {
10570  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10571  return NULL;
10572  }
10573  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10574  }
10575  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10576  resultobj = SWIG_Py_Void();
10577  {
10578  Py_CLEAR( tmp2 );
10579  }
10580  {
10581  Py_CLEAR( tmp4 );
10582  }
10583  {
10584  Py_CLEAR( tmp5 );
10585  }
10586  {
10587  Py_CLEAR( tmp6 );
10588  }
10589  {
10590  Py_CLEAR( tmp7 );
10591  }
10592  {
10593  Py_CLEAR( tmp8 );
10594  }
10595  return resultobj;
10596 fail:
10597  {
10598  Py_CLEAR( tmp2 );
10599  }
10600  {
10601  Py_CLEAR( tmp4 );
10602  }
10603  {
10604  Py_CLEAR( tmp5 );
10605  }
10606  {
10607  Py_CLEAR( tmp6 );
10608  }
10609  {
10610  Py_CLEAR( tmp7 );
10611  }
10612  {
10613  Py_CLEAR( tmp8 );
10614  }
10615  return NULL;
10616 }
10617 
10618 
10619 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10620  PyObject *resultobj = 0;
10621  PLINT arg1 ;
10622  int val1 ;
10623  int ecode1 = 0 ;
10624  PyObject *swig_obj[1] ;
10625 
10626  if (!args) SWIG_fail;
10627  swig_obj[0] = args;
10628  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10629  if (!SWIG_IsOK(ecode1)) {
10630  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10631  }
10632  arg1 = (PLINT)(val1);
10633  plscmap1n(arg1);
10634  resultobj = SWIG_Py_Void();
10635  return resultobj;
10636 fail:
10637  return NULL;
10638 }
10639 
10640 
10641 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10642  PyObject *resultobj = 0;
10643  PLFLT arg1 ;
10644  PLFLT arg2 ;
10645  double val1 ;
10646  int ecode1 = 0 ;
10647  double val2 ;
10648  int ecode2 = 0 ;
10649  PyObject *swig_obj[2] ;
10650 
10651  if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
10652  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10653  if (!SWIG_IsOK(ecode1)) {
10654  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10655  }
10656  arg1 = (PLFLT)(val1);
10657  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10658  if (!SWIG_IsOK(ecode2)) {
10659  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10660  }
10661  arg2 = (PLFLT)(val2);
10662  plscmap1_range(arg1,arg2);
10663  resultobj = SWIG_Py_Void();
10664  return resultobj;
10665 fail:
10666  return NULL;
10667 }
10668 
10669 
10670 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10671  PyObject *resultobj = 0;
10672  PLFLT *arg1 = (PLFLT *) 0 ;
10673  PLFLT *arg2 = (PLFLT *) 0 ;
10674  PLFLT temp1 ;
10675  int res1 = SWIG_TMPOBJ ;
10676  PLFLT temp2 ;
10677  int res2 = SWIG_TMPOBJ ;
10678 
10679  arg1 = &temp1;
10680  arg2 = &temp2;
10681  if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
10682  plgcmap1_range(arg1,arg2);
10683  resultobj = SWIG_Py_Void();
10684  if (SWIG_IsTmpObj(res1)) {
10685  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
10686  } else {
10687  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10688  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10689  }
10690  if (SWIG_IsTmpObj(res2)) {
10691  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
10692  } else {
10693  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10694  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10695  }
10696  return resultobj;
10697 fail:
10698  return NULL;
10699 }
10700 
10701 
10702 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10703  PyObject *resultobj = 0;
10704  PLINT arg1 ;
10705  PLINT arg2 ;
10706  PLINT arg3 ;
10707  PLINT arg4 ;
10708  int val1 ;
10709  int ecode1 = 0 ;
10710  int val2 ;
10711  int ecode2 = 0 ;
10712  int val3 ;
10713  int ecode3 = 0 ;
10714  int val4 ;
10715  int ecode4 = 0 ;
10716  PyObject *swig_obj[4] ;
10717 
10718  if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
10719  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10720  if (!SWIG_IsOK(ecode1)) {
10721  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10722  }
10723  arg1 = (PLINT)(val1);
10724  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10725  if (!SWIG_IsOK(ecode2)) {
10726  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10727  }
10728  arg2 = (PLINT)(val2);
10729  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10730  if (!SWIG_IsOK(ecode3)) {
10731  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10732  }
10733  arg3 = (PLINT)(val3);
10734  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10735  if (!SWIG_IsOK(ecode4)) {
10736  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10737  }
10738  arg4 = (PLINT)(val4);
10739  plscol0(arg1,arg2,arg3,arg4);
10740  resultobj = SWIG_Py_Void();
10741  return resultobj;
10742 fail:
10743  return NULL;
10744 }
10745 
10746 
10747 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10748  PyObject *resultobj = 0;
10749  PLINT arg1 ;
10750  PLINT arg2 ;
10751  PLINT arg3 ;
10752  PLINT arg4 ;
10753  PLFLT arg5 ;
10754  int val1 ;
10755  int ecode1 = 0 ;
10756  int val2 ;
10757  int ecode2 = 0 ;
10758  int val3 ;
10759  int ecode3 = 0 ;
10760  int val4 ;
10761  int ecode4 = 0 ;
10762  double val5 ;
10763  int ecode5 = 0 ;
10764  PyObject *swig_obj[5] ;
10765 
10766  if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
10767  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10768  if (!SWIG_IsOK(ecode1)) {
10769  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10770  }
10771  arg1 = (PLINT)(val1);
10772  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10773  if (!SWIG_IsOK(ecode2)) {
10774  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10775  }
10776  arg2 = (PLINT)(val2);
10777  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10778  if (!SWIG_IsOK(ecode3)) {
10779  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10780  }
10781  arg3 = (PLINT)(val3);
10782  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10783  if (!SWIG_IsOK(ecode4)) {
10784  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10785  }
10786  arg4 = (PLINT)(val4);
10787  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10788  if (!SWIG_IsOK(ecode5)) {
10789  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10790  }
10791  arg5 = (PLFLT)(val5);
10792  plscol0a(arg1,arg2,arg3,arg4,arg5);
10793  resultobj = SWIG_Py_Void();
10794  return resultobj;
10795 fail:
10796  return NULL;
10797 }
10798 
10799 
10800 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10801  PyObject *resultobj = 0;
10802  PLINT arg1 ;
10803  PLINT arg2 ;
10804  PLINT arg3 ;
10805  int val1 ;
10806  int ecode1 = 0 ;
10807  int val2 ;
10808  int ecode2 = 0 ;
10809  int val3 ;
10810  int ecode3 = 0 ;
10811  PyObject *swig_obj[3] ;
10812 
10813  if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
10814  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10815  if (!SWIG_IsOK(ecode1)) {
10816  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10817  }
10818  arg1 = (PLINT)(val1);
10819  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10820  if (!SWIG_IsOK(ecode2)) {
10821  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10822  }
10823  arg2 = (PLINT)(val2);
10824  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10825  if (!SWIG_IsOK(ecode3)) {
10826  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10827  }
10828  arg3 = (PLINT)(val3);
10829  plscolbg(arg1,arg2,arg3);
10830  resultobj = SWIG_Py_Void();
10831  return resultobj;
10832 fail:
10833  return NULL;
10834 }
10835 
10836 
10837 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10838  PyObject *resultobj = 0;
10839  PLINT arg1 ;
10840  PLINT arg2 ;
10841  PLINT arg3 ;
10842  PLFLT arg4 ;
10843  int val1 ;
10844  int ecode1 = 0 ;
10845  int val2 ;
10846  int ecode2 = 0 ;
10847  int val3 ;
10848  int ecode3 = 0 ;
10849  double val4 ;
10850  int ecode4 = 0 ;
10851  PyObject *swig_obj[4] ;
10852 
10853  if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
10854  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10855  if (!SWIG_IsOK(ecode1)) {
10856  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10857  }
10858  arg1 = (PLINT)(val1);
10859  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10860  if (!SWIG_IsOK(ecode2)) {
10861  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10862  }
10863  arg2 = (PLINT)(val2);
10864  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10865  if (!SWIG_IsOK(ecode3)) {
10866  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10867  }
10868  arg3 = (PLINT)(val3);
10869  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10870  if (!SWIG_IsOK(ecode4)) {
10871  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10872  }
10873  arg4 = (PLFLT)(val4);
10874  plscolbga(arg1,arg2,arg3,arg4);
10875  resultobj = SWIG_Py_Void();
10876  return resultobj;
10877 fail:
10878  return NULL;
10879 }
10880 
10881 
10882 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10883  PyObject *resultobj = 0;
10884  PLINT arg1 ;
10885  int val1 ;
10886  int ecode1 = 0 ;
10887  PyObject *swig_obj[1] ;
10888 
10889  if (!args) SWIG_fail;
10890  swig_obj[0] = args;
10891  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10892  if (!SWIG_IsOK(ecode1)) {
10893  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10894  }
10895  arg1 = (PLINT)(val1);
10896  plscolor(arg1);
10897  resultobj = SWIG_Py_Void();
10898  return resultobj;
10899 fail:
10900  return NULL;
10901 }
10902 
10903 
10904 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905  PyObject *resultobj = 0;
10906  PLINT arg1 ;
10907  int val1 ;
10908  int ecode1 = 0 ;
10909  PyObject *swig_obj[1] ;
10910 
10911  if (!args) SWIG_fail;
10912  swig_obj[0] = args;
10913  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10914  if (!SWIG_IsOK(ecode1)) {
10915  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10916  }
10917  arg1 = (PLINT)(val1);
10918  plscompression(arg1);
10919  resultobj = SWIG_Py_Void();
10920  return resultobj;
10921 fail:
10922  return NULL;
10923 }
10924 
10925 
10926 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10927  PyObject *resultobj = 0;
10928  char *arg1 = (char *) 0 ;
10929  int res1 ;
10930  char *buf1 = 0 ;
10931  int alloc1 = 0 ;
10932  PyObject *swig_obj[1] ;
10933 
10934  if (!args) SWIG_fail;
10935  swig_obj[0] = args;
10936  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10937  if (!SWIG_IsOK(res1)) {
10938  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10939  }
10940  arg1 = (char *)(buf1);
10941  plsdev((char const *)arg1);
10942  resultobj = SWIG_Py_Void();
10943  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10944  return resultobj;
10945 fail:
10946  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10947  return NULL;
10948 }
10949 
10950 
10951 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952  PyObject *resultobj = 0;
10953  PLFLT arg1 ;
10954  PLFLT arg2 ;
10955  PLFLT arg3 ;
10956  PLFLT arg4 ;
10957  double val1 ;
10958  int ecode1 = 0 ;
10959  double val2 ;
10960  int ecode2 = 0 ;
10961  double val3 ;
10962  int ecode3 = 0 ;
10963  double val4 ;
10964  int ecode4 = 0 ;
10965  PyObject *swig_obj[4] ;
10966 
10967  if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
10968  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10969  if (!SWIG_IsOK(ecode1)) {
10970  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10971  }
10972  arg1 = (PLFLT)(val1);
10973  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10974  if (!SWIG_IsOK(ecode2)) {
10975  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10976  }
10977  arg2 = (PLFLT)(val2);
10978  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10979  if (!SWIG_IsOK(ecode3)) {
10980  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10981  }
10982  arg3 = (PLFLT)(val3);
10983  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10984  if (!SWIG_IsOK(ecode4)) {
10985  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10986  }
10987  arg4 = (PLFLT)(val4);
10988  plsdidev(arg1,arg2,arg3,arg4);
10989  resultobj = SWIG_Py_Void();
10990  return resultobj;
10991 fail:
10992  return NULL;
10993 }
10994 
10995 
10996 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10997  PyObject *resultobj = 0;
10998  PLINT arg1 ;
10999  PLINT arg2 ;
11000  PLINT arg3 ;
11001  PLINT arg4 ;
11002  PLFLT arg5 ;
11003  PLFLT arg6 ;
11004  int val1 ;
11005  int ecode1 = 0 ;
11006  int val2 ;
11007  int ecode2 = 0 ;
11008  int val3 ;
11009  int ecode3 = 0 ;
11010  int val4 ;
11011  int ecode4 = 0 ;
11012  double val5 ;
11013  int ecode5 = 0 ;
11014  double val6 ;
11015  int ecode6 = 0 ;
11016  PyObject *swig_obj[6] ;
11017 
11018  if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11019  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11020  if (!SWIG_IsOK(ecode1)) {
11021  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11022  }
11023  arg1 = (PLINT)(val1);
11024  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11025  if (!SWIG_IsOK(ecode2)) {
11026  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11027  }
11028  arg2 = (PLINT)(val2);
11029  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11030  if (!SWIG_IsOK(ecode3)) {
11031  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11032  }
11033  arg3 = (PLINT)(val3);
11034  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11035  if (!SWIG_IsOK(ecode4)) {
11036  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11037  }
11038  arg4 = (PLINT)(val4);
11039  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11040  if (!SWIG_IsOK(ecode5)) {
11041  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11042  }
11043  arg5 = (PLFLT)(val5);
11044  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11045  if (!SWIG_IsOK(ecode6)) {
11046  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11047  }
11048  arg6 = (PLFLT)(val6);
11049  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11050  resultobj = SWIG_Py_Void();
11051  return resultobj;
11052 fail:
11053  return NULL;
11054 }
11055 
11056 
11057 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11058  PyObject *resultobj = 0;
11059  PLFLT arg1 ;
11060  double val1 ;
11061  int ecode1 = 0 ;
11062  PyObject *swig_obj[1] ;
11063 
11064  if (!args) SWIG_fail;
11065  swig_obj[0] = args;
11066  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11067  if (!SWIG_IsOK(ecode1)) {
11068  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11069  }
11070  arg1 = (PLFLT)(val1);
11071  plsdiori(arg1);
11072  resultobj = SWIG_Py_Void();
11073  return resultobj;
11074 fail:
11075  return NULL;
11076 }
11077 
11078 
11079 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11080  PyObject *resultobj = 0;
11081  PLFLT arg1 ;
11082  PLFLT arg2 ;
11083  PLFLT arg3 ;
11084  PLFLT arg4 ;
11085  double val1 ;
11086  int ecode1 = 0 ;
11087  double val2 ;
11088  int ecode2 = 0 ;
11089  double val3 ;
11090  int ecode3 = 0 ;
11091  double val4 ;
11092  int ecode4 = 0 ;
11093  PyObject *swig_obj[4] ;
11094 
11095  if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11096  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11097  if (!SWIG_IsOK(ecode1)) {
11098  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11099  }
11100  arg1 = (PLFLT)(val1);
11101  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11102  if (!SWIG_IsOK(ecode2)) {
11103  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11104  }
11105  arg2 = (PLFLT)(val2);
11106  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11107  if (!SWIG_IsOK(ecode3)) {
11108  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11109  }
11110  arg3 = (PLFLT)(val3);
11111  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11112  if (!SWIG_IsOK(ecode4)) {
11113  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11114  }
11115  arg4 = (PLFLT)(val4);
11116  plsdiplt(arg1,arg2,arg3,arg4);
11117  resultobj = SWIG_Py_Void();
11118  return resultobj;
11119 fail:
11120  return NULL;
11121 }
11122 
11123 
11124 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125  PyObject *resultobj = 0;
11126  PLFLT arg1 ;
11127  PLFLT arg2 ;
11128  PLFLT arg3 ;
11129  PLFLT arg4 ;
11130  double val1 ;
11131  int ecode1 = 0 ;
11132  double val2 ;
11133  int ecode2 = 0 ;
11134  double val3 ;
11135  int ecode3 = 0 ;
11136  double val4 ;
11137  int ecode4 = 0 ;
11138  PyObject *swig_obj[4] ;
11139 
11140  if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11141  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11142  if (!SWIG_IsOK(ecode1)) {
11143  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11144  }
11145  arg1 = (PLFLT)(val1);
11146  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11147  if (!SWIG_IsOK(ecode2)) {
11148  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11149  }
11150  arg2 = (PLFLT)(val2);
11151  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11152  if (!SWIG_IsOK(ecode3)) {
11153  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11154  }
11155  arg3 = (PLFLT)(val3);
11156  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11157  if (!SWIG_IsOK(ecode4)) {
11158  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11159  }
11160  arg4 = (PLFLT)(val4);
11161  plsdiplz(arg1,arg2,arg3,arg4);
11162  resultobj = SWIG_Py_Void();
11163  return resultobj;
11164 fail:
11165  return NULL;
11166 }
11167 
11168 
11169 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11170  PyObject *resultobj = 0;
11171  unsigned int arg1 ;
11172  unsigned int val1 ;
11173  int ecode1 = 0 ;
11174  PyObject *swig_obj[1] ;
11175 
11176  if (!args) SWIG_fail;
11177  swig_obj[0] = args;
11178  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11179  if (!SWIG_IsOK(ecode1)) {
11180  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11181  }
11182  arg1 = (unsigned int)(val1);
11183  plseed(arg1);
11184  resultobj = SWIG_Py_Void();
11185  return resultobj;
11186 fail:
11187  return NULL;
11188 }
11189 
11190 
11191 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11192  PyObject *resultobj = 0;
11193  char arg1 ;
11194  char val1 ;
11195  int ecode1 = 0 ;
11196  PyObject *swig_obj[1] ;
11197 
11198  if (!args) SWIG_fail;
11199  swig_obj[0] = args;
11200  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11201  if (!SWIG_IsOK(ecode1)) {
11202  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11203  }
11204  arg1 = (char)(val1);
11205  plsesc(arg1);
11206  resultobj = SWIG_Py_Void();
11207  return resultobj;
11208 fail:
11209  return NULL;
11210 }
11211 
11212 
11213 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11214  PyObject *resultobj = 0;
11215  char *arg1 = (char *) 0 ;
11216  char *arg2 = (char *) 0 ;
11217  int res1 ;
11218  char *buf1 = 0 ;
11219  int alloc1 = 0 ;
11220  int res2 ;
11221  char *buf2 = 0 ;
11222  int alloc2 = 0 ;
11223  PyObject *swig_obj[2] ;
11224  PLINT result;
11225 
11226  if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11227  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11228  if (!SWIG_IsOK(res1)) {
11229  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11230  }
11231  arg1 = (char *)(buf1);
11232  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11233  if (!SWIG_IsOK(res2)) {
11234  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11235  }
11236  arg2 = (char *)(buf2);
11237  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11238  resultobj = SWIG_From_int((int)(result));
11239  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11240  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11241  return resultobj;
11242 fail:
11243  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11244  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11245  return NULL;
11246 }
11247 
11248 
11249 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250  PyObject *resultobj = 0;
11251  PLINT arg1 ;
11252  PLINT arg2 ;
11253  PLINT arg3 ;
11254  int val1 ;
11255  int ecode1 = 0 ;
11256  int val2 ;
11257  int ecode2 = 0 ;
11258  int val3 ;
11259  int ecode3 = 0 ;
11260  PyObject *swig_obj[3] ;
11261 
11262  if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11263  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11264  if (!SWIG_IsOK(ecode1)) {
11265  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11266  }
11267  arg1 = (PLINT)(val1);
11268  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11269  if (!SWIG_IsOK(ecode2)) {
11270  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11271  }
11272  arg2 = (PLINT)(val2);
11273  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11274  if (!SWIG_IsOK(ecode3)) {
11275  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11276  }
11277  arg3 = (PLINT)(val3);
11278  plsfam(arg1,arg2,arg3);
11279  resultobj = SWIG_Py_Void();
11280  return resultobj;
11281 fail:
11282  return NULL;
11283 }
11284 
11285 
11286 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11287  PyObject *resultobj = 0;
11288  PLUNICODE arg1 ;
11289  unsigned int val1 ;
11290  int ecode1 = 0 ;
11291  PyObject *swig_obj[1] ;
11292 
11293  if (!args) SWIG_fail;
11294  swig_obj[0] = args;
11295  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11296  if (!SWIG_IsOK(ecode1)) {
11297  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11298  }
11299  arg1 = (PLUNICODE)(val1);
11300  plsfci(arg1);
11301  resultobj = SWIG_Py_Void();
11302  return resultobj;
11303 fail:
11304  return NULL;
11305 }
11306 
11307 
11308 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11309  PyObject *resultobj = 0;
11310  char *arg1 = (char *) 0 ;
11311  int res1 ;
11312  char *buf1 = 0 ;
11313  int alloc1 = 0 ;
11314  PyObject *swig_obj[1] ;
11315 
11316  if (!args) SWIG_fail;
11317  swig_obj[0] = args;
11318  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11319  if (!SWIG_IsOK(res1)) {
11320  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11321  }
11322  arg1 = (char *)(buf1);
11323  plsfnam((char const *)arg1);
11324  resultobj = SWIG_Py_Void();
11325  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11326  return resultobj;
11327 fail:
11328  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11329  return NULL;
11330 }
11331 
11332 
11333 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334  PyObject *resultobj = 0;
11335  PLINT arg1 ;
11336  PLINT arg2 ;
11337  PLINT arg3 ;
11338  int val1 ;
11339  int ecode1 = 0 ;
11340  int val2 ;
11341  int ecode2 = 0 ;
11342  int val3 ;
11343  int ecode3 = 0 ;
11344  PyObject *swig_obj[3] ;
11345 
11346  if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11347  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11348  if (!SWIG_IsOK(ecode1)) {
11349  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11350  }
11351  arg1 = (PLINT)(val1);
11352  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11353  if (!SWIG_IsOK(ecode2)) {
11354  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11355  }
11356  arg2 = (PLINT)(val2);
11357  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11358  if (!SWIG_IsOK(ecode3)) {
11359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11360  }
11361  arg3 = (PLINT)(val3);
11362  plsfont(arg1,arg2,arg3);
11363  resultobj = SWIG_Py_Void();
11364  return resultobj;
11365 fail:
11366  return NULL;
11367 }
11368 
11369 
11370 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371  PyObject *resultobj = 0;
11372  PLFLT **arg1 = (PLFLT **) 0 ;
11373  PLINT arg2 ;
11374  PLINT arg3 ;
11375  defined_func arg4 = (defined_func) 0 ;
11376  PLFLT arg5 ;
11377  PLFLT arg6 ;
11378  PLFLT arg7 ;
11379  PLFLT arg8 ;
11380  PLFLT *arg9 = (PLFLT *) 0 ;
11381  PLINT arg10 ;
11382  PLFLT arg11 ;
11383  PLINT arg12 ;
11384  PLFLT arg13 ;
11385  fill_func arg14 = (fill_func) 0 ;
11386  PLBOOL arg15 ;
11387  pltr_func arg16 = (pltr_func) 0 ;
11388  PLPointer arg17 = (PLPointer) 0 ;
11389  PyArrayObject *tmp1 = NULL ;
11390  double val5 ;
11391  int ecode5 = 0 ;
11392  double val6 ;
11393  int ecode6 = 0 ;
11394  double val7 ;
11395  int ecode7 = 0 ;
11396  double val8 ;
11397  int ecode8 = 0 ;
11398  PyArrayObject *tmp9 = NULL ;
11399  double val11 ;
11400  int ecode11 = 0 ;
11401  int val12 ;
11402  int ecode12 = 0 ;
11403  double val13 ;
11404  int ecode13 = 0 ;
11405  int val15 ;
11406  int ecode15 = 0 ;
11407  PyObject *swig_obj[12] ;
11408 
11409  {
11410  python_pltr = 0;
11411  arg16 = NULL;
11412  }
11413  {
11414  arg17 = NULL;
11415  }
11416  {
11417  arg4 = NULL;
11418  }
11419  {
11420  arg14 = plfill;
11421  }
11422  if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
11423  {
11424  int i, size;
11425  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11426  if ( tmp1 == NULL )
11427  return NULL;
11428  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11429  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11430  size = arg3;
11431  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11432  for ( i = 0; i < arg2; i++ )
11433  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11434  }
11435  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11436  if (!SWIG_IsOK(ecode5)) {
11437  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11438  }
11439  arg5 = (PLFLT)(val5);
11440  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11441  if (!SWIG_IsOK(ecode6)) {
11442  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11443  }
11444  arg6 = (PLFLT)(val6);
11445  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11446  if (!SWIG_IsOK(ecode7)) {
11447  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11448  }
11449  arg7 = (PLFLT)(val7);
11450  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11451  if (!SWIG_IsOK(ecode8)) {
11452  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11453  }
11454  arg8 = (PLFLT)(val8);
11455  {
11456  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11457  if ( tmp9 == NULL )
11458  return NULL;
11459  arg10 = PyArray_DIMS( tmp9 )[0];
11460  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11461  }
11462  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
11463  if (!SWIG_IsOK(ecode11)) {
11464  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11465  }
11466  arg11 = (PLFLT)(val11);
11467  ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
11468  if (!SWIG_IsOK(ecode12)) {
11469  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11470  }
11471  arg12 = (PLINT)(val12);
11472  ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
11473  if (!SWIG_IsOK(ecode13)) {
11474  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11475  }
11476  arg13 = (PLFLT)(val13);
11477  ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
11478  if (!SWIG_IsOK(ecode15)) {
11479  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11480  }
11481  arg15 = (PLBOOL)(val15);
11482  if (swig_obj[10]) {
11483  {
11484  // it must be a callable or None
11485  if ( swig_obj[10] == Py_None )
11486  {
11487  arg16 = NULL;
11488  }
11489  else
11490  {
11491  if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
11492  {
11493  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11494  return NULL;
11495  }
11496  arg16 = marshal_pltr( swig_obj[10] );
11497  }
11498  }
11499  }
11500  if (swig_obj[11]) {
11501  {
11502  if ( swig_obj[11] == Py_None )
11503  arg17 = NULL;
11504  else
11505  {
11506  arg17 = marshal_PLPointer( swig_obj[11], 0 );
11507  }
11508  }
11509  }
11510  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11511  resultobj = SWIG_Py_Void();
11512  {
11513  Py_CLEAR( tmp1 );
11514  free( arg1 );
11515  }
11516  {
11517  Py_CLEAR( tmp9 );
11518  }
11519  {
11520  cleanup_pltr();
11521  }
11522  {
11524  }
11525  return resultobj;
11526 fail:
11527  {
11528  Py_CLEAR( tmp1 );
11529  free( arg1 );
11530  }
11531  {
11532  Py_CLEAR( tmp9 );
11533  }
11534  {
11535  cleanup_pltr();
11536  }
11537  {
11539  }
11540  return NULL;
11541 }
11542 
11543 
11544 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11545  PyObject *resultobj = 0;
11546  PLFLT **arg1 = (PLFLT **) 0 ;
11547  PLINT arg2 ;
11548  PLINT arg3 ;
11549  defined_func arg4 = (defined_func) 0 ;
11550  PLFLT arg5 ;
11551  PLFLT arg6 ;
11552  PLFLT arg7 ;
11553  PLFLT arg8 ;
11554  PLFLT arg9 ;
11555  PLFLT arg10 ;
11556  PLINT arg11 ;
11557  PLFLT arg12 ;
11558  PLFLT arg13 ;
11559  PLINT arg14 ;
11560  PLFLT arg15 ;
11561  PLINT arg16 ;
11562  PLFLT arg17 ;
11563  fill_func arg18 = (fill_func) 0 ;
11564  PLBOOL arg19 ;
11565  pltr_func arg20 = (pltr_func) 0 ;
11566  PLPointer arg21 = (PLPointer) 0 ;
11567  PyArrayObject *tmp1 = NULL ;
11568  double val5 ;
11569  int ecode5 = 0 ;
11570  double val6 ;
11571  int ecode6 = 0 ;
11572  double val7 ;
11573  int ecode7 = 0 ;
11574  double val8 ;
11575  int ecode8 = 0 ;
11576  double val9 ;
11577  int ecode9 = 0 ;
11578  double val10 ;
11579  int ecode10 = 0 ;
11580  int val11 ;
11581  int ecode11 = 0 ;
11582  double val12 ;
11583  int ecode12 = 0 ;
11584  double val13 ;
11585  int ecode13 = 0 ;
11586  int val14 ;
11587  int ecode14 = 0 ;
11588  double val15 ;
11589  int ecode15 = 0 ;
11590  int val16 ;
11591  int ecode16 = 0 ;
11592  double val17 ;
11593  int ecode17 = 0 ;
11594  int val19 ;
11595  int ecode19 = 0 ;
11596  PyObject *swig_obj[17] ;
11597 
11598  {
11599  python_pltr = 0;
11600  arg20 = NULL;
11601  }
11602  {
11603  arg21 = NULL;
11604  }
11605  {
11606  arg4 = NULL;
11607  }
11608  {
11609  arg18 = plfill;
11610  }
11611  if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
11612  {
11613  int i, size;
11614  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11615  if ( tmp1 == NULL )
11616  return NULL;
11617  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11618  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11619  size = arg3;
11620  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11621  for ( i = 0; i < arg2; i++ )
11622  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11623  }
11624  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11625  if (!SWIG_IsOK(ecode5)) {
11626  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11627  }
11628  arg5 = (PLFLT)(val5);
11629  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11630  if (!SWIG_IsOK(ecode6)) {
11631  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11632  }
11633  arg6 = (PLFLT)(val6);
11634  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11635  if (!SWIG_IsOK(ecode7)) {
11636  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11637  }
11638  arg7 = (PLFLT)(val7);
11639  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11640  if (!SWIG_IsOK(ecode8)) {
11641  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11642  }
11643  arg8 = (PLFLT)(val8);
11644  ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
11645  if (!SWIG_IsOK(ecode9)) {
11646  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11647  }
11648  arg9 = (PLFLT)(val9);
11649  ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
11650  if (!SWIG_IsOK(ecode10)) {
11651  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11652  }
11653  arg10 = (PLFLT)(val10);
11654  ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
11655  if (!SWIG_IsOK(ecode11)) {
11656  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11657  }
11658  arg11 = (PLINT)(val11);
11659  ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
11660  if (!SWIG_IsOK(ecode12)) {
11661  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11662  }
11663  arg12 = (PLFLT)(val12);
11664  ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
11665  if (!SWIG_IsOK(ecode13)) {
11666  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
11667  }
11668  arg13 = (PLFLT)(val13);
11669  ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
11670  if (!SWIG_IsOK(ecode14)) {
11671  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11672  }
11673  arg14 = (PLINT)(val14);
11674  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
11675  if (!SWIG_IsOK(ecode15)) {
11676  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
11677  }
11678  arg15 = (PLFLT)(val15);
11679  ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
11680  if (!SWIG_IsOK(ecode16)) {
11681  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11682  }
11683  arg16 = (PLINT)(val16);
11684  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
11685  if (!SWIG_IsOK(ecode17)) {
11686  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
11687  }
11688  arg17 = (PLFLT)(val17);
11689  ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
11690  if (!SWIG_IsOK(ecode19)) {
11691  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11692  }
11693  arg19 = (PLBOOL)(val19);
11694  if (swig_obj[15]) {
11695  {
11696  // it must be a callable or None
11697  if ( swig_obj[15] == Py_None )
11698  {
11699  arg20 = NULL;
11700  }
11701  else
11702  {
11703  if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
11704  {
11705  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11706  return NULL;
11707  }
11708  arg20 = marshal_pltr( swig_obj[15] );
11709  }
11710  }
11711  }
11712  if (swig_obj[16]) {
11713  {
11714  if ( swig_obj[16] == Py_None )
11715  arg21 = NULL;
11716  else
11717  {
11718  arg21 = marshal_PLPointer( swig_obj[16], 0 );
11719  }
11720  }
11721  }
11722  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11723  resultobj = SWIG_Py_Void();
11724  {
11725  Py_CLEAR( tmp1 );
11726  free( arg1 );
11727  }
11728  {
11729  cleanup_pltr();
11730  }
11731  {
11733  }
11734  return resultobj;
11735 fail:
11736  {
11737  Py_CLEAR( tmp1 );
11738  free( arg1 );
11739  }
11740  {
11741  cleanup_pltr();
11742  }
11743  {
11745  }
11746  return NULL;
11747 }
11748 
11749 
11750 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751  PyObject *resultobj = 0;
11752  label_func arg1 = (label_func) 0 ;
11753  PLPointer arg2 = (PLPointer) 0 ;
11754  int res2 ;
11755  PyObject *swig_obj[2] ;
11756 
11757  if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
11758  {
11759  // Release reference to previous function if applicable
11760  if ( python_label )
11761  {
11762  Py_CLEAR( python_label );
11763  python_label = 0;
11764  }
11765  // it must be a callable or None
11766  if ( swig_obj[0] == Py_None )
11767  {
11768  arg1 = NULL;
11769  }
11770  else
11771  {
11772  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
11773  {
11774  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11775  return NULL;
11776  }
11777  // hold a reference to it
11778  Py_XINCREF( (PyObject *) swig_obj[0] );
11779  python_label = (PyObject *) swig_obj[0];
11780  // this function handles calling the python function
11781  arg1 = do_label_callback;
11782  }
11783  }
11784  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
11785  if (!SWIG_IsOK(res2)) {
11786  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
11787  }
11788  plslabelfunc(arg1,arg2);
11789  resultobj = SWIG_Py_Void();
11790  return resultobj;
11791 fail:
11792  return NULL;
11793 }
11794 
11795 
11796 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11797  PyObject *resultobj = 0;
11798  PLFLT arg1 ;
11799  PLFLT arg2 ;
11800  double val1 ;
11801  int ecode1 = 0 ;
11802  double val2 ;
11803  int ecode2 = 0 ;
11804  PyObject *swig_obj[2] ;
11805 
11806  if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
11807  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11808  if (!SWIG_IsOK(ecode1)) {
11809  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11810  }
11811  arg1 = (PLFLT)(val1);
11812  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11813  if (!SWIG_IsOK(ecode2)) {
11814  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11815  }
11816  arg2 = (PLFLT)(val2);
11817  plsmaj(arg1,arg2);
11818  resultobj = SWIG_Py_Void();
11819  return resultobj;
11820 fail:
11821  return NULL;
11822 }
11823 
11824 
11825 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11826  PyObject *resultobj = 0;
11827  PLINT arg1 ;
11828  PLINT arg2 ;
11829  void *arg3 = (void *) 0 ;
11830  int val1 ;
11831  int ecode1 = 0 ;
11832  int val2 ;
11833  int ecode2 = 0 ;
11834  PyObject *swig_obj[3] ;
11835 
11836  if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
11837  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11838  if (!SWIG_IsOK(ecode1)) {
11839  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11840  }
11841  arg1 = (PLINT)(val1);
11842  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11843  if (!SWIG_IsOK(ecode2)) {
11844  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11845  }
11846  arg2 = (PLINT)(val2);
11847  {
11848  int res; void *buf = 0;
11849  Py_buffer view;
11850  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11851  buf = view.buf;
11852  PyBuffer_Release(&view);
11853  if (res < 0) {
11854  PyErr_Clear();
11855  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
11856  }
11857  arg3 = (void *) buf;
11858  }
11859  plsmem(arg1,arg2,arg3);
11860  resultobj = SWIG_Py_Void();
11861  return resultobj;
11862 fail:
11863  return NULL;
11864 }
11865 
11866 
11867 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11868  PyObject *resultobj = 0;
11869  PLINT arg1 ;
11870  PLINT arg2 ;
11871  void *arg3 = (void *) 0 ;
11872  int val1 ;
11873  int ecode1 = 0 ;
11874  int val2 ;
11875  int ecode2 = 0 ;
11876  PyObject *swig_obj[3] ;
11877 
11878  if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
11879  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11880  if (!SWIG_IsOK(ecode1)) {
11881  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11882  }
11883  arg1 = (PLINT)(val1);
11884  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11885  if (!SWIG_IsOK(ecode2)) {
11886  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11887  }
11888  arg2 = (PLINT)(val2);
11889  {
11890  int res; void *buf = 0;
11891  Py_buffer view;
11892  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11893  buf = view.buf;
11894  PyBuffer_Release(&view);
11895  if (res < 0) {
11896  PyErr_Clear();
11897  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
11898  }
11899  arg3 = (void *) buf;
11900  }
11901  plsmema(arg1,arg2,arg3);
11902  resultobj = SWIG_Py_Void();
11903  return resultobj;
11904 fail:
11905  return NULL;
11906 }
11907 
11908 
11909 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910  PyObject *resultobj = 0;
11911  PLFLT arg1 ;
11912  PLFLT arg2 ;
11913  double val1 ;
11914  int ecode1 = 0 ;
11915  double val2 ;
11916  int ecode2 = 0 ;
11917  PyObject *swig_obj[2] ;
11918 
11919  if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
11920  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11921  if (!SWIG_IsOK(ecode1)) {
11922  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11923  }
11924  arg1 = (PLFLT)(val1);
11925  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11926  if (!SWIG_IsOK(ecode2)) {
11927  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11928  }
11929  arg2 = (PLFLT)(val2);
11930  plsmin(arg1,arg2);
11931  resultobj = SWIG_Py_Void();
11932  return resultobj;
11933 fail:
11934  return NULL;
11935 }
11936 
11937 
11938 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939  PyObject *resultobj = 0;
11940  PLINT arg1 ;
11941  int val1 ;
11942  int ecode1 = 0 ;
11943  PyObject *swig_obj[1] ;
11944 
11945  if (!args) SWIG_fail;
11946  swig_obj[0] = args;
11947  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11948  if (!SWIG_IsOK(ecode1)) {
11949  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11950  }
11951  arg1 = (PLINT)(val1);
11952  plsori(arg1);
11953  resultobj = SWIG_Py_Void();
11954  return resultobj;
11955 fail:
11956  return NULL;
11957 }
11958 
11959 
11960 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11961  PyObject *resultobj = 0;
11962  PLFLT arg1 ;
11963  PLFLT arg2 ;
11964  PLINT arg3 ;
11965  PLINT arg4 ;
11966  PLINT arg5 ;
11967  PLINT arg6 ;
11968  double val1 ;
11969  int ecode1 = 0 ;
11970  double val2 ;
11971  int ecode2 = 0 ;
11972  int val3 ;
11973  int ecode3 = 0 ;
11974  int val4 ;
11975  int ecode4 = 0 ;
11976  int val5 ;
11977  int ecode5 = 0 ;
11978  int val6 ;
11979  int ecode6 = 0 ;
11980  PyObject *swig_obj[6] ;
11981 
11982  if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
11983  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11984  if (!SWIG_IsOK(ecode1)) {
11985  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11986  }
11987  arg1 = (PLFLT)(val1);
11988  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11989  if (!SWIG_IsOK(ecode2)) {
11990  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11991  }
11992  arg2 = (PLFLT)(val2);
11993  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11994  if (!SWIG_IsOK(ecode3)) {
11995  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
11996  }
11997  arg3 = (PLINT)(val3);
11998  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11999  if (!SWIG_IsOK(ecode4)) {
12000  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12001  }
12002  arg4 = (PLINT)(val4);
12003  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12004  if (!SWIG_IsOK(ecode5)) {
12005  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12006  }
12007  arg5 = (PLINT)(val5);
12008  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12009  if (!SWIG_IsOK(ecode6)) {
12010  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12011  }
12012  arg6 = (PLINT)(val6);
12013  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12014  resultobj = SWIG_Py_Void();
12015  return resultobj;
12016 fail:
12017  return NULL;
12018 }
12019 
12020 
12021 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12022  PyObject *resultobj = 0;
12023  char *arg1 = (char *) 0 ;
12024  int res1 ;
12025  char *buf1 = 0 ;
12026  int alloc1 = 0 ;
12027  PyObject *swig_obj[1] ;
12028 
12029  if (!args) SWIG_fail;
12030  swig_obj[0] = args;
12031  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12032  if (!SWIG_IsOK(res1)) {
12033  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12034  }
12035  arg1 = (char *)(buf1);
12036  plspal0((char const *)arg1);
12037  resultobj = SWIG_Py_Void();
12038  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12039  return resultobj;
12040 fail:
12041  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12042  return NULL;
12043 }
12044 
12045 
12046 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12047  PyObject *resultobj = 0;
12048  char *arg1 = (char *) 0 ;
12049  PLBOOL arg2 ;
12050  int res1 ;
12051  char *buf1 = 0 ;
12052  int alloc1 = 0 ;
12053  int val2 ;
12054  int ecode2 = 0 ;
12055  PyObject *swig_obj[2] ;
12056 
12057  if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12058  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12059  if (!SWIG_IsOK(res1)) {
12060  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12061  }
12062  arg1 = (char *)(buf1);
12063  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12064  if (!SWIG_IsOK(ecode2)) {
12065  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12066  }
12067  arg2 = (PLBOOL)(val2);
12068  plspal1((char const *)arg1,arg2);
12069  resultobj = SWIG_Py_Void();
12070  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12071  return resultobj;
12072 fail:
12073  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12074  return NULL;
12075 }
12076 
12077 
12078 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12079  PyObject *resultobj = 0;
12080  PLBOOL arg1 ;
12081  int val1 ;
12082  int ecode1 = 0 ;
12083  PyObject *swig_obj[1] ;
12084 
12085  if (!args) SWIG_fail;
12086  swig_obj[0] = args;
12087  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12088  if (!SWIG_IsOK(ecode1)) {
12089  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12090  }
12091  arg1 = (PLBOOL)(val1);
12092  plspause(arg1);
12093  resultobj = SWIG_Py_Void();
12094  return resultobj;
12095 fail:
12096  return NULL;
12097 }
12098 
12099 
12100 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101  PyObject *resultobj = 0;
12102  PLINT arg1 ;
12103  int val1 ;
12104  int ecode1 = 0 ;
12105  PyObject *swig_obj[1] ;
12106 
12107  if (!args) SWIG_fail;
12108  swig_obj[0] = args;
12109  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12110  if (!SWIG_IsOK(ecode1)) {
12111  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12112  }
12113  arg1 = (PLINT)(val1);
12114  plsstrm(arg1);
12115  resultobj = SWIG_Py_Void();
12116  return resultobj;
12117 fail:
12118  return NULL;
12119 }
12120 
12121 
12122 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12123  PyObject *resultobj = 0;
12124  PLINT arg1 ;
12125  PLINT arg2 ;
12126  int val1 ;
12127  int ecode1 = 0 ;
12128  int val2 ;
12129  int ecode2 = 0 ;
12130  PyObject *swig_obj[2] ;
12131 
12132  if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12133  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12134  if (!SWIG_IsOK(ecode1)) {
12135  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12136  }
12137  arg1 = (PLINT)(val1);
12138  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12139  if (!SWIG_IsOK(ecode2)) {
12140  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12141  }
12142  arg2 = (PLINT)(val2);
12143  plssub(arg1,arg2);
12144  resultobj = SWIG_Py_Void();
12145  return resultobj;
12146 fail:
12147  return NULL;
12148 }
12149 
12150 
12151 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152  PyObject *resultobj = 0;
12153  PLFLT arg1 ;
12154  PLFLT arg2 ;
12155  double val1 ;
12156  int ecode1 = 0 ;
12157  double val2 ;
12158  int ecode2 = 0 ;
12159  PyObject *swig_obj[2] ;
12160 
12161  if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12162  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12163  if (!SWIG_IsOK(ecode1)) {
12164  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12165  }
12166  arg1 = (PLFLT)(val1);
12167  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12168  if (!SWIG_IsOK(ecode2)) {
12169  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12170  }
12171  arg2 = (PLFLT)(val2);
12172  plssym(arg1,arg2);
12173  resultobj = SWIG_Py_Void();
12174  return resultobj;
12175 fail:
12176  return NULL;
12177 }
12178 
12179 
12180 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12181  PyObject *resultobj = 0;
12182  PLINT arg1 ;
12183  PLINT arg2 ;
12184  int val1 ;
12185  int ecode1 = 0 ;
12186  int val2 ;
12187  int ecode2 = 0 ;
12188  PyObject *swig_obj[2] ;
12189 
12190  if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12191  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12192  if (!SWIG_IsOK(ecode1)) {
12193  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12194  }
12195  arg1 = (PLINT)(val1);
12196  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12197  if (!SWIG_IsOK(ecode2)) {
12198  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12199  }
12200  arg2 = (PLINT)(val2);
12201  plstar(arg1,arg2);
12202  resultobj = SWIG_Py_Void();
12203  return resultobj;
12204 fail:
12205  return NULL;
12206 }
12207 
12208 
12209 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210  PyObject *resultobj = 0;
12211  char *arg1 = (char *) 0 ;
12212  PLINT arg2 ;
12213  PLINT arg3 ;
12214  int res1 ;
12215  char *buf1 = 0 ;
12216  int alloc1 = 0 ;
12217  int val2 ;
12218  int ecode2 = 0 ;
12219  int val3 ;
12220  int ecode3 = 0 ;
12221  PyObject *swig_obj[3] ;
12222 
12223  if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12224  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12225  if (!SWIG_IsOK(res1)) {
12226  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12227  }
12228  arg1 = (char *)(buf1);
12229  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12230  if (!SWIG_IsOK(ecode2)) {
12231  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12232  }
12233  arg2 = (PLINT)(val2);
12234  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12235  if (!SWIG_IsOK(ecode3)) {
12236  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12237  }
12238  arg3 = (PLINT)(val3);
12239  plstart((char const *)arg1,arg2,arg3);
12240  resultobj = SWIG_Py_Void();
12241  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12242  return resultobj;
12243 fail:
12244  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12245  return NULL;
12246 }
12247 
12248 
12249 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12250  PyObject *resultobj = 0;
12251  ct_func arg1 = (ct_func) 0 ;
12252  PLPointer arg2 = (PLPointer) 0 ;
12253  int res2 ;
12254  PyObject *swig_obj[2] ;
12255 
12256  {
12257  python_ct = 0;
12258  arg1 = NULL;
12259  }
12260  if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12261  if (swig_obj[0]) {
12262  {
12263  if ( python_ct )
12264  cleanup_ct();
12265  // it must be a callable or none
12266  if ( swig_obj[0] == Py_None )
12267  {
12268  arg1 = NULL;
12269  }
12270  else
12271  {
12272  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12273  {
12274  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12275  return NULL;
12276  }
12277  arg1 = marshal_ct( swig_obj[0] );
12278  }
12279  }
12280  }
12281  if (swig_obj[1]) {
12282  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12283  if (!SWIG_IsOK(res2)) {
12284  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12285  }
12286  }
12287  plstransform(arg1,arg2);
12288  resultobj = SWIG_Py_Void();
12289  return resultobj;
12290 fail:
12291  return NULL;
12292 }
12293 
12294 
12295 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12296  PyObject *resultobj = 0;
12297  PLINT arg1 ;
12298  PLFLT *arg2 = (PLFLT *) 0 ;
12299  PLFLT *arg3 = (PLFLT *) 0 ;
12300  char *arg4 = (char *) 0 ;
12301  PyArrayObject *tmp1 = NULL ;
12302  PyArrayObject *tmp3 = NULL ;
12303  int res4 ;
12304  char *buf4 = 0 ;
12305  int alloc4 = 0 ;
12306  PyObject *swig_obj[3] ;
12307 
12308  if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
12309  {
12310  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12311  if ( tmp1 == NULL )
12312  return NULL;
12313  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12314  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12315  }
12316  {
12317  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12318  if ( tmp3 == NULL )
12319  return NULL;
12320  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12321  {
12322  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12323  return NULL;
12324  }
12325  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12326  }
12327  res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
12328  if (!SWIG_IsOK(res4)) {
12329  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12330  }
12331  arg4 = (char *)(buf4);
12332  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12333  resultobj = SWIG_Py_Void();
12334  {
12335  Py_CLEAR( tmp1 );
12336  }
12337  {
12338  Py_CLEAR( tmp3 );
12339  }
12340  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12341  return resultobj;
12342 fail:
12343  {
12344  Py_CLEAR( tmp1 );
12345  }
12346  {
12347  Py_CLEAR( tmp3 );
12348  }
12349  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12350  return NULL;
12351 }
12352 
12353 
12354 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355  PyObject *resultobj = 0;
12356  PLINT arg1 ;
12357  PLFLT *arg2 = (PLFLT *) 0 ;
12358  PLFLT *arg3 = (PLFLT *) 0 ;
12359  PLFLT *arg4 = (PLFLT *) 0 ;
12360  char *arg5 = (char *) 0 ;
12361  PyArrayObject *tmp1 = NULL ;
12362  PyArrayObject *tmp3 = NULL ;
12363  PyArrayObject *tmp4 = NULL ;
12364  int res5 ;
12365  char *buf5 = 0 ;
12366  int alloc5 = 0 ;
12367  PyObject *swig_obj[4] ;
12368 
12369  if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
12370  {
12371  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12372  if ( tmp1 == NULL )
12373  return NULL;
12374  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12375  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12376  }
12377  {
12378  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12379  if ( tmp3 == NULL )
12380  return NULL;
12381  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12382  {
12383  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12384  return NULL;
12385  }
12386  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12387  }
12388  {
12389  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
12390  if ( tmp4 == NULL )
12391  return NULL;
12392  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12393  {
12394  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12395  return NULL;
12396  }
12397  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12398  }
12399  res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
12400  if (!SWIG_IsOK(res5)) {
12401  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12402  }
12403  arg5 = (char *)(buf5);
12404  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12405  resultobj = SWIG_Py_Void();
12406  {
12407  Py_CLEAR( tmp1 );
12408  }
12409  {
12410  Py_CLEAR( tmp3 );
12411  }
12412  {
12413  Py_CLEAR( tmp4 );
12414  }
12415  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12416  return resultobj;
12417 fail:
12418  {
12419  Py_CLEAR( tmp1 );
12420  }
12421  {
12422  Py_CLEAR( tmp3 );
12423  }
12424  {
12425  Py_CLEAR( tmp4 );
12426  }
12427  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12428  return NULL;
12429 }
12430 
12431 
12432 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433  PyObject *resultobj = 0;
12434  PLINT arg1 ;
12435  PLINT arg2 ;
12436  PLFLT arg3 ;
12437  PLFLT arg4 ;
12438  int val1 ;
12439  int ecode1 = 0 ;
12440  int val2 ;
12441  int ecode2 = 0 ;
12442  double val3 ;
12443  int ecode3 = 0 ;
12444  double val4 ;
12445  int ecode4 = 0 ;
12446  PyObject *swig_obj[4] ;
12447 
12448  if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
12449  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12450  if (!SWIG_IsOK(ecode1)) {
12451  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12452  }
12453  arg1 = (PLINT)(val1);
12454  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12455  if (!SWIG_IsOK(ecode2)) {
12456  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12457  }
12458  arg2 = (PLINT)(val2);
12459  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12460  if (!SWIG_IsOK(ecode3)) {
12461  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12462  }
12463  arg3 = (PLFLT)(val3);
12464  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12465  if (!SWIG_IsOK(ecode4)) {
12466  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12467  }
12468  arg4 = (PLFLT)(val4);
12469  plstripa(arg1,arg2,arg3,arg4);
12470  resultobj = SWIG_Py_Void();
12471  return resultobj;
12472 fail:
12473  return NULL;
12474 }
12475 
12476 
12477 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12478  PyObject *resultobj = 0;
12479  PLINT *arg1 = (PLINT *) 0 ;
12480  char *arg2 = (char *) 0 ;
12481  char *arg3 = (char *) 0 ;
12482  PLFLT arg4 ;
12483  PLFLT arg5 ;
12484  PLFLT arg6 ;
12485  PLFLT arg7 ;
12486  PLFLT arg8 ;
12487  PLFLT arg9 ;
12488  PLFLT arg10 ;
12489  PLBOOL arg11 ;
12490  PLBOOL arg12 ;
12491  PLINT arg13 ;
12492  PLINT arg14 ;
12493  PLINT *arg15 = (PLINT *) 0 ;
12494  PLINT *arg16 = (PLINT *) 0 ;
12495  char **arg17 ;
12496  char *arg18 = (char *) 0 ;
12497  char *arg19 = (char *) 0 ;
12498  char *arg20 = (char *) 0 ;
12499  PLINT temp1 ;
12500  int res1 = SWIG_TMPOBJ ;
12501  int res2 ;
12502  char *buf2 = 0 ;
12503  int alloc2 = 0 ;
12504  int res3 ;
12505  char *buf3 = 0 ;
12506  int alloc3 = 0 ;
12507  double val4 ;
12508  int ecode4 = 0 ;
12509  double val5 ;
12510  int ecode5 = 0 ;
12511  double val6 ;
12512  int ecode6 = 0 ;
12513  double val7 ;
12514  int ecode7 = 0 ;
12515  double val8 ;
12516  int ecode8 = 0 ;
12517  double val9 ;
12518  int ecode9 = 0 ;
12519  double val10 ;
12520  int ecode10 = 0 ;
12521  int val11 ;
12522  int ecode11 = 0 ;
12523  int val12 ;
12524  int ecode12 = 0 ;
12525  int val13 ;
12526  int ecode13 = 0 ;
12527  int val14 ;
12528  int ecode14 = 0 ;
12529  PyArrayObject *tmp15 = NULL ;
12530  PyArrayObject *tmp16 = NULL ;
12531  char **tmp17 = NULL ;
12532  int res18 ;
12533  char *buf18 = 0 ;
12534  int alloc18 = 0 ;
12535  int res19 ;
12536  char *buf19 = 0 ;
12537  int alloc19 = 0 ;
12538  int res20 ;
12539  char *buf20 = 0 ;
12540  int alloc20 = 0 ;
12541  PyObject *swig_obj[19] ;
12542 
12543  arg1 = &temp1;
12544  if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
12545  res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
12546  if (!SWIG_IsOK(res2)) {
12547  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12548  }
12549  arg2 = (char *)(buf2);
12550  res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
12551  if (!SWIG_IsOK(res3)) {
12552  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12553  }
12554  arg3 = (char *)(buf3);
12555  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
12556  if (!SWIG_IsOK(ecode4)) {
12557  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12558  }
12559  arg4 = (PLFLT)(val4);
12560  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
12561  if (!SWIG_IsOK(ecode5)) {
12562  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12563  }
12564  arg5 = (PLFLT)(val5);
12565  ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
12566  if (!SWIG_IsOK(ecode6)) {
12567  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12568  }
12569  arg6 = (PLFLT)(val6);
12570  ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
12571  if (!SWIG_IsOK(ecode7)) {
12572  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12573  }
12574  arg7 = (PLFLT)(val7);
12575  ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
12576  if (!SWIG_IsOK(ecode8)) {
12577  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12578  }
12579  arg8 = (PLFLT)(val8);
12580  ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
12581  if (!SWIG_IsOK(ecode9)) {
12582  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12583  }
12584  arg9 = (PLFLT)(val9);
12585  ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
12586  if (!SWIG_IsOK(ecode10)) {
12587  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12588  }
12589  arg10 = (PLFLT)(val10);
12590  ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
12591  if (!SWIG_IsOK(ecode11)) {
12592  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12593  }
12594  arg11 = (PLBOOL)(val11);
12595  ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
12596  if (!SWIG_IsOK(ecode12)) {
12597  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12598  }
12599  arg12 = (PLBOOL)(val12);
12600  ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
12601  if (!SWIG_IsOK(ecode13)) {
12602  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12603  }
12604  arg13 = (PLINT)(val13);
12605  ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
12606  if (!SWIG_IsOK(ecode14)) {
12607  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12608  }
12609  arg14 = (PLINT)(val14);
12610  {
12611  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
12612  if ( tmp15 == NULL )
12613  return NULL;
12614  Alen = PyArray_DIMS( tmp15 )[0];
12615  arg15 = (PLINT *) PyArray_DATA( tmp15 );
12616  }
12617  {
12618  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
12619  if ( tmp16 == NULL )
12620  return NULL;
12621  if ( PyArray_DIMS( tmp16 )[0] != Alen )
12622  {
12623  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12624  return NULL;
12625  }
12626  arg16 = (PLINT *) PyArray_DATA( tmp16 );
12627  }
12628  {
12629  int i;
12630  PyObject *elt, *unicode_string;
12631 
12632  if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
12633  {
12634  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12635  return NULL;
12636  }
12637  if ( Alen != 4 )
12638  {
12639  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12640  return NULL;
12641  }
12642  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
12643  if ( tmp17 == NULL )
12644  return NULL;
12645  arg17 = tmp17;
12646  for ( i = 0; i < 4; i++ )
12647  {
12648  arg17[i] = NULL;
12649  elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
12650  if ( PyString_Check( elt ) )
12651  {
12652  arg17[i] = PyString_AsString( elt );
12653  }
12654  else if ( PyUnicode_Check( elt ) )
12655  {
12656  unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
12657  arg17[i] = PyBytes_AS_STRING( unicode_string );
12658  }
12659  if ( arg17[i] == NULL )
12660  {
12661  free( tmp17 );
12662  return NULL;
12663  }
12664  }
12665  }
12666  res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
12667  if (!SWIG_IsOK(res18)) {
12668  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12669  }
12670  arg18 = (char *)(buf18);
12671  res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
12672  if (!SWIG_IsOK(res19)) {
12673  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12674  }
12675  arg19 = (char *)(buf19);
12676  res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
12677  if (!SWIG_IsOK(res20)) {
12678  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12679  }
12680  arg20 = (char *)(buf20);
12681  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);
12682  resultobj = SWIG_Py_Void();
12683  if (SWIG_IsTmpObj(res1)) {
12684  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12685  } else {
12686  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12687  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12688  }
12689  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12690  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12691  {
12692  Py_CLEAR( tmp15 );
12693  }
12694  {
12695  Py_CLEAR( tmp16 );
12696  }
12697  {
12698  free( tmp17 );
12699  }
12700  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12701  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12702  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12703  return resultobj;
12704 fail:
12705  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12706  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12707  {
12708  Py_CLEAR( tmp15 );
12709  }
12710  {
12711  Py_CLEAR( tmp16 );
12712  }
12713  {
12714  free( tmp17 );
12715  }
12716  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12717  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12718  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12719  return NULL;
12720 }
12721 
12722 
12723 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724  PyObject *resultobj = 0;
12725  PLINT arg1 ;
12726  int val1 ;
12727  int ecode1 = 0 ;
12728  PyObject *swig_obj[1] ;
12729 
12730  if (!args) SWIG_fail;
12731  swig_obj[0] = args;
12732  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12733  if (!SWIG_IsOK(ecode1)) {
12734  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12735  }
12736  arg1 = (PLINT)(val1);
12737  plstripd(arg1);
12738  resultobj = SWIG_Py_Void();
12739  return resultobj;
12740 fail:
12741  return NULL;
12742 }
12743 
12744 
12745 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12746  PyObject *resultobj = 0;
12747  PLINT arg1 ;
12748  PLINT *arg2 = (PLINT *) 0 ;
12749  PLINT *arg3 = (PLINT *) 0 ;
12750  PyArrayObject *tmp1 = NULL ;
12751  PyArrayObject *tmp3 = NULL ;
12752  PyObject *swig_obj[2] ;
12753 
12754  if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
12755  {
12756  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
12757  if ( tmp1 == NULL )
12758  return NULL;
12759  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12760  arg2 = (PLINT *) PyArray_DATA( tmp1 );
12761  }
12762  {
12763  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
12764  if ( tmp3 == NULL )
12765  return NULL;
12766  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12767  {
12768  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12769  return NULL;
12770  }
12771  arg3 = (PLINT *) PyArray_DATA( tmp3 );
12772  }
12773  plstyl(arg1,(int const *)arg2,(int const *)arg3);
12774  resultobj = SWIG_Py_Void();
12775  {
12776  Py_CLEAR( tmp1 );
12777  }
12778  {
12779  Py_CLEAR( tmp3 );
12780  }
12781  return resultobj;
12782 fail:
12783  {
12784  Py_CLEAR( tmp1 );
12785  }
12786  {
12787  Py_CLEAR( tmp3 );
12788  }
12789  return NULL;
12790 }
12791 
12792 
12793 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794  PyObject *resultobj = 0;
12795  PLFLT *arg1 = (PLFLT *) 0 ;
12796  PLFLT *arg2 = (PLFLT *) 0 ;
12797  PLINT arg3 ;
12798  PLBOOL arg4 ;
12799  PyArrayObject *tmp1 = NULL ;
12800  PyArrayObject *tmp2 = NULL ;
12801  int val4 ;
12802  int ecode4 = 0 ;
12803  PyObject *swig_obj[3] ;
12804 
12805  if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
12806  {
12807  if ( swig_obj[0] != Py_None )
12808  {
12809  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12810  if ( tmp1 == NULL )
12811  return NULL;
12812  Alen = PyArray_DIMS( tmp1 )[0];
12813  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
12814  }
12815  else
12816  {
12817  arg1 = NULL;
12818  Alen = 0;
12819  }
12820  }
12821  {
12822  if ( swig_obj[1] != Py_None )
12823  {
12824  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12825  if ( tmp2 == NULL )
12826  return NULL;
12827  if ( PyArray_DIMS( tmp2 )[0] != Alen )
12828  {
12829  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12830  return NULL;
12831  }
12832  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
12833  arg3 = PyArray_DIMS( tmp2 )[0];
12834  }
12835  else
12836  {
12837  arg2 = NULL;
12838  arg3 = 0;
12839  }
12840  }
12841  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
12842  if (!SWIG_IsOK(ecode4)) {
12843  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12844  }
12845  arg4 = (PLBOOL)(val4);
12846  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12847  resultobj = SWIG_Py_Void();
12848  {
12849  Py_CLEAR( tmp1 );
12850  }
12851  {
12852  Py_CLEAR( tmp2 );
12853  }
12854  return resultobj;
12855 fail:
12856  {
12857  Py_CLEAR( tmp1 );
12858  }
12859  {
12860  Py_CLEAR( tmp2 );
12861  }
12862  return NULL;
12863 }
12864 
12865 
12866 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12867  PyObject *resultobj = 0;
12868  PLFLT arg1 ;
12869  PLFLT arg2 ;
12870  PLFLT arg3 ;
12871  PLFLT arg4 ;
12872  double val1 ;
12873  int ecode1 = 0 ;
12874  double val2 ;
12875  int ecode2 = 0 ;
12876  double val3 ;
12877  int ecode3 = 0 ;
12878  double val4 ;
12879  int ecode4 = 0 ;
12880  PyObject *swig_obj[4] ;
12881 
12882  if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
12883  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12884  if (!SWIG_IsOK(ecode1)) {
12885  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12886  }
12887  arg1 = (PLFLT)(val1);
12888  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12889  if (!SWIG_IsOK(ecode2)) {
12890  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12891  }
12892  arg2 = (PLFLT)(val2);
12893  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12894  if (!SWIG_IsOK(ecode3)) {
12895  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12896  }
12897  arg3 = (PLFLT)(val3);
12898  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12899  if (!SWIG_IsOK(ecode4)) {
12900  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12901  }
12902  arg4 = (PLFLT)(val4);
12903  plsvpa(arg1,arg2,arg3,arg4);
12904  resultobj = SWIG_Py_Void();
12905  return resultobj;
12906 fail:
12907  return NULL;
12908 }
12909 
12910 
12911 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912  PyObject *resultobj = 0;
12913  PLINT arg1 ;
12914  PLINT arg2 ;
12915  int val1 ;
12916  int ecode1 = 0 ;
12917  int val2 ;
12918  int ecode2 = 0 ;
12919  PyObject *swig_obj[2] ;
12920 
12921  if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
12922  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12923  if (!SWIG_IsOK(ecode1)) {
12924  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12925  }
12926  arg1 = (PLINT)(val1);
12927  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12928  if (!SWIG_IsOK(ecode2)) {
12929  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12930  }
12931  arg2 = (PLINT)(val2);
12932  plsxax(arg1,arg2);
12933  resultobj = SWIG_Py_Void();
12934  return resultobj;
12935 fail:
12936  return NULL;
12937 }
12938 
12939 
12940 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941  PyObject *resultobj = 0;
12942  PLINT arg1 ;
12943  PLINT arg2 ;
12944  int val1 ;
12945  int ecode1 = 0 ;
12946  int val2 ;
12947  int ecode2 = 0 ;
12948  PyObject *swig_obj[2] ;
12949 
12950  if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
12951  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12952  if (!SWIG_IsOK(ecode1)) {
12953  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12954  }
12955  arg1 = (PLINT)(val1);
12956  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12957  if (!SWIG_IsOK(ecode2)) {
12958  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12959  }
12960  arg2 = (PLINT)(val2);
12961  plsyax(arg1,arg2);
12962  resultobj = SWIG_Py_Void();
12963  return resultobj;
12964 fail:
12965  return NULL;
12966 }
12967 
12968 
12969 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12970  PyObject *resultobj = 0;
12971  PLINT arg1 ;
12972  PLFLT *arg2 = (PLFLT *) 0 ;
12973  PLFLT *arg3 = (PLFLT *) 0 ;
12974  PLINT arg4 ;
12975  PyArrayObject *tmp1 = NULL ;
12976  PyArrayObject *tmp3 = NULL ;
12977  int val4 ;
12978  int ecode4 = 0 ;
12979  PyObject *swig_obj[3] ;
12980 
12981  if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
12982  {
12983  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12984  if ( tmp1 == NULL )
12985  return NULL;
12986  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12987  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12988  }
12989  {
12990  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12991  if ( tmp3 == NULL )
12992  return NULL;
12993  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12994  {
12995  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12996  return NULL;
12997  }
12998  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12999  }
13000  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13001  if (!SWIG_IsOK(ecode4)) {
13002  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13003  }
13004  arg4 = (PLINT)(val4);
13005  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13006  resultobj = SWIG_Py_Void();
13007  {
13008  Py_CLEAR( tmp1 );
13009  }
13010  {
13011  Py_CLEAR( tmp3 );
13012  }
13013  return resultobj;
13014 fail:
13015  {
13016  Py_CLEAR( tmp1 );
13017  }
13018  {
13019  Py_CLEAR( tmp3 );
13020  }
13021  return NULL;
13022 }
13023 
13024 
13025 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026  PyObject *resultobj = 0;
13027  PLINT arg1 ;
13028  PLINT arg2 ;
13029  int val1 ;
13030  int ecode1 = 0 ;
13031  int val2 ;
13032  int ecode2 = 0 ;
13033  PyObject *swig_obj[2] ;
13034 
13035  if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13036  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13037  if (!SWIG_IsOK(ecode1)) {
13038  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13039  }
13040  arg1 = (PLINT)(val1);
13041  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13042  if (!SWIG_IsOK(ecode2)) {
13043  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13044  }
13045  arg2 = (PLINT)(val2);
13046  plszax(arg1,arg2);
13047  resultobj = SWIG_Py_Void();
13048  return resultobj;
13049 fail:
13050  return NULL;
13051 }
13052 
13053 
13054 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13055  PyObject *resultobj = 0;
13056 
13057  if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13058  pltext();
13059  resultobj = SWIG_Py_Void();
13060  return resultobj;
13061 fail:
13062  return NULL;
13063 }
13064 
13065 
13066 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13067  PyObject *resultobj = 0;
13068  char *arg1 = (char *) 0 ;
13069  int res1 ;
13070  char *buf1 = 0 ;
13071  int alloc1 = 0 ;
13072  PyObject *swig_obj[1] ;
13073 
13074  if (!args) SWIG_fail;
13075  swig_obj[0] = args;
13076  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13077  if (!SWIG_IsOK(res1)) {
13078  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13079  }
13080  arg1 = (char *)(buf1);
13081  pltimefmt((char const *)arg1);
13082  resultobj = SWIG_Py_Void();
13083  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13084  return resultobj;
13085 fail:
13086  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13087  return NULL;
13088 }
13089 
13090 
13091 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13092  PyObject *resultobj = 0;
13093  PLFLT arg1 ;
13094  double val1 ;
13095  int ecode1 = 0 ;
13096  PyObject *swig_obj[1] ;
13097 
13098  if (!args) SWIG_fail;
13099  swig_obj[0] = args;
13100  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13101  if (!SWIG_IsOK(ecode1)) {
13102  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13103  }
13104  arg1 = (PLFLT)(val1);
13105  plvasp(arg1);
13106  resultobj = SWIG_Py_Void();
13107  return resultobj;
13108 fail:
13109  return NULL;
13110 }
13111 
13112 
13113 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114  PyObject *resultobj = 0;
13115  PLFLT **arg1 = (PLFLT **) 0 ;
13116  PLFLT **arg2 = (PLFLT **) 0 ;
13117  PLINT arg3 ;
13118  PLINT arg4 ;
13119  PLFLT arg5 ;
13120  pltr_func arg6 = (pltr_func) 0 ;
13121  PLPointer arg7 = (PLPointer) 0 ;
13122  PyArrayObject *tmp1 = NULL ;
13123  PyArrayObject *tmp2 = NULL ;
13124  double val5 ;
13125  int ecode5 = 0 ;
13126  PyObject *swig_obj[5] ;
13127 
13128  {
13129  python_pltr = 0;
13130  arg6 = NULL;
13131  }
13132  {
13133  arg7 = NULL;
13134  }
13135  if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13136  {
13137  int i, size;
13138  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13139  if ( tmp1 == NULL )
13140  return NULL;
13141  Xlen = PyArray_DIMS( tmp1 )[0];
13142  Ylen = PyArray_DIMS( tmp1 )[1];
13143  size = Ylen;
13144  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13145  for ( i = 0; i < Xlen; i++ )
13146  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13147  }
13148  {
13149  int i, size;
13150  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13151  if ( tmp2 == NULL )
13152  return NULL;
13153  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13154  {
13155  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13156  return NULL;
13157  }
13158  arg3 = PyArray_DIMS( tmp2 )[0];
13159  arg4 = PyArray_DIMS( tmp2 )[1];
13160  size = arg4;
13161  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13162  for ( i = 0; i < arg3; i++ )
13163  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13164  }
13165  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13166  if (!SWIG_IsOK(ecode5)) {
13167  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13168  }
13169  arg5 = (PLFLT)(val5);
13170  if (swig_obj[3]) {
13171  {
13172  // it must be a callable or None
13173  if ( swig_obj[3] == Py_None )
13174  {
13175  arg6 = NULL;
13176  }
13177  else
13178  {
13179  if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13180  {
13181  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13182  return NULL;
13183  }
13184  arg6 = marshal_pltr( swig_obj[3] );
13185  }
13186  }
13187  }
13188  if (swig_obj[4]) {
13189  {
13190  if ( swig_obj[4] == Py_None )
13191  arg7 = NULL;
13192  else
13193  {
13194  arg7 = marshal_PLPointer( swig_obj[4], 0 );
13195  }
13196  }
13197  }
13198  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13199  resultobj = SWIG_Py_Void();
13200  {
13201  Py_CLEAR( tmp1 );
13202  free( arg1 );
13203  }
13204  {
13205  Py_CLEAR( tmp2 );
13206  free( arg2 );
13207  }
13208  {
13209  cleanup_pltr();
13210  }
13211  {
13213  }
13214  return resultobj;
13215 fail:
13216  {
13217  Py_CLEAR( tmp1 );
13218  free( arg1 );
13219  }
13220  {
13221  Py_CLEAR( tmp2 );
13222  free( arg2 );
13223  }
13224  {
13225  cleanup_pltr();
13226  }
13227  {
13229  }
13230  return NULL;
13231 }
13232 
13233 
13234 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235  PyObject *resultobj = 0;
13236  PLFLT arg1 ;
13237  PLFLT arg2 ;
13238  PLFLT arg3 ;
13239  PLFLT arg4 ;
13240  PLFLT arg5 ;
13241  double val1 ;
13242  int ecode1 = 0 ;
13243  double val2 ;
13244  int ecode2 = 0 ;
13245  double val3 ;
13246  int ecode3 = 0 ;
13247  double val4 ;
13248  int ecode4 = 0 ;
13249  double val5 ;
13250  int ecode5 = 0 ;
13251  PyObject *swig_obj[5] ;
13252 
13253  if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13254  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13255  if (!SWIG_IsOK(ecode1)) {
13256  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13257  }
13258  arg1 = (PLFLT)(val1);
13259  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13260  if (!SWIG_IsOK(ecode2)) {
13261  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13262  }
13263  arg2 = (PLFLT)(val2);
13264  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13265  if (!SWIG_IsOK(ecode3)) {
13266  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13267  }
13268  arg3 = (PLFLT)(val3);
13269  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13270  if (!SWIG_IsOK(ecode4)) {
13271  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13272  }
13273  arg4 = (PLFLT)(val4);
13274  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13275  if (!SWIG_IsOK(ecode5)) {
13276  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13277  }
13278  arg5 = (PLFLT)(val5);
13279  plvpas(arg1,arg2,arg3,arg4,arg5);
13280  resultobj = SWIG_Py_Void();
13281  return resultobj;
13282 fail:
13283  return NULL;
13284 }
13285 
13286 
13287 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13288  PyObject *resultobj = 0;
13289  PLFLT arg1 ;
13290  PLFLT arg2 ;
13291  PLFLT arg3 ;
13292  PLFLT arg4 ;
13293  double val1 ;
13294  int ecode1 = 0 ;
13295  double val2 ;
13296  int ecode2 = 0 ;
13297  double val3 ;
13298  int ecode3 = 0 ;
13299  double val4 ;
13300  int ecode4 = 0 ;
13301  PyObject *swig_obj[4] ;
13302 
13303  if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
13304  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13305  if (!SWIG_IsOK(ecode1)) {
13306  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13307  }
13308  arg1 = (PLFLT)(val1);
13309  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13310  if (!SWIG_IsOK(ecode2)) {
13311  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13312  }
13313  arg2 = (PLFLT)(val2);
13314  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13315  if (!SWIG_IsOK(ecode3)) {
13316  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13317  }
13318  arg3 = (PLFLT)(val3);
13319  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13320  if (!SWIG_IsOK(ecode4)) {
13321  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13322  }
13323  arg4 = (PLFLT)(val4);
13324  plvpor(arg1,arg2,arg3,arg4);
13325  resultobj = SWIG_Py_Void();
13326  return resultobj;
13327 fail:
13328  return NULL;
13329 }
13330 
13331 
13332 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13333  PyObject *resultobj = 0;
13334 
13335  if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
13336  plvsta();
13337  resultobj = SWIG_Py_Void();
13338  return resultobj;
13339 fail:
13340  return NULL;
13341 }
13342 
13343 
13344 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13345  PyObject *resultobj = 0;
13346  PLFLT arg1 ;
13347  PLFLT arg2 ;
13348  PLFLT arg3 ;
13349  PLFLT arg4 ;
13350  PLFLT arg5 ;
13351  PLFLT arg6 ;
13352  PLFLT arg7 ;
13353  PLFLT arg8 ;
13354  PLFLT arg9 ;
13355  PLFLT arg10 ;
13356  PLFLT arg11 ;
13357  double val1 ;
13358  int ecode1 = 0 ;
13359  double val2 ;
13360  int ecode2 = 0 ;
13361  double val3 ;
13362  int ecode3 = 0 ;
13363  double val4 ;
13364  int ecode4 = 0 ;
13365  double val5 ;
13366  int ecode5 = 0 ;
13367  double val6 ;
13368  int ecode6 = 0 ;
13369  double val7 ;
13370  int ecode7 = 0 ;
13371  double val8 ;
13372  int ecode8 = 0 ;
13373  double val9 ;
13374  int ecode9 = 0 ;
13375  double val10 ;
13376  int ecode10 = 0 ;
13377  double val11 ;
13378  int ecode11 = 0 ;
13379  PyObject *swig_obj[11] ;
13380 
13381  if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
13382  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13383  if (!SWIG_IsOK(ecode1)) {
13384  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13385  }
13386  arg1 = (PLFLT)(val1);
13387  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13388  if (!SWIG_IsOK(ecode2)) {
13389  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13390  }
13391  arg2 = (PLFLT)(val2);
13392  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13393  if (!SWIG_IsOK(ecode3)) {
13394  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13395  }
13396  arg3 = (PLFLT)(val3);
13397  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13398  if (!SWIG_IsOK(ecode4)) {
13399  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13400  }
13401  arg4 = (PLFLT)(val4);
13402  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13403  if (!SWIG_IsOK(ecode5)) {
13404  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13405  }
13406  arg5 = (PLFLT)(val5);
13407  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13408  if (!SWIG_IsOK(ecode6)) {
13409  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13410  }
13411  arg6 = (PLFLT)(val6);
13412  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13413  if (!SWIG_IsOK(ecode7)) {
13414  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13415  }
13416  arg7 = (PLFLT)(val7);
13417  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13418  if (!SWIG_IsOK(ecode8)) {
13419  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13420  }
13421  arg8 = (PLFLT)(val8);
13422  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13423  if (!SWIG_IsOK(ecode9)) {
13424  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13425  }
13426  arg9 = (PLFLT)(val9);
13427  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13428  if (!SWIG_IsOK(ecode10)) {
13429  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13430  }
13431  arg10 = (PLFLT)(val10);
13432  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
13433  if (!SWIG_IsOK(ecode11)) {
13434  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13435  }
13436  arg11 = (PLFLT)(val11);
13437  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13438  resultobj = SWIG_Py_Void();
13439  return resultobj;
13440 fail:
13441  return NULL;
13442 }
13443 
13444 
13445 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446  PyObject *resultobj = 0;
13447  PLFLT arg1 ;
13448  double val1 ;
13449  int ecode1 = 0 ;
13450  PyObject *swig_obj[1] ;
13451 
13452  if (!args) SWIG_fail;
13453  swig_obj[0] = args;
13454  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13455  if (!SWIG_IsOK(ecode1)) {
13456  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13457  }
13458  arg1 = (PLFLT)(val1);
13459  plwidth(arg1);
13460  resultobj = SWIG_Py_Void();
13461  return resultobj;
13462 fail:
13463  return NULL;
13464 }
13465 
13466 
13467 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13468  PyObject *resultobj = 0;
13469  PLFLT arg1 ;
13470  PLFLT arg2 ;
13471  PLFLT arg3 ;
13472  PLFLT arg4 ;
13473  double val1 ;
13474  int ecode1 = 0 ;
13475  double val2 ;
13476  int ecode2 = 0 ;
13477  double val3 ;
13478  int ecode3 = 0 ;
13479  double val4 ;
13480  int ecode4 = 0 ;
13481  PyObject *swig_obj[4] ;
13482 
13483  if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
13484  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13485  if (!SWIG_IsOK(ecode1)) {
13486  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13487  }
13488  arg1 = (PLFLT)(val1);
13489  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13490  if (!SWIG_IsOK(ecode2)) {
13491  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13492  }
13493  arg2 = (PLFLT)(val2);
13494  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13495  if (!SWIG_IsOK(ecode3)) {
13496  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13497  }
13498  arg3 = (PLFLT)(val3);
13499  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13500  if (!SWIG_IsOK(ecode4)) {
13501  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13502  }
13503  arg4 = (PLFLT)(val4);
13504  plwind(arg1,arg2,arg3,arg4);
13505  resultobj = SWIG_Py_Void();
13506  return resultobj;
13507 fail:
13508  return NULL;
13509 }
13510 
13511 
13512 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13513  PyObject *resultobj = 0;
13514  PLBOOL arg1 ;
13515  PLBOOL *arg2 = (PLBOOL *) 0 ;
13516  int val1 ;
13517  int ecode1 = 0 ;
13518  PLBOOL temp2 ;
13519  int res2 = SWIG_TMPOBJ ;
13520  PyObject *swig_obj[1] ;
13521 
13522  arg2 = &temp2;
13523  if (!args) SWIG_fail;
13524  swig_obj[0] = args;
13525  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13526  if (!SWIG_IsOK(ecode1)) {
13527  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13528  }
13529  arg1 = (PLBOOL)(val1);
13530  plxormod(arg1,arg2);
13531  resultobj = SWIG_Py_Void();
13532  if (SWIG_IsTmpObj(res2)) {
13533  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13534  } else {
13535  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13536  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13537  }
13538  return resultobj;
13539 fail:
13540  return NULL;
13541 }
13542 
13543 
13544 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13545  PyObject *resultobj = 0;
13546  mapform_func arg1 = (mapform_func) 0 ;
13547  char *arg2 = (char *) 0 ;
13548  PLFLT arg3 ;
13549  PLFLT arg4 ;
13550  PLFLT arg5 ;
13551  PLFLT arg6 ;
13552  int res2 ;
13553  char *buf2 = 0 ;
13554  int alloc2 = 0 ;
13555  double val3 ;
13556  int ecode3 = 0 ;
13557  double val4 ;
13558  int ecode4 = 0 ;
13559  double val5 ;
13560  int ecode5 = 0 ;
13561  double val6 ;
13562  int ecode6 = 0 ;
13563  PyObject *swig_obj[6] ;
13564 
13565  if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
13566  {
13567  // it must be a callable or none
13568  if ( swig_obj[0] == Py_None )
13569  {
13570  arg1 = NULL;
13571  }
13572  else
13573  {
13574  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13575  {
13576  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13577  return NULL;
13578  }
13579  arg1 = marshal_mapform( swig_obj[0] );
13580  }
13581  }
13582  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13583  if (!SWIG_IsOK(res2)) {
13584  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13585  }
13586  arg2 = (char *)(buf2);
13587  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13588  if (!SWIG_IsOK(ecode3)) {
13589  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13590  }
13591  arg3 = (PLFLT)(val3);
13592  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13593  if (!SWIG_IsOK(ecode4)) {
13594  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13595  }
13596  arg4 = (PLFLT)(val4);
13597  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13598  if (!SWIG_IsOK(ecode5)) {
13599  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13600  }
13601  arg5 = (PLFLT)(val5);
13602  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13603  if (!SWIG_IsOK(ecode6)) {
13604  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13605  }
13606  arg6 = (PLFLT)(val6);
13607  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13608  resultobj = SWIG_Py_Void();
13609  {
13610  cleanup_mapform();
13611  }
13612  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13613  return resultobj;
13614 fail:
13615  {
13616  cleanup_mapform();
13617  }
13618  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13619  return NULL;
13620 }
13621 
13622 
13623 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13624  PyObject *resultobj = 0;
13625  mapform_func arg1 = (mapform_func) 0 ;
13626  char *arg2 = (char *) 0 ;
13627  PLFLT arg3 ;
13628  PLFLT arg4 ;
13629  PLFLT arg5 ;
13630  PLFLT arg6 ;
13631  PLINT *arg7 = (PLINT *) 0 ;
13632  PLINT arg8 ;
13633  int res2 ;
13634  char *buf2 = 0 ;
13635  int alloc2 = 0 ;
13636  double val3 ;
13637  int ecode3 = 0 ;
13638  double val4 ;
13639  int ecode4 = 0 ;
13640  double val5 ;
13641  int ecode5 = 0 ;
13642  double val6 ;
13643  int ecode6 = 0 ;
13644  PyArrayObject *tmp7 = NULL ;
13645  PyObject *swig_obj[7] ;
13646 
13647  if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
13648  {
13649  // it must be a callable or none
13650  if ( swig_obj[0] == Py_None )
13651  {
13652  arg1 = NULL;
13653  }
13654  else
13655  {
13656  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13657  {
13658  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13659  return NULL;
13660  }
13661  arg1 = marshal_mapform( swig_obj[0] );
13662  }
13663  }
13664  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13665  if (!SWIG_IsOK(res2)) {
13666  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
13667  }
13668  arg2 = (char *)(buf2);
13669  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13670  if (!SWIG_IsOK(ecode3)) {
13671  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
13672  }
13673  arg3 = (PLFLT)(val3);
13674  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13675  if (!SWIG_IsOK(ecode4)) {
13676  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
13677  }
13678  arg4 = (PLFLT)(val4);
13679  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13680  if (!SWIG_IsOK(ecode5)) {
13681  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
13682  }
13683  arg5 = (PLFLT)(val5);
13684  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13685  if (!SWIG_IsOK(ecode6)) {
13686  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
13687  }
13688  arg6 = (PLFLT)(val6);
13689  {
13690  if ( swig_obj[6] != Py_None )
13691  {
13692  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
13693  if ( tmp7 == NULL )
13694  return NULL;
13695  arg7 = (PLINT *) PyArray_DATA( tmp7 );
13696  arg8 = PyArray_DIMS( tmp7 )[0];
13697  }
13698  else
13699  {
13700  arg7 = NULL;
13701  arg8 = 0;
13702  }
13703  }
13704  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
13705  resultobj = SWIG_Py_Void();
13706  {
13707  cleanup_mapform();
13708  }
13709  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13710  {
13711  Py_CLEAR( tmp7 );
13712  }
13713  return resultobj;
13714 fail:
13715  {
13716  cleanup_mapform();
13717  }
13718  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13719  {
13720  Py_CLEAR( tmp7 );
13721  }
13722  return NULL;
13723 }
13724 
13725 
13726 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13727  PyObject *resultobj = 0;
13728  mapform_func arg1 = (mapform_func) 0 ;
13729  char *arg2 = (char *) 0 ;
13730  char *arg3 = (char *) 0 ;
13731  PLFLT arg4 ;
13732  PLFLT arg5 ;
13733  PLFLT arg6 ;
13734  PLFLT arg7 ;
13735  PLINT *arg8 = (PLINT *) 0 ;
13736  PLINT arg9 ;
13737  int res2 ;
13738  char *buf2 = 0 ;
13739  int alloc2 = 0 ;
13740  int res3 ;
13741  char *buf3 = 0 ;
13742  int alloc3 = 0 ;
13743  double val4 ;
13744  int ecode4 = 0 ;
13745  double val5 ;
13746  int ecode5 = 0 ;
13747  double val6 ;
13748  int ecode6 = 0 ;
13749  double val7 ;
13750  int ecode7 = 0 ;
13751  PyArrayObject *tmp8 = NULL ;
13752  PyObject *swig_obj[8] ;
13753 
13754  if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
13755  {
13756  // it must be a callable or none
13757  if ( swig_obj[0] == Py_None )
13758  {
13759  arg1 = NULL;
13760  }
13761  else
13762  {
13763  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13764  {
13765  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13766  return NULL;
13767  }
13768  arg1 = marshal_mapform( swig_obj[0] );
13769  }
13770  }
13771  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13772  if (!SWIG_IsOK(res2)) {
13773  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
13774  }
13775  arg2 = (char *)(buf2);
13776  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
13777  if (!SWIG_IsOK(res3)) {
13778  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
13779  }
13780  arg3 = (char *)(buf3);
13781  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13782  if (!SWIG_IsOK(ecode4)) {
13783  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
13784  }
13785  arg4 = (PLFLT)(val4);
13786  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13787  if (!SWIG_IsOK(ecode5)) {
13788  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
13789  }
13790  arg5 = (PLFLT)(val5);
13791  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13792  if (!SWIG_IsOK(ecode6)) {
13793  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
13794  }
13795  arg6 = (PLFLT)(val6);
13796  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13797  if (!SWIG_IsOK(ecode7)) {
13798  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
13799  }
13800  arg7 = (PLFLT)(val7);
13801  {
13802  if ( swig_obj[7] != Py_None )
13803  {
13804  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
13805  if ( tmp8 == NULL )
13806  return NULL;
13807  arg8 = (PLINT *) PyArray_DATA( tmp8 );
13808  arg9 = PyArray_DIMS( tmp8 )[0];
13809  }
13810  else
13811  {
13812  arg8 = NULL;
13813  arg9 = 0;
13814  }
13815  }
13816  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
13817  resultobj = SWIG_Py_Void();
13818  {
13819  cleanup_mapform();
13820  }
13821  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13822  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13823  {
13824  Py_CLEAR( tmp8 );
13825  }
13826  return resultobj;
13827 fail:
13828  {
13829  cleanup_mapform();
13830  }
13831  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13832  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13833  {
13834  Py_CLEAR( tmp8 );
13835  }
13836  return NULL;
13837 }
13838 
13839 
13840 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13841  PyObject *resultobj = 0;
13842  mapform_func arg1 = (mapform_func) 0 ;
13843  char *arg2 = (char *) 0 ;
13844  PLFLT arg3 ;
13845  PLFLT arg4 ;
13846  PLFLT arg5 ;
13847  char *arg6 = (char *) 0 ;
13848  PLFLT arg7 ;
13849  PLFLT arg8 ;
13850  PLFLT arg9 ;
13851  PLFLT arg10 ;
13852  PLINT arg11 ;
13853  int res2 ;
13854  char *buf2 = 0 ;
13855  int alloc2 = 0 ;
13856  double val3 ;
13857  int ecode3 = 0 ;
13858  double val4 ;
13859  int ecode4 = 0 ;
13860  double val5 ;
13861  int ecode5 = 0 ;
13862  int res6 ;
13863  char *buf6 = 0 ;
13864  int alloc6 = 0 ;
13865  double val7 ;
13866  int ecode7 = 0 ;
13867  double val8 ;
13868  int ecode8 = 0 ;
13869  double val9 ;
13870  int ecode9 = 0 ;
13871  double val10 ;
13872  int ecode10 = 0 ;
13873  int val11 ;
13874  int ecode11 = 0 ;
13875  PyObject *swig_obj[11] ;
13876 
13877  if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
13878  {
13879  // it must be a callable or none
13880  if ( swig_obj[0] == Py_None )
13881  {
13882  arg1 = NULL;
13883  }
13884  else
13885  {
13886  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13887  {
13888  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13889  return NULL;
13890  }
13891  arg1 = marshal_mapform( swig_obj[0] );
13892  }
13893  }
13894  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13895  if (!SWIG_IsOK(res2)) {
13896  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
13897  }
13898  arg2 = (char *)(buf2);
13899  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13900  if (!SWIG_IsOK(ecode3)) {
13901  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
13902  }
13903  arg3 = (PLFLT)(val3);
13904  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13905  if (!SWIG_IsOK(ecode4)) {
13906  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
13907  }
13908  arg4 = (PLFLT)(val4);
13909  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13910  if (!SWIG_IsOK(ecode5)) {
13911  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
13912  }
13913  arg5 = (PLFLT)(val5);
13914  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
13915  if (!SWIG_IsOK(res6)) {
13916  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
13917  }
13918  arg6 = (char *)(buf6);
13919  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13920  if (!SWIG_IsOK(ecode7)) {
13921  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
13922  }
13923  arg7 = (PLFLT)(val7);
13924  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13925  if (!SWIG_IsOK(ecode8)) {
13926  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
13927  }
13928  arg8 = (PLFLT)(val8);
13929  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13930  if (!SWIG_IsOK(ecode9)) {
13931  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
13932  }
13933  arg9 = (PLFLT)(val9);
13934  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13935  if (!SWIG_IsOK(ecode10)) {
13936  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
13937  }
13938  arg10 = (PLFLT)(val10);
13939  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
13940  if (!SWIG_IsOK(ecode11)) {
13941  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
13942  }
13943  arg11 = (PLINT)(val11);
13944  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
13945  resultobj = SWIG_Py_Void();
13946  {
13947  cleanup_mapform();
13948  }
13949  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13950  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13951  return resultobj;
13952 fail:
13953  {
13954  cleanup_mapform();
13955  }
13956  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13957  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13958  return NULL;
13959 }
13960 
13961 
13962 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13963  PyObject *resultobj = 0;
13964  mapform_func arg1 = (mapform_func) 0 ;
13965  char *arg2 = (char *) 0 ;
13966  PLFLT arg3 ;
13967  PLFLT arg4 ;
13968  PLFLT arg5 ;
13969  PLFLT arg6 ;
13970  PLINT *arg7 = (PLINT *) 0 ;
13971  PLINT arg8 ;
13972  int res2 ;
13973  char *buf2 = 0 ;
13974  int alloc2 = 0 ;
13975  double val3 ;
13976  int ecode3 = 0 ;
13977  double val4 ;
13978  int ecode4 = 0 ;
13979  double val5 ;
13980  int ecode5 = 0 ;
13981  double val6 ;
13982  int ecode6 = 0 ;
13983  PyArrayObject *tmp7 = NULL ;
13984  PyObject *swig_obj[7] ;
13985 
13986  if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
13987  {
13988  // it must be a callable or none
13989  if ( swig_obj[0] == Py_None )
13990  {
13991  arg1 = NULL;
13992  }
13993  else
13994  {
13995  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13996  {
13997  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13998  return NULL;
13999  }
14000  arg1 = marshal_mapform( swig_obj[0] );
14001  }
14002  }
14003  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14004  if (!SWIG_IsOK(res2)) {
14005  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14006  }
14007  arg2 = (char *)(buf2);
14008  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14009  if (!SWIG_IsOK(ecode3)) {
14010  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14011  }
14012  arg3 = (PLFLT)(val3);
14013  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14014  if (!SWIG_IsOK(ecode4)) {
14015  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14016  }
14017  arg4 = (PLFLT)(val4);
14018  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14019  if (!SWIG_IsOK(ecode5)) {
14020  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14021  }
14022  arg5 = (PLFLT)(val5);
14023  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14024  if (!SWIG_IsOK(ecode6)) {
14025  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14026  }
14027  arg6 = (PLFLT)(val6);
14028  {
14029  if ( swig_obj[6] != Py_None )
14030  {
14031  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14032  if ( tmp7 == NULL )
14033  return NULL;
14034  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14035  arg8 = PyArray_DIMS( tmp7 )[0];
14036  }
14037  else
14038  {
14039  arg7 = NULL;
14040  arg8 = 0;
14041  }
14042  }
14043  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14044  resultobj = SWIG_Py_Void();
14045  {
14046  cleanup_mapform();
14047  }
14048  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14049  {
14050  Py_CLEAR( tmp7 );
14051  }
14052  return resultobj;
14053 fail:
14054  {
14055  cleanup_mapform();
14056  }
14057  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14058  {
14059  Py_CLEAR( tmp7 );
14060  }
14061  return NULL;
14062 }
14063 
14064 
14065 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14066  PyObject *resultobj = 0;
14067  mapform_func arg1 = (mapform_func) 0 ;
14068  PLFLT arg2 ;
14069  PLFLT arg3 ;
14070  PLFLT arg4 ;
14071  PLFLT arg5 ;
14072  PLFLT arg6 ;
14073  PLFLT arg7 ;
14074  double val2 ;
14075  int ecode2 = 0 ;
14076  double val3 ;
14077  int ecode3 = 0 ;
14078  double val4 ;
14079  int ecode4 = 0 ;
14080  double val5 ;
14081  int ecode5 = 0 ;
14082  double val6 ;
14083  int ecode6 = 0 ;
14084  double val7 ;
14085  int ecode7 = 0 ;
14086  PyObject *swig_obj[7] ;
14087 
14088  if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14089  {
14090  // it must be a callable or none
14091  if ( swig_obj[0] == Py_None )
14092  {
14093  arg1 = NULL;
14094  }
14095  else
14096  {
14097  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14098  {
14099  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14100  return NULL;
14101  }
14102  arg1 = marshal_mapform( swig_obj[0] );
14103  }
14104  }
14105  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14106  if (!SWIG_IsOK(ecode2)) {
14107  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14108  }
14109  arg2 = (PLFLT)(val2);
14110  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14111  if (!SWIG_IsOK(ecode3)) {
14112  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14113  }
14114  arg3 = (PLFLT)(val3);
14115  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14116  if (!SWIG_IsOK(ecode4)) {
14117  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14118  }
14119  arg4 = (PLFLT)(val4);
14120  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14121  if (!SWIG_IsOK(ecode5)) {
14122  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14123  }
14124  arg5 = (PLFLT)(val5);
14125  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14126  if (!SWIG_IsOK(ecode6)) {
14127  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14128  }
14129  arg6 = (PLFLT)(val6);
14130  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14131  if (!SWIG_IsOK(ecode7)) {
14132  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14133  }
14134  arg7 = (PLFLT)(val7);
14135  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14136  resultobj = SWIG_Py_Void();
14137  {
14138  cleanup_mapform();
14139  }
14140  return resultobj;
14141 fail:
14142  {
14143  cleanup_mapform();
14144  }
14145  return NULL;
14146 }
14147 
14148 
14149 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14150  PyObject *resultobj = 0;
14151  PLFLT **arg1 = (PLFLT **) 0 ;
14152  PLINT arg2 ;
14153  PLINT arg3 ;
14154  PLFLT arg4 ;
14155  PLFLT arg5 ;
14156  PLFLT arg6 ;
14157  PLFLT arg7 ;
14158  PLFLT arg8 ;
14159  PLFLT arg9 ;
14160  PLFLT arg10 ;
14161  PLFLT arg11 ;
14162  PLFLT arg12 ;
14163  PLFLT arg13 ;
14164  PyArrayObject *tmp1 = NULL ;
14165  double val4 ;
14166  int ecode4 = 0 ;
14167  double val5 ;
14168  int ecode5 = 0 ;
14169  double val6 ;
14170  int ecode6 = 0 ;
14171  double val7 ;
14172  int ecode7 = 0 ;
14173  double val8 ;
14174  int ecode8 = 0 ;
14175  double val9 ;
14176  int ecode9 = 0 ;
14177  double val10 ;
14178  int ecode10 = 0 ;
14179  double val11 ;
14180  int ecode11 = 0 ;
14181  double val12 ;
14182  int ecode12 = 0 ;
14183  double val13 ;
14184  int ecode13 = 0 ;
14185  PyObject *swig_obj[11] ;
14186 
14187  if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14188  {
14189  int i, size;
14190  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14191  if ( tmp1 == NULL )
14192  return NULL;
14193  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14194  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14195  size = arg3;
14196  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14197  for ( i = 0; i < arg2; i++ )
14198  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14199  }
14200  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14201  if (!SWIG_IsOK(ecode4)) {
14202  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14203  }
14204  arg4 = (PLFLT)(val4);
14205  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14206  if (!SWIG_IsOK(ecode5)) {
14207  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14208  }
14209  arg5 = (PLFLT)(val5);
14210  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14211  if (!SWIG_IsOK(ecode6)) {
14212  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14213  }
14214  arg6 = (PLFLT)(val6);
14215  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14216  if (!SWIG_IsOK(ecode7)) {
14217  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14218  }
14219  arg7 = (PLFLT)(val7);
14220  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14221  if (!SWIG_IsOK(ecode8)) {
14222  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14223  }
14224  arg8 = (PLFLT)(val8);
14225  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14226  if (!SWIG_IsOK(ecode9)) {
14227  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14228  }
14229  arg9 = (PLFLT)(val9);
14230  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14231  if (!SWIG_IsOK(ecode10)) {
14232  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14233  }
14234  arg10 = (PLFLT)(val10);
14235  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14236  if (!SWIG_IsOK(ecode11)) {
14237  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14238  }
14239  arg11 = (PLFLT)(val11);
14240  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14241  if (!SWIG_IsOK(ecode12)) {
14242  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14243  }
14244  arg12 = (PLFLT)(val12);
14245  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14246  if (!SWIG_IsOK(ecode13)) {
14247  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14248  }
14249  arg13 = (PLFLT)(val13);
14250  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14251  resultobj = SWIG_Py_Void();
14252  {
14253  Py_CLEAR( tmp1 );
14254  free( arg1 );
14255  }
14256  return resultobj;
14257 fail:
14258  {
14259  Py_CLEAR( tmp1 );
14260  free( arg1 );
14261  }
14262  return NULL;
14263 }
14264 
14265 
14266 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14267  PyObject *resultobj = 0;
14268  PLFLT **arg1 = (PLFLT **) 0 ;
14269  PLINT arg2 ;
14270  PLINT arg3 ;
14271  PLFLT arg4 ;
14272  PLFLT arg5 ;
14273  PLFLT arg6 ;
14274  PLFLT arg7 ;
14275  PLFLT arg8 ;
14276  PLFLT arg9 ;
14277  PLFLT arg10 ;
14278  PLFLT arg11 ;
14279  pltr_func arg12 = (pltr_func) 0 ;
14280  PLPointer arg13 = (PLPointer) 0 ;
14281  PyArrayObject *tmp1 = NULL ;
14282  double val4 ;
14283  int ecode4 = 0 ;
14284  double val5 ;
14285  int ecode5 = 0 ;
14286  double val6 ;
14287  int ecode6 = 0 ;
14288  double val7 ;
14289  int ecode7 = 0 ;
14290  double val8 ;
14291  int ecode8 = 0 ;
14292  double val9 ;
14293  int ecode9 = 0 ;
14294  double val10 ;
14295  int ecode10 = 0 ;
14296  double val11 ;
14297  int ecode11 = 0 ;
14298  PyObject *swig_obj[11] ;
14299 
14300  {
14301  python_pltr = 0;
14302  arg12 = NULL;
14303  }
14304  {
14305  arg13 = NULL;
14306  }
14307  if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
14308  {
14309  int i, size;
14310  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14311  if ( tmp1 == NULL )
14312  return NULL;
14313  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14314  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14315  size = arg3;
14316  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14317  for ( i = 0; i < arg2; i++ )
14318  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14319  }
14320  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14321  if (!SWIG_IsOK(ecode4)) {
14322  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14323  }
14324  arg4 = (PLFLT)(val4);
14325  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14326  if (!SWIG_IsOK(ecode5)) {
14327  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14328  }
14329  arg5 = (PLFLT)(val5);
14330  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14331  if (!SWIG_IsOK(ecode6)) {
14332  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14333  }
14334  arg6 = (PLFLT)(val6);
14335  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14336  if (!SWIG_IsOK(ecode7)) {
14337  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14338  }
14339  arg7 = (PLFLT)(val7);
14340  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14341  if (!SWIG_IsOK(ecode8)) {
14342  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14343  }
14344  arg8 = (PLFLT)(val8);
14345  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14346  if (!SWIG_IsOK(ecode9)) {
14347  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14348  }
14349  arg9 = (PLFLT)(val9);
14350  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14351  if (!SWIG_IsOK(ecode10)) {
14352  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14353  }
14354  arg10 = (PLFLT)(val10);
14355  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14356  if (!SWIG_IsOK(ecode11)) {
14357  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14358  }
14359  arg11 = (PLFLT)(val11);
14360  if (swig_obj[9]) {
14361  {
14362  // it must be a callable or None
14363  if ( swig_obj[9] == Py_None )
14364  {
14365  arg12 = NULL;
14366  }
14367  else
14368  {
14369  if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
14370  {
14371  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14372  return NULL;
14373  }
14374  arg12 = marshal_pltr( swig_obj[9] );
14375  }
14376  }
14377  }
14378  if (swig_obj[10]) {
14379  {
14380  if ( swig_obj[10] == Py_None )
14381  arg13 = NULL;
14382  else
14383  {
14384  arg13 = marshal_PLPointer( swig_obj[10], 1 );
14385  }
14386  }
14387  }
14388  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14389  resultobj = SWIG_Py_Void();
14390  {
14391  Py_CLEAR( tmp1 );
14392  free( arg1 );
14393  }
14394  {
14395  cleanup_pltr();
14396  }
14397  {
14399  }
14400  return resultobj;
14401 fail:
14402  {
14403  Py_CLEAR( tmp1 );
14404  free( arg1 );
14405  }
14406  {
14407  cleanup_pltr();
14408  }
14409  {
14411  }
14412  return NULL;
14413 }
14414 
14415 
14416 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14417  PyObject *resultobj = 0;
14418 
14419  if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
14420  plClearOpts();
14421  resultobj = SWIG_Py_Void();
14422  return resultobj;
14423 fail:
14424  return NULL;
14425 }
14426 
14427 
14428 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14429  PyObject *resultobj = 0;
14430 
14431  if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
14432  plResetOpts();
14433  resultobj = SWIG_Py_Void();
14434  return resultobj;
14435 fail:
14436  return NULL;
14437 }
14438 
14439 
14440 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14441  PyObject *resultobj = 0;
14442  char *arg1 = (char *) 0 ;
14443  char *arg2 = (char *) 0 ;
14444  int res1 ;
14445  char *buf1 = 0 ;
14446  int alloc1 = 0 ;
14447  int res2 ;
14448  char *buf2 = 0 ;
14449  int alloc2 = 0 ;
14450  PyObject *swig_obj[2] ;
14451 
14452  if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
14453  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
14454  if (!SWIG_IsOK(res1)) {
14455  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14456  }
14457  arg1 = (char *)(buf1);
14458  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14459  if (!SWIG_IsOK(res2)) {
14460  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14461  }
14462  arg2 = (char *)(buf2);
14463  plSetUsage((char const *)arg1,(char const *)arg2);
14464  resultobj = SWIG_Py_Void();
14465  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14466  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14467  return resultobj;
14468 fail:
14469  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14470  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14471  return NULL;
14472 }
14473 
14474 
14475 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14476  PyObject *resultobj = 0;
14477 
14478  if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
14479  plOptUsage();
14480  resultobj = SWIG_Py_Void();
14481  return resultobj;
14482 fail:
14483  return NULL;
14484 }
14485 
14486 
14487 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14488  PyObject *resultobj = 0;
14489  PLFLT **arg1 = (PLFLT **) 0 ;
14490  PLINT arg2 ;
14491  PLINT arg3 ;
14492  PLFLT *arg4 = (PLFLT *) 0 ;
14493  PLFLT *arg5 = (PLFLT *) 0 ;
14494  PyArrayObject *tmp1 = NULL ;
14495  PLFLT temp4 ;
14496  int res4 = SWIG_TMPOBJ ;
14497  PLFLT temp5 ;
14498  int res5 = SWIG_TMPOBJ ;
14499  PyObject *swig_obj[1] ;
14500 
14501  arg4 = &temp4;
14502  arg5 = &temp5;
14503  if (!args) SWIG_fail;
14504  swig_obj[0] = args;
14505  {
14506  int i, size;
14507  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14508  if ( tmp1 == NULL )
14509  return NULL;
14510  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14511  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14512  size = arg3;
14513  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14514  for ( i = 0; i < arg2; i++ )
14515  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14516  }
14517  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14518  resultobj = SWIG_Py_Void();
14519  if (SWIG_IsTmpObj(res4)) {
14520  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14521  } else {
14522  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14523  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14524  }
14525  if (SWIG_IsTmpObj(res5)) {
14526  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14527  } else {
14528  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14529  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14530  }
14531  {
14532  Py_CLEAR( tmp1 );
14533  free( arg1 );
14534  }
14535  return resultobj;
14536 fail:
14537  {
14538  Py_CLEAR( tmp1 );
14539  free( arg1 );
14540  }
14541  return NULL;
14542 }
14543 
14544 
14545 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14546  PyObject *resultobj = 0;
14547  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14548  void *argp1 = 0 ;
14549  int res1 = 0 ;
14550  PyObject *swig_obj[1] ;
14551  PLINT result;
14552 
14553  if (!args) SWIG_fail;
14554  swig_obj[0] = args;
14555  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14556  if (!SWIG_IsOK(res1)) {
14557  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14558  }
14559  arg1 = (PLGraphicsIn *)(argp1);
14560  result = (PLINT)plGetCursor(arg1);
14561  resultobj = SWIG_From_int((int)(result));
14562  return resultobj;
14563 fail:
14564  return NULL;
14565 }
14566 
14567 
14568 static PyMethodDef SwigMethods[] = {
14569  { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
14570  { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14571  { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14572  { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14573  { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14574  { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
14575  { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14576  { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
14577  { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14578  { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
14579  { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14580  { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
14581  { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14582  { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
14583  { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14584  { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
14585  { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14586  { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
14587  { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14588  { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
14589  { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14590  { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
14591  { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14592  { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
14593  { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14594  { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
14595  { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14596  { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
14597  { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
14598  { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
14599  { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14600  { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
14601  { "plsxwin", _wrap_plsxwin, METH_O, NULL},
14602  { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
14603  "Set format of numerical label for contours\n"
14604  "\n"
14605  "DESCRIPTION:\n"
14606  "\n"
14607  " Set format of numerical label for contours.\n"
14608  "\n"
14609  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14610  "\n"
14611  " This function is used example 9.\n"
14612  "\n"
14613  "\n"
14614  "\n"
14615  "SYNOPSIS:\n"
14616  "\n"
14617  "pl_setcontlabelformat(lexp, sigdig)\n"
14618  "\n"
14619  "ARGUMENTS:\n"
14620  "\n"
14621  " lexp (PLINT, input) : If the contour numerical label is greater\n"
14622  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14623  " format is used. Default value of lexp is 4.\n"
14624  "\n"
14625  " sigdig (PLINT, input) : Number of significant digits. Default\n"
14626  " value is 2.\n"
14627  "\n"
14628  ""},
14629  { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
14630  "Set parameters of contour labelling other than format of numerical label\n"
14631  "\n"
14632  "DESCRIPTION:\n"
14633  "\n"
14634  " Set parameters of contour labelling other than those handled by\n"
14635  " pl_setcontlabelformat.\n"
14636  "\n"
14637  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14638  "\n"
14639  " This function is used in example 9.\n"
14640  "\n"
14641  "\n"
14642  "\n"
14643  "SYNOPSIS:\n"
14644  "\n"
14645  "pl_setcontlabelparam(offset, size, spacing, active)\n"
14646  "\n"
14647  "ARGUMENTS:\n"
14648  "\n"
14649  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14650  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
14651  "\n"
14652  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
14653  " Default value is 0.3.\n"
14654  "\n"
14655  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
14656  " Default value is 0.1.\n"
14657  "\n"
14658  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14659  " contour labels on. Default is off (0).\n"
14660  "\n"
14661  ""},
14662  { "pladv", _wrap_pladv, METH_O, "\n"
14663  "Advance the (sub-)page\n"
14664  "\n"
14665  "DESCRIPTION:\n"
14666  "\n"
14667  " Advances to the next subpage if sub=0, performing a page advance if\n"
14668  " there are no remaining subpages on the current page. If subpages\n"
14669  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
14670  " PLplot switches to the specified subpage. Note that this allows you\n"
14671  " to overwrite a plot on the specified subpage; if this is not what you\n"
14672  " intended, use pleop followed by plbop to first advance the page. This\n"
14673  " routine is called automatically (with page=0) by plenv, but if plenv\n"
14674  " is not used, pladv must be called after initializing PLplot but before\n"
14675  " defining the viewport.\n"
14676  "\n"
14677  " Redacted form: pladv(page)\n"
14678  "\n"
14679  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
14680  " 29, and 31.\n"
14681  "\n"
14682  "\n"
14683  "\n"
14684  "SYNOPSIS:\n"
14685  "\n"
14686  "pladv(page)\n"
14687  "\n"
14688  "ARGUMENTS:\n"
14689  "\n"
14690  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
14691  " in the top left corner and increasing along the rows) to which to\n"
14692  " advance. Set to zero to advance to the next subpage (or to the\n"
14693  " next page if subpages are not being used).\n"
14694  "\n"
14695  ""},
14696  { "plarc", _wrap_plarc, METH_VARARGS, "\n"
14697  "Draw a circular or elliptical arc\n"
14698  "\n"
14699  "DESCRIPTION:\n"
14700  "\n"
14701  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14702  " semiminor axis b, starting at angle1 and ending at angle2.\n"
14703  "\n"
14704  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14705  " fill)\n"
14706  "\n"
14707  "\n"
14708  " This function is used in examples 3 and 27.\n"
14709  "\n"
14710  "\n"
14711  "\n"
14712  "SYNOPSIS:\n"
14713  "\n"
14714  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14715  "\n"
14716  "ARGUMENTS:\n"
14717  "\n"
14718  " x (PLFLT, input) : X coordinate of arc center.\n"
14719  "\n"
14720  " y (PLFLT, input) : Y coordinate of arc center.\n"
14721  "\n"
14722  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
14723  "\n"
14724  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
14725  "\n"
14726  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14727  " semimajor axis.\n"
14728  "\n"
14729  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14730  " semimajor axis.\n"
14731  "\n"
14732  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14733  " X-axis.\n"
14734  "\n"
14735  " fill (PLBOOL, input) : Draw a filled arc.\n"
14736  "\n"
14737  ""},
14738  { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
14739  "Draw a box with axes, etc. with arbitrary origin\n"
14740  "\n"
14741  "DESCRIPTION:\n"
14742  "\n"
14743  " Draws a box around the currently defined viewport with arbitrary\n"
14744  " world-coordinate origin specified by x0 and y0 and labels it with\n"
14745  " world coordinate values appropriate to the window. Thus plaxes should\n"
14746  " only be called after defining both viewport and window. The ascii\n"
14747  " character strings xopt and yopt specify how the box should be drawn as\n"
14748  " described below. If ticks and/or subticks are to be drawn for a\n"
14749  " particular axis, the tick intervals and number of subintervals may be\n"
14750  " specified explicitly, or they may be defaulted by setting the\n"
14751  " appropriate arguments to zero.\n"
14752  "\n"
14753  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14754  " ytick, nysub)\n"
14755  "\n"
14756  "\n"
14757  " This function is not used in any examples.\n"
14758  "\n"
14759  "\n"
14760  "\n"
14761  "SYNOPSIS:\n"
14762  "\n"
14763  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14764  "\n"
14765  "ARGUMENTS:\n"
14766  "\n"
14767  " x0 (PLFLT, input) : World X coordinate of origin.\n"
14768  "\n"
14769  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
14770  "\n"
14771  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14772  " options for the x axis. The string can include any combination of\n"
14773  " the following letters (upper or lower case) in any order: a: Draws\n"
14774  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14775  " (x=0).\n"
14776  " b: Draws bottom (X) or left (Y) edge of frame.\n"
14777  " c: Draws top (X) or right (Y) edge of frame.\n"
14778  " d: Plot labels as date / time. Values are assumed to be\n"
14779  " seconds since the epoch (as used by gmtime).\n"
14780  " f: Always use fixed point numeric labels.\n"
14781  " g: Draws a grid at the major tick interval.\n"
14782  " h: Draws a grid at the minor tick interval.\n"
14783  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14784  " inwards.\n"
14785  " l: Labels axis logarithmically. This only affects the labels,\n"
14786  " not the data, and so it is necessary to compute the logarithms\n"
14787  " of data points before passing them to any of the drawing\n"
14788  " routines.\n"
14789  " m: Writes numeric labels at major tick intervals in the\n"
14790  " unconventional location (above box for X, right of box for Y).\n"
14791  " n: Writes numeric labels at major tick intervals in the\n"
14792  " conventional location (below box for X, left of box for Y).\n"
14793  " o: Use custom labelling function to generate axis label text.\n"
14794  " The custom labelling function can be defined with the\n"
14795  " plslabelfunc command.\n"
14796  " s: Enables subticks between major ticks, only valid if t is\n"
14797  " also specified.\n"
14798  " t: Draws major ticks.\n"
14799  " u: Exactly like \"b\" except don't draw edge line.\n"
14800  " w: Exactly like \"c\" except don't draw edge line.\n"
14801  " x: Exactly like \"t\" (including the side effect of the\n"
14802  " numerical labels for the major ticks) except exclude drawing\n"
14803  " the major and minor tick marks.\n"
14804  "\n"
14805  "\n"
14806  " xtick (PLFLT, input) : World coordinate interval between major\n"
14807  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14808  " generates a suitable tick interval.\n"
14809  "\n"
14810  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14811  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14812  " generates a suitable minor tick interval.\n"
14813  "\n"
14814  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14815  " options for the y axis. The string can include any combination of\n"
14816  " the letters defined above for xopt, and in addition may contain:\n"
14817  " v: Write numeric labels for the y axis parallel to the base of the\n"
14818  " graph, rather than parallel to the axis.\n"
14819  "\n"
14820  "\n"
14821  " ytick (PLFLT, input) : World coordinate interval between major\n"
14822  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14823  " generates a suitable tick interval.\n"
14824  "\n"
14825  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14826  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14827  " generates a suitable minor tick interval.\n"
14828  "\n"
14829  ""},
14830  { "plbin", _wrap_plbin, METH_VARARGS, "\n"
14831  "Plot a histogram from binned data\n"
14832  "\n"
14833  "DESCRIPTION:\n"
14834  "\n"
14835  " Plots a histogram consisting of nbin bins. The value associated with\n"
14836  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14837  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14838  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14839  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14840  " placed midway between the values in the x vector. Also see plhist for\n"
14841  " drawing histograms from unbinned data.\n"
14842  "\n"
14843  " Redacted form: General: plbin(x, y, opt)\n"
14844  " Python: plbin(nbin, x, y, opt)\n"
14845  "\n"
14846  "\n"
14847  " This function is not used in any examples.\n"
14848  "\n"
14849  "\n"
14850  "\n"
14851  "SYNOPSIS:\n"
14852  "\n"
14853  "plbin(nbin, x, y, opt)\n"
14854  "\n"
14855  "ARGUMENTS:\n"
14856  "\n"
14857  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14858  " and y vectors.)\n"
14859  "\n"
14860  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
14861  " with bins. These must form a strictly increasing sequence.\n"
14862  "\n"
14863  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
14864  " proportional to the number of points in each bin. This is a PLFLT\n"
14865  " (instead of PLINT) vector so as to allow histograms of\n"
14866  " probabilities, etc.\n"
14867  "\n"
14868  " opt (PLINT, input) : Is a combination of several flags:\n"
14869  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14870  " outer bins are expanded to fill up the entire x-axis and bins of\n"
14871  " zero height are simply drawn.\n"
14872  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14873  " between the x values. If the values in x are equally spaced,\n"
14874  " the values are the center values of the bins.\n"
14875  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14876  " size as the ones inside.\n"
14877  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14878  " (there is a gap for such bins).\n"
14879  "\n"
14880  ""},
14881  { "plbtime", _wrap_plbtime, METH_O, "\n"
14882  "Calculate broken-down time from continuous time for the current stream\n"
14883  "\n"
14884  "DESCRIPTION:\n"
14885  "\n"
14886  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
14887  " continuous time, ctime for the current stream. This function is the\n"
14888  " inverse of plctime.\n"
14889  "\n"
14890  " The PLplot definition of broken-down time is a calendar time that\n"
14891  " completely ignores all time zone offsets, i.e., it is the user's\n"
14892  " responsibility to apply those offsets (if so desired) before using the\n"
14893  " PLplot time API. By default broken-down time is defined using the\n"
14894  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
14895  " continuous time is defined as the number of seconds since the Unix\n"
14896  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
14897  " broken-down and continuous time are possible, see plconfigtime.\n"
14898  "\n"
14899  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
14900  " ctime)\n"
14901  "\n"
14902  "\n"
14903  " This function is used in example 29.\n"
14904  "\n"
14905  "\n"
14906  "\n"
14907  "SYNOPSIS:\n"
14908  "\n"
14909  "plbtime(year, month, day, hour, min, sec, ctime)\n"
14910  "\n"
14911  "ARGUMENTS:\n"
14912  "\n"
14913  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
14914  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
14915  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
14916  " BCE, etc.)\n"
14917  "\n"
14918  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
14919  " the year in the range from 0 (January) to 11 (December).\n"
14920  "\n"
14921  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
14922  " month in the range from 1 to 31.\n"
14923  "\n"
14924  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
14925  " day in the range from 0 to 23.\n"
14926  "\n"
14927  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
14928  " hour in the range from 0 to 59\n"
14929  "\n"
14930  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
14931  " minute in range from 0. to 60.\n"
14932  "\n"
14933  " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
14934  " time is calculated.\n"
14935  "\n"
14936  ""},
14937  { "plbop", _wrap_plbop, METH_NOARGS, "\n"
14938  "Begin a new page\n"
14939  "\n"
14940  "DESCRIPTION:\n"
14941  "\n"
14942  " Begins a new page. For a file driver, the output file is opened if\n"
14943  " necessary. Advancing the page via pleop and plbop is useful when a\n"
14944  " page break is desired at a particular point when plotting to subpages.\n"
14945  " Another use for pleop and plbop is when plotting pages to different\n"
14946  " files, since you can manually set the file name by calling plsfnam\n"
14947  " after the call to pleop. (In fact some drivers may only support a\n"
14948  " single page per file, making this a necessity.) One way to handle\n"
14949  " this case automatically is to page advance via pladv, but enable\n"
14950  " familying (see plsfam) with a small limit on the file size so that a\n"
14951  " new family member file will be created on each page break.\n"
14952  "\n"
14953  " Redacted form: plbop()\n"
14954  "\n"
14955  " This function is used in examples 2 and 20.\n"
14956  "\n"
14957  "\n"
14958  "\n"
14959  "SYNOPSIS:\n"
14960  "\n"
14961  "plbop()\n"
14962  "\n"
14963  ""},
14964  { "plbox", _wrap_plbox, METH_VARARGS, "\n"
14965  "Draw a box with axes, etc\n"
14966  "\n"
14967  "DESCRIPTION:\n"
14968  "\n"
14969  " Draws a box around the currently defined viewport, and labels it with\n"
14970  " world coordinate values appropriate to the window. Thus plbox should\n"
14971  " only be called after defining both viewport and window. The ascii\n"
14972  " character strings xopt and yopt specify how the box should be drawn as\n"
14973  " described below. If ticks and/or subticks are to be drawn for a\n"
14974  " particular axis, the tick intervals and number of subintervals may be\n"
14975  " specified explicitly, or they may be defaulted by setting the\n"
14976  " appropriate arguments to zero.\n"
14977  "\n"
14978  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14979  "\n"
14980  "\n"
14981  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
14982  " and 29.\n"
14983  "\n"
14984  "\n"
14985  "\n"
14986  "SYNOPSIS:\n"
14987  "\n"
14988  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14989  "\n"
14990  "ARGUMENTS:\n"
14991  "\n"
14992  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14993  " options for the x axis. The string can include any combination of\n"
14994  " the following letters (upper or lower case) in any order: a: Draws\n"
14995  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14996  " (x=0).\n"
14997  " b: Draws bottom (X) or left (Y) edge of frame.\n"
14998  " c: Draws top (X) or right (Y) edge of frame.\n"
14999  " d: Plot labels as date / time. Values are assumed to be\n"
15000  " seconds since the epoch (as used by gmtime).\n"
15001  " f: Always use fixed point numeric labels.\n"
15002  " g: Draws a grid at the major tick interval.\n"
15003  " h: Draws a grid at the minor tick interval.\n"
15004  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15005  " inwards.\n"
15006  " l: Labels axis logarithmically. This only affects the labels,\n"
15007  " not the data, and so it is necessary to compute the logarithms\n"
15008  " of data points before passing them to any of the drawing\n"
15009  " routines.\n"
15010  " m: Writes numeric labels at major tick intervals in the\n"
15011  " unconventional location (above box for X, right of box for Y).\n"
15012  " n: Writes numeric labels at major tick intervals in the\n"
15013  " conventional location (below box for X, left of box for Y).\n"
15014  " o: Use custom labelling function to generate axis label text.\n"
15015  " The custom labelling function can be defined with the\n"
15016  " plslabelfunc command.\n"
15017  " s: Enables subticks between major ticks, only valid if t is\n"
15018  " also specified.\n"
15019  " t: Draws major ticks.\n"
15020  " u: Exactly like \"b\" except don't draw edge line.\n"
15021  " w: Exactly like \"c\" except don't draw edge line.\n"
15022  " x: Exactly like \"t\" (including the side effect of the\n"
15023  " numerical labels for the major ticks) except exclude drawing\n"
15024  " the major and minor tick marks.\n"
15025  "\n"
15026  "\n"
15027  " xtick (PLFLT, input) : World coordinate interval between major\n"
15028  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15029  " generates a suitable tick interval.\n"
15030  "\n"
15031  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15032  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15033  " generates a suitable minor tick interval.\n"
15034  "\n"
15035  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15036  " options for the y axis. The string can include any combination of\n"
15037  " the letters defined above for xopt, and in addition may contain:\n"
15038  " v: Write numeric labels for the y axis parallel to the base of the\n"
15039  " graph, rather than parallel to the axis.\n"
15040  "\n"
15041  "\n"
15042  " ytick (PLFLT, input) : World coordinate interval between major\n"
15043  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15044  " generates a suitable tick interval.\n"
15045  "\n"
15046  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15047  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15048  " generates a suitable minor tick interval.\n"
15049  "\n"
15050  ""},
15051  { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15052  "Draw a box with axes, etc, in 3-d\n"
15053  "\n"
15054  "DESCRIPTION:\n"
15055  "\n"
15056  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15057  " plot. For a more complete description of three-dimensional plotting\n"
15058  " see the PLplot documentation.\n"
15059  "\n"
15060  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15061  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15062  "\n"
15063  "\n"
15064  " This function is used in examples 8, 11, 18, and 21.\n"
15065  "\n"
15066  "\n"
15067  "\n"
15068  "SYNOPSIS:\n"
15069  "\n"
15070  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15071  "\n"
15072  "ARGUMENTS:\n"
15073  "\n"
15074  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15075  " options for the x axis. The string can include any combination of\n"
15076  " the following letters (upper or lower case) in any order: b: Draws\n"
15077  " axis at base, at height z=\n"
15078  " zmin where zmin is defined by call to plw3d. This character must be\n"
15079  " specified in order to use any of the other options.\n"
15080  " d: Plot labels as date / time. Values are assumed to be\n"
15081  " seconds since the epoch (as used by gmtime).\n"
15082  " f: Always use fixed point numeric labels.\n"
15083  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15084  " than upwards.\n"
15085  " l: Labels axis logarithmically. This only affects the labels,\n"
15086  " not the data, and so it is necessary to compute the logarithms\n"
15087  " of data points before passing them to any of the drawing\n"
15088  " routines.\n"
15089  " n: Writes numeric labels at major tick intervals.\n"
15090  " o: Use custom labelling function to generate axis label text.\n"
15091  " The custom labelling function can be defined with the\n"
15092  " plslabelfunc command.\n"
15093  " s: Enables subticks between major ticks, only valid if t is\n"
15094  " also specified.\n"
15095  " t: Draws major ticks.\n"
15096  " u: If this is specified, the text label for the axis is\n"
15097  " written under the axis.\n"
15098  "\n"
15099  "\n"
15100  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15101  " the text label for the x axis. It is only drawn if u is in the\n"
15102  " xopt string.\n"
15103  "\n"
15104  " xtick (PLFLT, input) : World coordinate interval between major\n"
15105  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15106  " generates a suitable tick interval.\n"
15107  "\n"
15108  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15109  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15110  " generates a suitable minor tick interval.\n"
15111  "\n"
15112  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15113  " options for the y axis. The string is interpreted in the same way\n"
15114  " as xopt.\n"
15115  "\n"
15116  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15117  " the text label for the y axis. It is only drawn if u is in the\n"
15118  " yopt string.\n"
15119  "\n"
15120  " ytick (PLFLT, input) : World coordinate interval between major\n"
15121  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15122  " generates a suitable tick interval.\n"
15123  "\n"
15124  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15125  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15126  " generates a suitable minor tick interval.\n"
15127  "\n"
15128  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15129  " options for the z axis. The string can include any combination of\n"
15130  " the following letters (upper or lower case) in any order: b: Draws\n"
15131  " z axis to the left of the surface plot.\n"
15132  " c: Draws z axis to the right of the surface plot.\n"
15133  " d: Draws grid lines parallel to the x-y plane behind the\n"
15134  " figure. These lines are not drawn until after plot3d or\n"
15135  " plmesh are called because of the need for hidden line removal.\n"
15136  " e: Plot labels as date / time. Values are assumed to be\n"
15137  " seconds since the epoch (as used by gmtime). Note this\n"
15138  " suboption is interpreted the same as the d suboption for xopt\n"
15139  " and yopt, but it has to be identified as e for zopt since d\n"
15140  " has already been used for the different purpose above.\n"
15141  " f: Always use fixed point numeric labels.\n"
15142  " i: Inverts tick marks, so they are drawn away from the center.\n"
15143  " l: Labels axis logarithmically. This only affects the labels,\n"
15144  " not the data, and so it is necessary to compute the logarithms\n"
15145  " of data points before passing them to any of the drawing\n"
15146  " routines.\n"
15147  " m: Writes numeric labels at major tick intervals on the\n"
15148  " right-hand z axis.\n"
15149  " n: Writes numeric labels at major tick intervals on the\n"
15150  " left-hand z axis.\n"
15151  " o: Use custom labelling function to generate axis label text.\n"
15152  " The custom labelling function can be defined with the\n"
15153  " plslabelfunc command.\n"
15154  " s: Enables subticks between major ticks, only valid if t is\n"
15155  " also specified.\n"
15156  " t: Draws major ticks.\n"
15157  " u: If this is specified, the text label is written beside the\n"
15158  " left-hand axis.\n"
15159  " v: If this is specified, the text label is written beside the\n"
15160  " right-hand axis.\n"
15161  "\n"
15162  "\n"
15163  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15164  " the text label for the z axis. It is only drawn if u or v are in\n"
15165  " the zopt string.\n"
15166  "\n"
15167  " ztick (PLFLT, input) : World coordinate interval between major\n"
15168  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15169  " generates a suitable tick interval.\n"
15170  "\n"
15171  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15172  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15173  " generates a suitable minor tick interval.\n"
15174  "\n"
15175  ""},
15176  { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15177  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15178  "\n"
15179  "DESCRIPTION:\n"
15180  "\n"
15181  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15182  " from relative device coordinates, rx and ry.\n"
15183  "\n"
15184  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15185  "\n"
15186  "\n"
15187  " This function is used in example 31.\n"
15188  "\n"
15189  "\n"
15190  "\n"
15191  "SYNOPSIS:\n"
15192  "\n"
15193  "plcalc_world(rx, ry, wx, wy, window)\n"
15194  "\n"
15195  "ARGUMENTS:\n"
15196  "\n"
15197  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15198  " the x coordinate.\n"
15199  "\n"
15200  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15201  " the y coordinate.\n"
15202  "\n"
15203  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15204  " coordinate corresponding to the relative device coordinates rx and\n"
15205  " ry.\n"
15206  "\n"
15207  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15208  " coordinate corresponding to the relative device coordinates rx and\n"
15209  " ry.\n"
15210  "\n"
15211  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15212  " defined window index that corresponds to the input relative device\n"
15213  " coordinates (and the returned world coordinates). To give some\n"
15214  " background on the window index, for each page the initial window\n"
15215  " index is set to zero, and each time plwind is called within the\n"
15216  " page, world and device coordinates are stored for the window and\n"
15217  " the window index is incremented. Thus, for a simple page layout\n"
15218  " with non-overlapping viewports and one window per viewport, window\n"
15219  " corresponds to the viewport index (in the order which the\n"
15220  " viewport/windows were created) of the only viewport/window\n"
15221  " corresponding to rx and ry. However, for more complicated layouts\n"
15222  " with potentially overlapping viewports and possibly more than one\n"
15223  " window (set of world coordinates) per viewport, window and the\n"
15224  " corresponding output world coordinates corresponds to the last\n"
15225  " window created that fulfills the criterion that the relative\n"
15226  " device coordinates are inside it. Finally, in all cases where the\n"
15227  " input relative device coordinates are not inside any\n"
15228  " viewport/window, then the returned value of the last defined\n"
15229  " window index is set to -1.\n"
15230  "\n"
15231  ""},
15232  { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15233  "Clear current (sub)page\n"
15234  "\n"
15235  "DESCRIPTION:\n"
15236  "\n"
15237  " Clears the current page, effectively erasing everything that have been\n"
15238  " drawn. This command only works with interactive drivers; if the\n"
15239  " driver does not support this, the page is filled with the background\n"
15240  " color in use. If the current page is divided into subpages, only the\n"
15241  " current subpage is erased. The nth subpage can be selected with\n"
15242  " pladv(n).\n"
15243  "\n"
15244  " Redacted form: General: plclear()\n"
15245  "\n"
15246  "\n"
15247  " This function is not used in any examples.\n"
15248  "\n"
15249  "\n"
15250  "\n"
15251  "SYNOPSIS:\n"
15252  "\n"
15253  "plclear()\n"
15254  "\n"
15255  ""},
15256  { "plcol0", _wrap_plcol0, METH_O, "\n"
15257  "Set color, cmap0\n"
15258  "\n"
15259  "DESCRIPTION:\n"
15260  "\n"
15261  " Sets the color index for cmap0 (see the PLplot documentation).\n"
15262  "\n"
15263  " Redacted form: plcol0(icol0)\n"
15264  "\n"
15265  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15266  "\n"
15267  "\n"
15268  "\n"
15269  "SYNOPSIS:\n"
15270  "\n"
15271  "plcol0(icol0)\n"
15272  "\n"
15273  "ARGUMENTS:\n"
15274  "\n"
15275  " icol0 (PLINT, input) : Integer representing the color. The\n"
15276  " defaults at present are (these may change):\n"
15277  " 0 black (default background)\n"
15278  " 1 red (default foreground)\n"
15279  " 2 yellow\n"
15280  " 3 green\n"
15281  " 4 aquamarine\n"
15282  " 5 pink\n"
15283  " 6 wheat\n"
15284  " 7 grey\n"
15285  " 8 brown\n"
15286  " 9 blue\n"
15287  " 10 BlueViolet\n"
15288  " 11 cyan\n"
15289  " 12 turquoise\n"
15290  " 13 magenta\n"
15291  " 14 salmon\n"
15292  " 15 white\n"
15293  "\n"
15294  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15295  " change an individual color in the cmap0 color palette.\n"
15296  "\n"
15297  ""},
15298  { "plcol1", _wrap_plcol1, METH_O, "\n"
15299  "Set color, cmap1\n"
15300  "\n"
15301  "DESCRIPTION:\n"
15302  "\n"
15303  " Sets the color for cmap1 (see the PLplot documentation).\n"
15304  "\n"
15305  " Redacted form: plcol1(col1)\n"
15306  "\n"
15307  " This function is used in examples 12 and 21.\n"
15308  "\n"
15309  "\n"
15310  "\n"
15311  "SYNOPSIS:\n"
15312  "\n"
15313  "plcol1(col1)\n"
15314  "\n"
15315  "ARGUMENTS:\n"
15316  "\n"
15317  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15318  " is mapped to color using the continuous cmap1 palette which by\n"
15319  " default ranges from blue to the background color to red. The\n"
15320  " cmap1 palette can also be straightforwardly changed by the user\n"
15321  " with plscmap1 or plscmap1l.\n"
15322  "\n"
15323  ""},
15324  { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
15325  "Configure the transformation between continuous and broken-down time for the current stream\n"
15326  "\n"
15327  "DESCRIPTION:\n"
15328  "\n"
15329  " Configure the transformation between continuous and broken-down time\n"
15330  " for the current stream. This transformation is used by both plbtime\n"
15331  " and plctime.\n"
15332  "\n"
15333  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15334  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15335  "\n"
15336  "\n"
15337  " This function is used in example 29.\n"
15338  "\n"
15339  "\n"
15340  "\n"
15341  "SYNOPSIS:\n"
15342  "\n"
15343  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15344  "\n"
15345  "ARGUMENTS:\n"
15346  "\n"
15347  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15348  " As a special case, if\n"
15349  " scale is 0., then all other arguments are ignored, and the result (the\n"
15350  " default used by PLplot) is the equivalent of a call to\n"
15351  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15352  " That is, for this special case broken-down time is calculated with\n"
15353  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15354  " and the continuous time is defined as the number of seconds since\n"
15355  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15356  "\n"
15357  " offset1 (PLFLT, input) : If\n"
15358  " ifbtime_offset is true, the parameters\n"
15359  " offset1 and\n"
15360  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15361  " (with units in days) specify the epoch of the continuous time\n"
15362  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15363  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15364  " are used to specify the origin to allow users (by specifying\n"
15365  " offset1 as an integer that can be exactly represented by a\n"
15366  " floating-point variable and specifying\n"
15367  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15368  " the numerical errors of the continuous time representation.\n"
15369  "\n"
15370  " offset2 (PLFLT, input) : See documentation of\n"
15371  " offset1.\n"
15372  "\n"
15373  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15374  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15375  " calendar is used for broken-down time rather than the proleptic\n"
15376  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15377  " have been historically used to define UTC are inserted into the\n"
15378  " broken-down time. Other possibilities for additional control bits\n"
15379  " for ccontrol exist such as making the historical time corrections\n"
15380  " in the broken-down time corresponding to ET (ephemeris time) or\n"
15381  " making the (slightly non-constant) corrections from international\n"
15382  " atomic time (TAI) to what astronomers define as terrestrial time\n"
15383  " (TT). But those additional possibilities have not been\n"
15384  " implemented yet in the qsastime library (one of the PLplot utility\n"
15385  " libraries).\n"
15386  "\n"
15387  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15388  " epoch of the continuous time scale is specified by the user. If\n"
15389  " ifbtime_offset is false, then\n"
15390  " offset1 and\n"
15391  " offset2 are used to specify the epoch, and the following broken-down\n"
15392  " time parameters are completely ignored. If\n"
15393  " ifbtime_offset is true, then\n"
15394  " offset1 and\n"
15395  " offset2 are completely ignored, and the following broken-down time\n"
15396  " parameters are used to specify the epoch.\n"
15397  "\n"
15398  " year (PLINT, input) : Year of epoch.\n"
15399  "\n"
15400  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15401  " 11 (December).\n"
15402  "\n"
15403  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15404  "\n"
15405  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15406  "\n"
15407  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15408  "\n"
15409  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15410  "\n"
15411  ""},
15412  { "plcont", _wrap_plcont, METH_VARARGS, "\n"
15413  "Contour plot\n"
15414  "\n"
15415  "DESCRIPTION:\n"
15416  "\n"
15417  " Draws a contour plot of the data in f[\n"
15418  " nx][\n"
15419  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15420  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
15421  " where all these index ranges are interpreted as one-based for\n"
15422  " historical reasons. A transformation routine pointed to by pltr with\n"
15423  " a generic pointer pltr_data for additional data required by the\n"
15424  " transformation routine is used to map indices within the matrix to the\n"
15425  " world coordinates.\n"
15426  "\n"
15427  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15428  " where (see above discussion) the pltr, pltr_data callback arguments\n"
15429  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
15430  " vectors; or xg and yg matrices.\n"
15431  "\n"
15432  " This function is used in examples 9, 14, 16, and 22.\n"
15433  "\n"
15434  "\n"
15435  "\n"
15436  "SYNOPSIS:\n"
15437  "\n"
15438  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15439  "\n"
15440  "ARGUMENTS:\n"
15441  "\n"
15442  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
15443  "\n"
15444  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
15445  "\n"
15446  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
15447  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
15448  " zero-based for historical backwards-compatibility reasons.\n"
15449  "\n"
15450  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
15451  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
15452  " zero-based for historical backwards-compatibility reasons.\n"
15453  "\n"
15454  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
15455  " which to draw contours.\n"
15456  "\n"
15457  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
15458  "\n"
15459  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
15460  " defines the transformation between the zero-based indices of the\n"
15461  " matrix f and the world coordinates.For the C case, transformation\n"
15462  " functions are provided in the PLplot library: pltr0 for the\n"
15463  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
15464  " respectively defined by vectors and matrices. In addition, C\n"
15465  " callback routines for the transformation can be supplied by the\n"
15466  " user such as the mypltr function in examples/c/x09c.c which\n"
15467  " provides a general linear transformation between index coordinates\n"
15468  " and world coordinates.For languages other than C you should\n"
15469  " consult the PLplot documentation for the details concerning how\n"
15470  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
15471  " general, a particular pattern of callback-associated arguments\n"
15472  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
15473  " yg matrices are respectively interfaced to a linear-transformation\n"
15474  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
15475  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
15476  " the PLplot documentation) support native language callbacks for\n"
15477  " handling index to world-coordinate transformations. Examples of\n"
15478  " these various approaches are given in examples/<language>x09*,\n"
15479  " examples/<language>x16*, examples/<language>x20*,\n"
15480  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
15481  " supported languages.\n"
15482  "\n"
15483  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15484  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
15485  " that is externally supplied.\n"
15486  "\n"
15487  ""},
15488  { "plctime", _wrap_plctime, METH_VARARGS, "\n"
15489  "Calculate continuous time from broken-down time for the current stream\n"
15490  "\n"
15491  "DESCRIPTION:\n"
15492  "\n"
15493  " Calculate continuous time, ctime, from broken-down time for the\n"
15494  " current stream. The broken-down\n"
15495  " time is specified by the following parameters: year, month, day, hour,\n"
15496  " min, and sec. This function is the inverse of plbtime.\n"
15497  "\n"
15498  " The PLplot definition of broken-down time is a calendar time that\n"
15499  " completely ignores all time zone offsets, i.e., it is the user's\n"
15500  " responsibility to apply those offsets (if so desired) before using the\n"
15501  " PLplot time API. By default broken-down time is defined using the\n"
15502  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15503  " continuous time is defined as the number of seconds since the Unix\n"
15504  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15505  " broken-down and continuous time are possible, see plconfigtime which\n"
15506  " specifies that transformation for the current stream.\n"
15507  "\n"
15508  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
15509  " ctime)\n"
15510  "\n"
15511  "\n"
15512  " This function is used in example 29.\n"
15513  "\n"
15514  "\n"
15515  "\n"
15516  "SYNOPSIS:\n"
15517  "\n"
15518  "plctime(year, month, day, hour, min, sec, ctime)\n"
15519  "\n"
15520  "ARGUMENTS:\n"
15521  "\n"
15522  " year (PLINT, input) : Input year.\n"
15523  "\n"
15524  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
15525  " (December).\n"
15526  "\n"
15527  " day (PLINT, input) : Input day in range from 1 to 31.\n"
15528  "\n"
15529  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
15530  "\n"
15531  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
15532  "\n"
15533  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
15534  "\n"
15535  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
15536  " time calculated from the broken-down time specified by the\n"
15537  " previous parameters.\n"
15538  "\n"
15539  ""},
15540  { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
15541  "Copy state parameters from the reference stream to the current stream\n"
15542  "\n"
15543  "DESCRIPTION:\n"
15544  "\n"
15545  " Copies state parameters from the reference stream to the current\n"
15546  " stream. Tell driver interface to map device coordinates unless flags\n"
15547  " == 1.\n"
15548  "\n"
15549  " This function is used for making save files of selected plots (e.g.\n"
15550  " from the TK driver). After initializing, you can get a copy of the\n"
15551  " current plot to the specified device by switching to this stream and\n"
15552  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15553  " appropriate. The plot buffer must have previously been enabled (done\n"
15554  " automatically by some display drivers, such as X).\n"
15555  "\n"
15556  " Redacted form: plcpstrm(iplsr, flags)\n"
15557  "\n"
15558  " This function is used in example 1,20.\n"
15559  "\n"
15560  "\n"
15561  "\n"
15562  "SYNOPSIS:\n"
15563  "\n"
15564  "plcpstrm(iplsr, flags)\n"
15565  "\n"
15566  "ARGUMENTS:\n"
15567  "\n"
15568  " iplsr (PLINT, input) : Number of reference stream.\n"
15569  "\n"
15570  " flags (PLBOOL, input) : If flags is set to true the device\n"
15571  " coordinates are not copied from the reference to current stream.\n"
15572  "\n"
15573  ""},
15574  { "plend", _wrap_plend, METH_NOARGS, "\n"
15575  "End plotting session\n"
15576  "\n"
15577  "DESCRIPTION:\n"
15578  "\n"
15579  " Ends a plotting session, tidies up all the output files, switches\n"
15580  " interactive devices back into text mode and frees up any memory that\n"
15581  " was allocated. Must be called before end of program.\n"
15582  "\n"
15583  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15584  " wait state after a call to plend or other functions which trigger the\n"
15585  " end of a plot page. To avoid this, use the plspause function.\n"
15586  "\n"
15587  " Redacted form: plend()\n"
15588  "\n"
15589  " This function is used in all of the examples.\n"
15590  "\n"
15591  "\n"
15592  "\n"
15593  "SYNOPSIS:\n"
15594  "\n"
15595  "plend()\n"
15596  "\n"
15597  ""},
15598  { "plend1", _wrap_plend1, METH_NOARGS, "\n"
15599  "End plotting session for current stream\n"
15600  "\n"
15601  "DESCRIPTION:\n"
15602  "\n"
15603  " Ends a plotting session for the current output stream only. See\n"
15604  " plsstrm for more info.\n"
15605  "\n"
15606  " Redacted form: plend1()\n"
15607  "\n"
15608  " This function is used in examples 1 and 20.\n"
15609  "\n"
15610  "\n"
15611  "\n"
15612  "SYNOPSIS:\n"
15613  "\n"
15614  "plend1()\n"
15615  "\n"
15616  ""},
15617  { "plenv", _wrap_plenv, METH_VARARGS, "\n"
15618  "Set up standard window and draw box\n"
15619  "\n"
15620  "DESCRIPTION:\n"
15621  "\n"
15622  " Sets up plotter environment for simple graphs by calling pladv and\n"
15623  " setting up viewport and window to sensible default values. plenv\n"
15624  " leaves a standard margin (left-hand margin of eight character heights,\n"
15625  " and a margin around the other three sides of five character heights)\n"
15626  " around most graphs for axis labels and a title. When these defaults\n"
15627  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15628  " plvasp for setting up the viewport, plwind for defining the window,\n"
15629  " and plbox for drawing the box.\n"
15630  "\n"
15631  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15632  "\n"
15633  " This function is used in example 1,3,9,13,14,19-22,29.\n"
15634  "\n"
15635  "\n"
15636  "\n"
15637  "SYNOPSIS:\n"
15638  "\n"
15639  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15640  "\n"
15641  "ARGUMENTS:\n"
15642  "\n"
15643  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15644  " world coordinates).\n"
15645  "\n"
15646  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15647  " world coordinates).\n"
15648  "\n"
15649  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15650  " coordinates).\n"
15651  "\n"
15652  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15653  " coordinates).\n"
15654  "\n"
15655  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15656  " scales will not be set, the user must set up the scale before\n"
15657  " calling plenv using plsvpa, plvasp or other.\n"
15658  " 0: the x and y axes are scaled independently to use as much of\n"
15659  " the screen as possible.\n"
15660  " 1: the scales of the x and y axes are made equal.\n"
15661  " 2: the axis of the x and y axes are made equal, and the plot\n"
15662  " box will be square.\n"
15663  "\n"
15664  "\n"
15665  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15666  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15667  " -1: draw box only.\n"
15668  " 0: draw box, ticks, and numeric tick labels.\n"
15669  " 1: also draw coordinate axes at x=0 and y=0.\n"
15670  " 2: also draw a grid at major tick positions in both\n"
15671  " coordinates.\n"
15672  " 3: also draw a grid at minor tick positions in both\n"
15673  " coordinates.\n"
15674  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15675  " have to be converted to logarithms separately.)\n"
15676  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15677  " have to be converted to logarithms separately.)\n"
15678  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15679  " have to be converted to logarithms separately.)\n"
15680  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15681  " have to be converted to logarithms separately.)\n"
15682  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15683  " have to be converted to logarithms separately.)\n"
15684  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15685  " have to be converted to logarithms separately.)\n"
15686  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15687  " have to be converted to logarithms separately.)\n"
15688  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15689  " have to be converted to logarithms separately.)\n"
15690  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15691  " and y data have to be converted to logarithms separately.)\n"
15692  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15693  " and y data have to be converted to logarithms separately.)\n"
15694  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15695  " and y data have to be converted to logarithms separately.)\n"
15696  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15697  " and y data have to be converted to logarithms separately.)\n"
15698  " 40: same as 0 except date / time x labels.\n"
15699  " 41: same as 1 except date / time x labels.\n"
15700  " 42: same as 2 except date / time x labels.\n"
15701  " 43: same as 3 except date / time x labels.\n"
15702  " 50: same as 0 except date / time y labels.\n"
15703  " 51: same as 1 except date / time y labels.\n"
15704  " 52: same as 2 except date / time y labels.\n"
15705  " 53: same as 3 except date / time y labels.\n"
15706  " 60: same as 0 except date / time x and y labels.\n"
15707  " 61: same as 1 except date / time x and y labels.\n"
15708  " 62: same as 2 except date / time x and y labels.\n"
15709  " 63: same as 3 except date / time x and y labels.\n"
15710  " 70: same as 0 except custom x and y labels.\n"
15711  " 71: same as 1 except custom x and y labels.\n"
15712  " 72: same as 2 except custom x and y labels.\n"
15713  " 73: same as 3 except custom x and y labels.\n"
15714  "\n"
15715  ""},
15716  { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
15717  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
15718  "\n"
15719  "DESCRIPTION:\n"
15720  "\n"
15721  " Sets up plotter environment for simple graphs by calling pladv and\n"
15722  " setting up viewport and window to sensible default values. plenv0\n"
15723  " leaves a standard margin (left-hand margin of eight character heights,\n"
15724  " and a margin around the other three sides of five character heights)\n"
15725  " around most graphs for axis labels and a title. When these defaults\n"
15726  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15727  " plvasp for setting up the viewport, plwind for defining the window,\n"
15728  " and plbox for drawing the box.\n"
15729  "\n"
15730  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15731  "\n"
15732  " This function is used in example 21.\n"
15733  "\n"
15734  "\n"
15735  "\n"
15736  "SYNOPSIS:\n"
15737  "\n"
15738  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15739  "\n"
15740  "ARGUMENTS:\n"
15741  "\n"
15742  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15743  " world coordinates).\n"
15744  "\n"
15745  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15746  " world coordinates).\n"
15747  "\n"
15748  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15749  " coordinates).\n"
15750  "\n"
15751  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15752  " coordinates).\n"
15753  "\n"
15754  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15755  " scales will not be set, the user must set up the scale before\n"
15756  " calling plenv0 using plsvpa, plvasp or other.\n"
15757  " 0: the x and y axes are scaled independently to use as much of\n"
15758  " the screen as possible.\n"
15759  " 1: the scales of the x and y axes are made equal.\n"
15760  " 2: the axis of the x and y axes are made equal, and the plot\n"
15761  " box will be square.\n"
15762  "\n"
15763  "\n"
15764  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15765  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15766  " -1: draw box only.\n"
15767  " 0: draw box, ticks, and numeric tick labels.\n"
15768  " 1: also draw coordinate axes at x=0 and y=0.\n"
15769  " 2: also draw a grid at major tick positions in both\n"
15770  " coordinates.\n"
15771  " 3: also draw a grid at minor tick positions in both\n"
15772  " coordinates.\n"
15773  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15774  " have to be converted to logarithms separately.)\n"
15775  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15776  " have to be converted to logarithms separately.)\n"
15777  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15778  " have to be converted to logarithms separately.)\n"
15779  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15780  " have to be converted to logarithms separately.)\n"
15781  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15782  " have to be converted to logarithms separately.)\n"
15783  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15784  " have to be converted to logarithms separately.)\n"
15785  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15786  " have to be converted to logarithms separately.)\n"
15787  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15788  " have to be converted to logarithms separately.)\n"
15789  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15790  " and y data have to be converted to logarithms separately.)\n"
15791  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15792  " and y data have to be converted to logarithms separately.)\n"
15793  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15794  " and y data have to be converted to logarithms separately.)\n"
15795  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15796  " and y data have to be converted to logarithms separately.)\n"
15797  " 40: same as 0 except date / time x labels.\n"
15798  " 41: same as 1 except date / time x labels.\n"
15799  " 42: same as 2 except date / time x labels.\n"
15800  " 43: same as 3 except date / time x labels.\n"
15801  " 50: same as 0 except date / time y labels.\n"
15802  " 51: same as 1 except date / time y labels.\n"
15803  " 52: same as 2 except date / time y labels.\n"
15804  " 53: same as 3 except date / time y labels.\n"
15805  " 60: same as 0 except date / time x and y labels.\n"
15806  " 61: same as 1 except date / time x and y labels.\n"
15807  " 62: same as 2 except date / time x and y labels.\n"
15808  " 63: same as 3 except date / time x and y labels.\n"
15809  " 70: same as 0 except custom x and y labels.\n"
15810  " 71: same as 1 except custom x and y labels.\n"
15811  " 72: same as 2 except custom x and y labels.\n"
15812  " 73: same as 3 except custom x and y labels.\n"
15813  "\n"
15814  ""},
15815  { "pleop", _wrap_pleop, METH_NOARGS, "\n"
15816  "Eject current page\n"
15817  "\n"
15818  "DESCRIPTION:\n"
15819  "\n"
15820  " Clears the graphics screen of an interactive device, or ejects a page\n"
15821  " on a plotter. See plbop for more information.\n"
15822  "\n"
15823  " Redacted form: pleop()\n"
15824  "\n"
15825  " This function is used in example 2,14.\n"
15826  "\n"
15827  "\n"
15828  "\n"
15829  "SYNOPSIS:\n"
15830  "\n"
15831  "pleop()\n"
15832  "\n"
15833  ""},
15834  { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
15835  "Draw error bars in x direction\n"
15836  "\n"
15837  "DESCRIPTION:\n"
15838  "\n"
15839  " Draws a set of n error bars in x direction, the i'th error bar\n"
15840  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
15841  " of the error bars are of length equal to the minor tick length\n"
15842  " (settable using plsmin).\n"
15843  "\n"
15844  " Redacted form: General: plerrx(xmin, ymax, y)\n"
15845  "\n"
15846  "\n"
15847  " This function is used in example 29.\n"
15848  "\n"
15849  "\n"
15850  "\n"
15851  "SYNOPSIS:\n"
15852  "\n"
15853  "plerrx(n, xmin, xmax, y)\n"
15854  "\n"
15855  "ARGUMENTS:\n"
15856  "\n"
15857  " n (PLINT, input) : Number of error bars to draw.\n"
15858  "\n"
15859  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15860  " of the left-hand endpoints of the error bars.\n"
15861  "\n"
15862  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15863  " of the right-hand endpoints of the error bars.\n"
15864  "\n"
15865  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15866  " the error bars.\n"
15867  "\n"
15868  ""},
15869  { "plerry", _wrap_plerry, METH_VARARGS, "\n"
15870  "Draw error bars in the y direction\n"
15871  "\n"
15872  "DESCRIPTION:\n"
15873  "\n"
15874  " Draws a set of n error bars in the y direction, the i'th error bar\n"
15875  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
15876  " of the error bars are of length equal to the minor tick length\n"
15877  " (settable using plsmin).\n"
15878  "\n"
15879  " Redacted form: General: plerry(x, ymin, ymax)\n"
15880  "\n"
15881  "\n"
15882  " This function is used in example 29.\n"
15883  "\n"
15884  "\n"
15885  "\n"
15886  "SYNOPSIS:\n"
15887  "\n"
15888  "plerry(n, x, ymin, ymax)\n"
15889  "\n"
15890  "ARGUMENTS:\n"
15891  "\n"
15892  " n (PLINT, input) : Number of error bars to draw.\n"
15893  "\n"
15894  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15895  " the error bars.\n"
15896  "\n"
15897  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15898  " of the lower endpoints of the error bars.\n"
15899  "\n"
15900  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15901  " of the upper endpoints of the error bars.\n"
15902  "\n"
15903  ""},
15904  { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
15905  "Advance to the next family file on the next new page\n"
15906  "\n"
15907  "DESCRIPTION:\n"
15908  "\n"
15909  " Advance to the next family file on the next new page.\n"
15910  "\n"
15911  " Redacted form: plfamadv()\n"
15912  "\n"
15913  " This function is not used in any examples.\n"
15914  "\n"
15915  "\n"
15916  "\n"
15917  "SYNOPSIS:\n"
15918  "\n"
15919  "plfamadv()\n"
15920  "\n"
15921  ""},
15922  { "plfill", _wrap_plfill, METH_VARARGS, "\n"
15923  "Draw filled polygon\n"
15924  "\n"
15925  "DESCRIPTION:\n"
15926  "\n"
15927  " Fills the polygon defined by the n points (\n"
15928  " x[i],\n"
15929  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15930  " style is a solid fill. The routine will automatically close the\n"
15931  " polygon between the last and first vertices. If multiple closed\n"
15932  " polygons are passed in x and y then plfill will fill in between them.\n"
15933  "\n"
15934  " Redacted form: plfill(x,y)\n"
15935  "\n"
15936  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
15937  "\n"
15938  "\n"
15939  "\n"
15940  "SYNOPSIS:\n"
15941  "\n"
15942  "plfill(n, x, y)\n"
15943  "\n"
15944  "ARGUMENTS:\n"
15945  "\n"
15946  " n (PLINT, input) : Number of vertices in polygon.\n"
15947  "\n"
15948  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15949  " vertices.\n"
15950  "\n"
15951  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15952  " vertices.\n"
15953  "\n"
15954  ""},
15955  { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
15956  "Draw filled polygon in 3D\n"
15957  "\n"
15958  "DESCRIPTION:\n"
15959  "\n"
15960  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
15961  " vectors using the pattern defined by plpsty or plpat. The routine\n"
15962  " will automatically close the polygon between the last and first\n"
15963  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
15964  " plfill3 will fill in between them.\n"
15965  "\n"
15966  " Redacted form: General: plfill3(x, y, z)\n"
15967  "\n"
15968  "\n"
15969  " This function is used in example 15.\n"
15970  "\n"
15971  "\n"
15972  "\n"
15973  "SYNOPSIS:\n"
15974  "\n"
15975  "plfill3(n, x, y, z)\n"
15976  "\n"
15977  "ARGUMENTS:\n"
15978  "\n"
15979  " n (PLINT, input) : Number of vertices in polygon.\n"
15980  "\n"
15981  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15982  " vertices.\n"
15983  "\n"
15984  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15985  " vertices.\n"
15986  "\n"
15987  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
15988  " vertices.\n"
15989  "\n"
15990  ""},
15991  { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
15992  "Draw linear gradient inside polygon\n"
15993  "\n"
15994  "DESCRIPTION:\n"
15995  "\n"
15996  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
15997  " points (\n"
15998  " x[i],\n"
15999  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16000  " polygon coordinates and the gradient angle are all expressed in world\n"
16001  " coordinates. The angle from the x axis for both the rotated\n"
16002  " coordinate system and the gradient vector is specified by angle. The\n"
16003  " magnitude of the gradient vector is the difference between the maximum\n"
16004  " and minimum values of x for the vertices in the rotated coordinate\n"
16005  " system. The origin of the gradient vector can be interpreted as being\n"
16006  " anywhere on the line corresponding to the minimum x value for the\n"
16007  " vertices in the rotated coordinate system. The distance along the\n"
16008  " gradient vector is linearly transformed to the independent variable of\n"
16009  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16010  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16011  " color corresponding to the independent variable of cmap1. For more\n"
16012  " information about cmap1 (see the PLplot documentation).\n"
16013  "\n"
16014  " Redacted form: plgradient(x,y,angle)\n"
16015  "\n"
16016  " This function is used in examples 25 and 30.\n"
16017  "\n"
16018  "\n"
16019  "\n"
16020  "SYNOPSIS:\n"
16021  "\n"
16022  "plgradient(n, x, y, angle)\n"
16023  "\n"
16024  "ARGUMENTS:\n"
16025  "\n"
16026  " n (PLINT, input) : Number of vertices in polygon.\n"
16027  "\n"
16028  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16029  " vertices.\n"
16030  "\n"
16031  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16032  " vertices.\n"
16033  "\n"
16034  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16035  " axis.\n"
16036  "\n"
16037  ""},
16038  { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16039  "Flushes the output stream\n"
16040  "\n"
16041  "DESCRIPTION:\n"
16042  "\n"
16043  " Flushes the output stream. Use sparingly, if at all.\n"
16044  "\n"
16045  " Redacted form: plflush()\n"
16046  "\n"
16047  " This function is used in examples 1 and 14.\n"
16048  "\n"
16049  "\n"
16050  "\n"
16051  "SYNOPSIS:\n"
16052  "\n"
16053  "plflush()\n"
16054  "\n"
16055  ""},
16056  { "plfont", _wrap_plfont, METH_O, "\n"
16057  "Set font\n"
16058  "\n"
16059  "DESCRIPTION:\n"
16060  "\n"
16061  " Sets the font used for subsequent text and symbols. For devices that\n"
16062  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16063  " fonts with extended character set are loaded (see plfontld). For\n"
16064  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16065  " this routine calls the plsfci routine with argument set up\n"
16066  " appropriately for the various cases below. However, this method of\n"
16067  " specifying the font for unicode-aware devices is deprecated, and the\n"
16068  " much more flexible method of calling plsfont directly is recommended\n"
16069  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16070  "\n"
16071  " Redacted form: plfont(ifont)\n"
16072  "\n"
16073  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16074  "\n"
16075  "\n"
16076  "\n"
16077  "SYNOPSIS:\n"
16078  "\n"
16079  "plfont(ifont)\n"
16080  "\n"
16081  "ARGUMENTS:\n"
16082  "\n"
16083  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16084  " (simplest and fastest)\n"
16085  " 2: Serif font\n"
16086  " 3: Italic font\n"
16087  " 4: Script font\n"
16088  "\n"
16089  ""},
16090  { "plfontld", _wrap_plfontld, METH_O, "\n"
16091  "Load Hershey fonts\n"
16092  "\n"
16093  "DESCRIPTION:\n"
16094  "\n"
16095  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16096  " be called before or after initializing PLplot. If not explicitly\n"
16097  " called before PLplot initialization, then by default that\n"
16098  " initialization loads Hershey fonts with the extended character set.\n"
16099  " This routine only has a practical effect for devices that still use\n"
16100  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16101  " system fonts instead of Hershey fonts).\n"
16102  "\n"
16103  " Redacted form: plfontld(fnt)\n"
16104  "\n"
16105  " This function is used in examples 1 and 7.\n"
16106  "\n"
16107  "\n"
16108  "\n"
16109  "SYNOPSIS:\n"
16110  "\n"
16111  "plfontld(fnt)\n"
16112  "\n"
16113  "ARGUMENTS:\n"
16114  "\n"
16115  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16116  " A zero value specifies Hershey fonts with the standard character\n"
16117  " set and a non-zero value (the default assumed if plfontld is never\n"
16118  " called) specifies Hershey fonts with the extended character set.\n"
16119  "\n"
16120  ""},
16121  { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16122  "Get character default height and current (scaled) height\n"
16123  "\n"
16124  "DESCRIPTION:\n"
16125  "\n"
16126  " Get character default height and current (scaled) height.\n"
16127  "\n"
16128  " Redacted form: plgchr(p_def, p_ht)\n"
16129  "\n"
16130  " This function is used in example 23.\n"
16131  "\n"
16132  "\n"
16133  "\n"
16134  "SYNOPSIS:\n"
16135  "\n"
16136  "plgchr(p_def, p_ht)\n"
16137  "\n"
16138  "ARGUMENTS:\n"
16139  "\n"
16140  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16141  " character height (mm).\n"
16142  "\n"
16143  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16144  " character height (mm).\n"
16145  "\n"
16146  ""},
16147  { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16148  "Returns 8-bit RGB values for given color index from cmap0\n"
16149  "\n"
16150  "DESCRIPTION:\n"
16151  "\n"
16152  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16153  " PLplot documentation). Values are negative if an invalid color id is\n"
16154  " given.\n"
16155  "\n"
16156  " Redacted form: plgcol0(icol0, r, g, b)\n"
16157  "\n"
16158  " This function is used in example 2.\n"
16159  "\n"
16160  "\n"
16161  "\n"
16162  "SYNOPSIS:\n"
16163  "\n"
16164  "plgcol0(icol0, r, g, b)\n"
16165  "\n"
16166  "ARGUMENTS:\n"
16167  "\n"
16168  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16169  "\n"
16170  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16171  " value.\n"
16172  "\n"
16173  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16174  " value.\n"
16175  "\n"
16176  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16177  " value.\n"
16178  "\n"
16179  ""},
16180  { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16181  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16182  "\n"
16183  "DESCRIPTION:\n"
16184  "\n"
16185  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16186  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16187  " Values are negative if an invalid color id is given.\n"
16188  "\n"
16189  " Redacted form: plgcola(r, g, b)\n"
16190  "\n"
16191  " This function is used in example 30.\n"
16192  "\n"
16193  "\n"
16194  "\n"
16195  "SYNOPSIS:\n"
16196  "\n"
16197  "plgcol0a(icol0, r, g, b, alpha)\n"
16198  "\n"
16199  "ARGUMENTS:\n"
16200  "\n"
16201  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16202  "\n"
16203  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16204  " in the range from 0 to 255.\n"
16205  "\n"
16206  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16207  " in the range from 0 to 255.\n"
16208  "\n"
16209  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16210  " in the range from 0 to 255.\n"
16211  "\n"
16212  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16213  " transparency in the range from (0.0-1.0).\n"
16214  "\n"
16215  ""},
16216  { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16217  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16218  "\n"
16219  "DESCRIPTION:\n"
16220  "\n"
16221  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16222  "\n"
16223  " Redacted form: plgcolbg(r, g, b)\n"
16224  "\n"
16225  " This function is used in example 31.\n"
16226  "\n"
16227  "\n"
16228  "\n"
16229  "SYNOPSIS:\n"
16230  "\n"
16231  "plgcolbg(r, g, b)\n"
16232  "\n"
16233  "ARGUMENTS:\n"
16234  "\n"
16235  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16236  " in the range from 0 to 255.\n"
16237  "\n"
16238  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16239  " in the range from 0 to 255.\n"
16240  "\n"
16241  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16242  " in the range from 0 to 255.\n"
16243  "\n"
16244  ""},
16245  { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16246  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16247  "\n"
16248  "DESCRIPTION:\n"
16249  "\n"
16250  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16251  " alpha transparency value.\n"
16252  "\n"
16253  " This function is used in example 31.\n"
16254  "\n"
16255  "\n"
16256  "\n"
16257  "SYNOPSIS:\n"
16258  "\n"
16259  "plgcolbga(r, g, b, alpha)\n"
16260  "\n"
16261  "ARGUMENTS:\n"
16262  "\n"
16263  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16264  " in the range from 0 to 255.\n"
16265  "\n"
16266  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16267  " in the range from 0 to 255.\n"
16268  "\n"
16269  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16270  " in the range from 0 to 255.\n"
16271  "\n"
16272  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16273  " transparency in the range (0.0-1.0).\n"
16274  "\n"
16275  ""},
16276  { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
16277  "Get the current device-compression setting\n"
16278  "\n"
16279  "DESCRIPTION:\n"
16280  "\n"
16281  " Get the current device-compression setting. This parameter is only\n"
16282  " used for drivers that provide compression.\n"
16283  "\n"
16284  " Redacted form: plgcompression(compression)\n"
16285  "\n"
16286  " This function is used in example 31.\n"
16287  "\n"
16288  "\n"
16289  "\n"
16290  "SYNOPSIS:\n"
16291  "\n"
16292  "plgcompression(compression)\n"
16293  "\n"
16294  "ARGUMENTS:\n"
16295  "\n"
16296  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16297  " compression setting for the current device.\n"
16298  "\n"
16299  ""},
16300  { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
16301  "Get the current device (keyword) name\n"
16302  "\n"
16303  "DESCRIPTION:\n"
16304  "\n"
16305  " Get the current device (keyword) name. Note: you must have allocated\n"
16306  " space for this (80 characters is safe).\n"
16307  "\n"
16308  " Redacted form: plgdev(p_dev)\n"
16309  "\n"
16310  " This function is used in example 14.\n"
16311  "\n"
16312  "\n"
16313  "\n"
16314  "SYNOPSIS:\n"
16315  "\n"
16316  "plgdev(p_dev)\n"
16317  "\n"
16318  "ARGUMENTS:\n"
16319  "\n"
16320  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16321  " (with preallocated length of 80 characters or more) containing the\n"
16322  " device (keyword) name.\n"
16323  "\n"
16324  ""},
16325  { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
16326  "Get parameters that define current device-space window\n"
16327  "\n"
16328  "DESCRIPTION:\n"
16329  "\n"
16330  " Get relative margin width, aspect ratio, and relative justification\n"
16331  " that define current device-space window. If plsdidev has not been\n"
16332  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16333  " p_jy will all be 0.\n"
16334  "\n"
16335  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16336  "\n"
16337  " This function is used in example 31.\n"
16338  "\n"
16339  "\n"
16340  "\n"
16341  "SYNOPSIS:\n"
16342  "\n"
16343  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16344  "\n"
16345  "ARGUMENTS:\n"
16346  "\n"
16347  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16348  " margin width.\n"
16349  "\n"
16350  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16351  " ratio.\n"
16352  "\n"
16353  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16354  " justification in x.\n"
16355  "\n"
16356  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16357  " justification in y.\n"
16358  "\n"
16359  ""},
16360  { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
16361  "Get plot orientation\n"
16362  "\n"
16363  "DESCRIPTION:\n"
16364  "\n"
16365  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16366  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16367  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16368  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16369  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16370  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16371  " not been called the default value pointed to by p_rot will be 0.\n"
16372  "\n"
16373  " Redacted form: plgdiori(p_rot)\n"
16374  "\n"
16375  " This function is not used in any examples.\n"
16376  "\n"
16377  "\n"
16378  "\n"
16379  "SYNOPSIS:\n"
16380  "\n"
16381  "plgdiori(p_rot)\n"
16382  "\n"
16383  "ARGUMENTS:\n"
16384  "\n"
16385  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16386  " parameter.\n"
16387  "\n"
16388  ""},
16389  { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
16390  "Get parameters that define current plot-space window\n"
16391  "\n"
16392  "DESCRIPTION:\n"
16393  "\n"
16394  " Get relative minima and maxima that define current plot-space window.\n"
16395  " If plsdiplt has not been called the default values pointed to by\n"
16396  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16397  "\n"
16398  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16399  "\n"
16400  " This function is used in example 31.\n"
16401  "\n"
16402  "\n"
16403  "\n"
16404  "SYNOPSIS:\n"
16405  "\n"
16406  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16407  "\n"
16408  "ARGUMENTS:\n"
16409  "\n"
16410  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16411  " minimum in x.\n"
16412  "\n"
16413  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16414  " minimum in y.\n"
16415  "\n"
16416  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16417  " maximum in x.\n"
16418  "\n"
16419  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16420  " maximum in y.\n"
16421  "\n"
16422  ""},
16423  { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
16424  "Get family file parameters\n"
16425  "\n"
16426  "DESCRIPTION:\n"
16427  "\n"
16428  " Gets information about current family file, if familying is enabled.\n"
16429  " See the PLplot documentation for more information.\n"
16430  "\n"
16431  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16432  "\n"
16433  " This function is used in examples 14 and 31.\n"
16434  "\n"
16435  "\n"
16436  "\n"
16437  "SYNOPSIS:\n"
16438  "\n"
16439  "plgfam(p_fam, p_num, p_bmax)\n"
16440  "\n"
16441  "ARGUMENTS:\n"
16442  "\n"
16443  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16444  " family flag value. If nonzero, familying is enabled for the\n"
16445  " current device.\n"
16446  "\n"
16447  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16448  " family file number.\n"
16449  "\n"
16450  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16451  " file size (in bytes) for a family file.\n"
16452  "\n"
16453  ""},
16454  { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
16455  "Get FCI (font characterization integer)\n"
16456  "\n"
16457  "DESCRIPTION:\n"
16458  "\n"
16459  " Gets information about the current font using the FCI approach. See\n"
16460  " the PLplot documentation for more information.\n"
16461  "\n"
16462  " Redacted form: plgfci(p_fci)\n"
16463  "\n"
16464  " This function is used in example 23.\n"
16465  "\n"
16466  "\n"
16467  "\n"
16468  "SYNOPSIS:\n"
16469  "\n"
16470  "plgfci(p_fci)\n"
16471  "\n"
16472  "ARGUMENTS:\n"
16473  "\n"
16474  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
16475  " FCI value.\n"
16476  "\n"
16477  ""},
16478  { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
16479  "Get output file name\n"
16480  "\n"
16481  "DESCRIPTION:\n"
16482  "\n"
16483  " Gets the current output file name, if applicable.\n"
16484  "\n"
16485  " Redacted form: plgfnam(fnam)\n"
16486  "\n"
16487  " This function is used in example 31.\n"
16488  "\n"
16489  "\n"
16490  "\n"
16491  "SYNOPSIS:\n"
16492  "\n"
16493  "plgfnam(fnam)\n"
16494  "\n"
16495  "ARGUMENTS:\n"
16496  "\n"
16497  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16498  " (with preallocated length of 80 characters or more) containing the\n"
16499  " file name.\n"
16500  "\n"
16501  ""},
16502  { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
16503  "Get family, style and weight of the current font\n"
16504  "\n"
16505  "DESCRIPTION:\n"
16506  "\n"
16507  " Gets information about current font. See the PLplot documentation for\n"
16508  " more information on font selection.\n"
16509  "\n"
16510  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16511  "\n"
16512  " This function is used in example 23.\n"
16513  "\n"
16514  "\n"
16515  "\n"
16516  "SYNOPSIS:\n"
16517  "\n"
16518  "plgfont(p_family, p_style, p_weight)\n"
16519  "\n"
16520  "ARGUMENTS:\n"
16521  "\n"
16522  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16523  " font family. The available values are given by the PL_FCI_*\n"
16524  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16525  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16526  " p_family is NULL then the font family is not returned.\n"
16527  "\n"
16528  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16529  " font style. The available values are given by the PL_FCI_*\n"
16530  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16531  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
16532  " style is not returned.\n"
16533  "\n"
16534  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16535  " font weight. The available values are given by the PL_FCI_*\n"
16536  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16537  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16538  " returned.\n"
16539  "\n"
16540  ""},
16541  { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
16542  "Get the (current) run level\n"
16543  "\n"
16544  "DESCRIPTION:\n"
16545  "\n"
16546  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
16547  " 1, initialized\n"
16548  " 2, viewport defined\n"
16549  " 3, world coordinates defined\n"
16550  "\n"
16551  "\n"
16552  " Redacted form: plglevel(p_level)\n"
16553  "\n"
16554  " This function is used in example 31.\n"
16555  "\n"
16556  "\n"
16557  "\n"
16558  "SYNOPSIS:\n"
16559  "\n"
16560  "plglevel(p_level)\n"
16561  "\n"
16562  "ARGUMENTS:\n"
16563  "\n"
16564  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
16565  " level.\n"
16566  "\n"
16567  ""},
16568  { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
16569  "Get page parameters\n"
16570  "\n"
16571  "DESCRIPTION:\n"
16572  "\n"
16573  " Gets the current page configuration. The length and offset values are\n"
16574  " expressed in units that are specific to the current driver. For\n"
16575  " instance: screen drivers will usually interpret them as number of\n"
16576  " pixels, whereas printer drivers will usually use mm.\n"
16577  "\n"
16578  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16579  "\n"
16580  " This function is used in examples 14 and 31.\n"
16581  "\n"
16582  "\n"
16583  "\n"
16584  "SYNOPSIS:\n"
16585  "\n"
16586  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16587  "\n"
16588  "ARGUMENTS:\n"
16589  "\n"
16590  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16591  " pixels/inch (DPI) in x.\n"
16592  "\n"
16593  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16594  " pixels/inch (DPI) in y.\n"
16595  "\n"
16596  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16597  " length.\n"
16598  "\n"
16599  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16600  " length.\n"
16601  "\n"
16602  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16603  " offset.\n"
16604  "\n"
16605  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16606  " offset.\n"
16607  "\n"
16608  ""},
16609  { "plgra", _wrap_plgra, METH_NOARGS, "\n"
16610  "Switch to graphics screen\n"
16611  "\n"
16612  "DESCRIPTION:\n"
16613  "\n"
16614  " Sets an interactive device to graphics mode, used in conjunction with\n"
16615  " pltext to allow graphics and text to be interspersed. On a device\n"
16616  " which supports separate text and graphics windows, this command causes\n"
16617  " control to be switched to the graphics window. If already in graphics\n"
16618  " mode, this command is ignored. It is also ignored on devices which\n"
16619  " only support a single window or use a different method for shifting\n"
16620  " focus. See also pltext.\n"
16621  "\n"
16622  " Redacted form: plgra()\n"
16623  "\n"
16624  " This function is used in example 1.\n"
16625  "\n"
16626  "\n"
16627  "\n"
16628  "SYNOPSIS:\n"
16629  "\n"
16630  "plgra()\n"
16631  "\n"
16632  ""},
16633  { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
16634  "Grid data from irregularly sampled data\n"
16635  "\n"
16636  "DESCRIPTION:\n"
16637  "\n"
16638  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
16639  " require data organized as a grid, i.e., with x sample point values\n"
16640  " independent of y coordinate and vice versa. This function takes\n"
16641  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
16642  " vectors; reads the desired grid location from the input vectors\n"
16643  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
16644  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
16645  " interpolate the data to the grid is specified with the argument type\n"
16646  " which can have one parameter specified in argument data.\n"
16647  "\n"
16648  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16649  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16650  "\n"
16651  "\n"
16652  " This function is used in example 21.\n"
16653  "\n"
16654  "\n"
16655  "\n"
16656  "SYNOPSIS:\n"
16657  "\n"
16658  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16659  "\n"
16660  "ARGUMENTS:\n"
16661  "\n"
16662  " x (PLFLT_VECTOR, input) : The input x vector.\n"
16663  "\n"
16664  " y (PLFLT_VECTOR, input) : The input y vector.\n"
16665  "\n"
16666  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
16667  " y[i], z[i] represents one data sample coordinate.\n"
16668  "\n"
16669  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16670  " vectors.\n"
16671  "\n"
16672  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16673  " in the x direction. Usually xg has nptsx equally spaced values\n"
16674  " from the minimum to the maximum values of the x input vector.\n"
16675  "\n"
16676  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
16677  "\n"
16678  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16679  " in the y direction. Similar to the xg parameter.\n"
16680  "\n"
16681  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
16682  "\n"
16683  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
16684  " where data lies in the grid specified by xg and yg. Therefore the\n"
16685  " zg matrix must be dimensioned\n"
16686  " nptsx by\n"
16687  " nptsy.\n"
16688  "\n"
16689  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
16690  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
16691  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
16692  " GRID_NNI: Natural Neighbors Interpolation\n"
16693  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
16694  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
16695  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16696  " Weighted\n"
16697  " For details of the algorithms read the source file plgridd.c.\n"
16698  "\n"
16699  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16700  " which can be specified through this argument. Currently, for\n"
16701  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16702  " use, the lower the value, the noisier (more local) the\n"
16703  " approximation is.\n"
16704  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16705  " range [1. .. 2.]. High values enable the usage of very thin\n"
16706  " triangles for interpolation, possibly resulting in error in\n"
16707  " the approximation.\n"
16708  " GRID_NNI, only weights greater than data will be accepted. If\n"
16709  " 0, all weights will be accepted.\n"
16710  "\n"
16711  ""},
16712  { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
16713  "Get current subpage parameters\n"
16714  "\n"
16715  "DESCRIPTION:\n"
16716  "\n"
16717  " Gets the size of the current subpage in millimeters measured from the\n"
16718  " bottom left hand corner of the output device page or screen. Can be\n"
16719  " used in conjunction with plsvpa for setting the size of a viewport in\n"
16720  " absolute coordinates (millimeters).\n"
16721  "\n"
16722  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16723  "\n"
16724  " This function is used in example 23.\n"
16725  "\n"
16726  "\n"
16727  "\n"
16728  "SYNOPSIS:\n"
16729  "\n"
16730  "plgspa(xmin, xmax, ymin, ymax)\n"
16731  "\n"
16732  "ARGUMENTS:\n"
16733  "\n"
16734  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16735  " the left hand edge of the subpage in millimeters.\n"
16736  "\n"
16737  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16738  " the right hand edge of the subpage in millimeters.\n"
16739  "\n"
16740  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16741  " the bottom edge of the subpage in millimeters.\n"
16742  "\n"
16743  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16744  " the top edge of the subpage in millimeters.\n"
16745  "\n"
16746  ""},
16747  { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
16748  "Get current stream number\n"
16749  "\n"
16750  "DESCRIPTION:\n"
16751  "\n"
16752  " Gets the number of the current output stream. See also plsstrm.\n"
16753  "\n"
16754  " Redacted form: plgstrm(p_strm)\n"
16755  "\n"
16756  " This function is used in example 1,20.\n"
16757  "\n"
16758  "\n"
16759  "\n"
16760  "SYNOPSIS:\n"
16761  "\n"
16762  "plgstrm(p_strm)\n"
16763  "\n"
16764  "ARGUMENTS:\n"
16765  "\n"
16766  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16767  " stream value.\n"
16768  "\n"
16769  ""},
16770  { "plgver", _wrap_plgver, METH_NOARGS, "\n"
16771  "Get the current library version number\n"
16772  "\n"
16773  "DESCRIPTION:\n"
16774  "\n"
16775  " Get the current library version number. Note: you must have allocated\n"
16776  " space for this (80 characters is safe).\n"
16777  "\n"
16778  " Redacted form: plgver(p_ver)\n"
16779  "\n"
16780  " This function is used in example 1.\n"
16781  "\n"
16782  "\n"
16783  "\n"
16784  "SYNOPSIS:\n"
16785  "\n"
16786  "plgver(p_ver)\n"
16787  "\n"
16788  "ARGUMENTS:\n"
16789  "\n"
16790  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16791  " (with preallocated length of 80 characters or more) containing the\n"
16792  " PLplot version number.\n"
16793  "\n"
16794  ""},
16795  { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
16796  "Get viewport limits in normalized device coordinates\n"
16797  "\n"
16798  "DESCRIPTION:\n"
16799  "\n"
16800  " Get viewport limits in normalized device coordinates.\n"
16801  "\n"
16802  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16803  "\n"
16804  "\n"
16805  " This function is used in example 31.\n"
16806  "\n"
16807  "\n"
16808  "\n"
16809  "SYNOPSIS:\n"
16810  "\n"
16811  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16812  "\n"
16813  "ARGUMENTS:\n"
16814  "\n"
16815  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16816  " viewport limit of the normalized device coordinate in x.\n"
16817  "\n"
16818  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16819  " viewport limit of the normalized device coordinate in x.\n"
16820  "\n"
16821  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16822  " viewport limit of the normalized device coordinate in y.\n"
16823  "\n"
16824  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16825  " viewport limit of the normalized device coordinate in y.\n"
16826  "\n"
16827  ""},
16828  { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
16829  "Get viewport limits in world coordinates\n"
16830  "\n"
16831  "DESCRIPTION:\n"
16832  "\n"
16833  " Get viewport limits in world coordinates.\n"
16834  "\n"
16835  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16836  "\n"
16837  "\n"
16838  " This function is used in example 31.\n"
16839  "\n"
16840  "\n"
16841  "\n"
16842  "SYNOPSIS:\n"
16843  "\n"
16844  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16845  "\n"
16846  "ARGUMENTS:\n"
16847  "\n"
16848  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16849  " viewport limit of the world coordinate in x.\n"
16850  "\n"
16851  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16852  " viewport limit of the world coordinate in x.\n"
16853  "\n"
16854  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16855  " viewport limit of the world coordinate in y.\n"
16856  "\n"
16857  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16858  " viewport limit of the world coordinate in y.\n"
16859  "\n"
16860  ""},
16861  { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
16862  "Get x axis parameters\n"
16863  "\n"
16864  "DESCRIPTION:\n"
16865  "\n"
16866  " Returns current values of the p_digmax and p_digits flags for the x\n"
16867  " axis. p_digits is updated after the plot is drawn, so this routine\n"
16868  " should only be called after the call to plbox (or plbox3) is complete.\n"
16869  " See the PLplot documentation for more information.\n"
16870  "\n"
16871  " Redacted form: plgxax(p_digmax, p_digits)\n"
16872  "\n"
16873  " This function is used in example 31.\n"
16874  "\n"
16875  "\n"
16876  "\n"
16877  "SYNOPSIS:\n"
16878  "\n"
16879  "plgxax(p_digmax, p_digits)\n"
16880  "\n"
16881  "ARGUMENTS:\n"
16882  "\n"
16883  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16884  " number of digits for the x axis. If nonzero, the printed label\n"
16885  " has been switched to a floating-point representation when the\n"
16886  " number of digits exceeds this value.\n"
16887  "\n"
16888  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16889  " number of digits for the numeric labels (x axis) from the last\n"
16890  " plot.\n"
16891  "\n"
16892  ""},
16893  { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
16894  "Get y axis parameters\n"
16895  "\n"
16896  "DESCRIPTION:\n"
16897  "\n"
16898  " Identical to plgxax, except that arguments are flags for y axis. See\n"
16899  " the description of plgxax for more detail.\n"
16900  "\n"
16901  " Redacted form: plgyax(p_digmax, p_digits)\n"
16902  "\n"
16903  " This function is used in example 31.\n"
16904  "\n"
16905  "\n"
16906  "\n"
16907  "SYNOPSIS:\n"
16908  "\n"
16909  "plgyax(p_digmax, p_digits)\n"
16910  "\n"
16911  "ARGUMENTS:\n"
16912  "\n"
16913  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16914  " number of digits for the y axis. If nonzero, the printed label\n"
16915  " has been switched to a floating-point representation when the\n"
16916  " number of digits exceeds this value.\n"
16917  "\n"
16918  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16919  " number of digits for the numeric labels (y axis) from the last\n"
16920  " plot.\n"
16921  "\n"
16922  ""},
16923  { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
16924  "Get z axis parameters\n"
16925  "\n"
16926  "DESCRIPTION:\n"
16927  "\n"
16928  " Identical to plgxax, except that arguments are flags for z axis. See\n"
16929  " the description of plgxax for more detail.\n"
16930  "\n"
16931  " Redacted form: plgzax(p_digmax, p_digits)\n"
16932  "\n"
16933  " This function is used in example 31.\n"
16934  "\n"
16935  "\n"
16936  "\n"
16937  "SYNOPSIS:\n"
16938  "\n"
16939  "plgzax(p_digmax, p_digits)\n"
16940  "\n"
16941  "ARGUMENTS:\n"
16942  "\n"
16943  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16944  " number of digits for the z axis. If nonzero, the printed label\n"
16945  " has been switched to a floating-point representation when the\n"
16946  " number of digits exceeds this value.\n"
16947  "\n"
16948  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16949  " number of digits for the numeric labels (z axis) from the last\n"
16950  " plot.\n"
16951  "\n"
16952  ""},
16953  { "plhist", _wrap_plhist, METH_VARARGS, "\n"
16954  "Plot a histogram from unbinned data\n"
16955  "\n"
16956  "DESCRIPTION:\n"
16957  "\n"
16958  " Plots a histogram from n data points stored in the data vector. This\n"
16959  " routine bins the data into nbin bins equally spaced between datmin and\n"
16960  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16961  " opt allows, among other things, the histogram either to be plotted in\n"
16962  " an existing window or causes plhist to call plenv with suitable limits\n"
16963  " before plotting the histogram.\n"
16964  "\n"
16965  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16966  "\n"
16967  " This function is used in example 5.\n"
16968  "\n"
16969  "\n"
16970  "\n"
16971  "SYNOPSIS:\n"
16972  "\n"
16973  "plhist(n, data, datmin, datmax, nbin, opt)\n"
16974  "\n"
16975  "ARGUMENTS:\n"
16976  "\n"
16977  " n (PLINT, input) : Number of data points.\n"
16978  "\n"
16979  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
16980  " n data points.\n"
16981  "\n"
16982  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
16983  "\n"
16984  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
16985  "\n"
16986  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16987  " divide the interval xmin to xmax.\n"
16988  "\n"
16989  " opt (PLINT, input) : Is a combination of several flags:\n"
16990  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16991  " the histogram data, the outer bins are expanded to fill up the\n"
16992  " entire x-axis, data outside the given extremes are assigned to the\n"
16993  " outer bins and bins of zero height are simply drawn.\n"
16994  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16995  " to fit the histogram data, without this flag, plenv is called\n"
16996  " to set the world coordinates.\n"
16997  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16998  " extremes are not taken into account. This option should\n"
16999  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17000  " properly present the data.\n"
17001  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17002  " size as the ones inside.\n"
17003  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17004  " (there is a gap for such bins).\n"
17005  "\n"
17006  ""},
17007  { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17008  "Convert HLS color to RGB\n"
17009  "\n"
17010  "DESCRIPTION:\n"
17011  "\n"
17012  " Convert HLS color coordinates to RGB.\n"
17013  "\n"
17014  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17015  "\n"
17016  "\n"
17017  " This function is used in example 2.\n"
17018  "\n"
17019  "\n"
17020  "\n"
17021  "SYNOPSIS:\n"
17022  "\n"
17023  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17024  "\n"
17025  "ARGUMENTS:\n"
17026  "\n"
17027  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17028  " cylinder.\n"
17029  "\n"
17030  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17031  " the axis of the color cylinder.\n"
17032  "\n"
17033  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17034  " the radius of the color cylinder.\n"
17035  "\n"
17036  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17037  " (0.0-1.0) of the color.\n"
17038  "\n"
17039  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17040  " intensity (0.0-1.0) of the color.\n"
17041  "\n"
17042  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17043  " intensity (0.0-1.0) of the color.\n"
17044  "\n"
17045  ""},
17046  { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17047  "Initialize PLplot\n"
17048  "\n"
17049  "DESCRIPTION:\n"
17050  "\n"
17051  " Initializing the plotting package. The program prompts for the device\n"
17052  " keyword or number of the desired output device. Hitting a RETURN in\n"
17053  " response to the prompt is the same as selecting the first device.\n"
17054  " plinit will issue no prompt if either the device was specified\n"
17055  " previously (via command line flag, the plsetopt function, or the\n"
17056  " plsdev function), or if only one device is enabled when PLplot is\n"
17057  " installed. If subpages have been specified, the output device is\n"
17058  " divided into nx by ny subpages, each of which may be used\n"
17059  " independently. If plinit is called again during a program, the\n"
17060  " previously opened file will be closed. The subroutine pladv is used\n"
17061  " to advance from one subpage to the next.\n"
17062  "\n"
17063  " Redacted form: plinit()\n"
17064  "\n"
17065  " This function is used in all of the examples.\n"
17066  "\n"
17067  "\n"
17068  "\n"
17069  "SYNOPSIS:\n"
17070  "\n"
17071  "plinit()\n"
17072  "\n"
17073  ""},
17074  { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17075  "Draw a line between two points\n"
17076  "\n"
17077  "DESCRIPTION:\n"
17078  "\n"
17079  " Joins the point (\n"
17080  " x1,\n"
17081  " y1) to (\n"
17082  " x2,\n"
17083  " y2).\n"
17084  "\n"
17085  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17086  "\n"
17087  " This function is used in examples 3 and 14.\n"
17088  "\n"
17089  "\n"
17090  "\n"
17091  "SYNOPSIS:\n"
17092  "\n"
17093  "pljoin(x1, y1, x2, y2)\n"
17094  "\n"
17095  "ARGUMENTS:\n"
17096  "\n"
17097  " x1 (PLFLT, input) : x coordinate of first point.\n"
17098  "\n"
17099  " y1 (PLFLT, input) : y coordinate of first point.\n"
17100  "\n"
17101  " x2 (PLFLT, input) : x coordinate of second point.\n"
17102  "\n"
17103  " y2 (PLFLT, input) : y coordinate of second point.\n"
17104  "\n"
17105  ""},
17106  { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17107  "Simple routine to write labels\n"
17108  "\n"
17109  "DESCRIPTION:\n"
17110  "\n"
17111  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17112  "\n"
17113  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17114  "\n"
17115  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17116  "\n"
17117  "\n"
17118  "\n"
17119  "SYNOPSIS:\n"
17120  "\n"
17121  "pllab(xlabel, ylabel, tlabel)\n"
17122  "\n"
17123  "ARGUMENTS:\n"
17124  "\n"
17125  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17126  " the label for the x axis.\n"
17127  "\n"
17128  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17129  " the label for the y axis.\n"
17130  "\n"
17131  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17132  " the title of the plot.\n"
17133  "\n"
17134  ""},
17135  { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17136  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17137  "\n"
17138  "DESCRIPTION:\n"
17139  "\n"
17140  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17141  " line, and/or line of symbols for each annotated legend entry. (See\n"
17142  " plcolorbar for similar functionality for creating continuous color\n"
17143  " bars.) The arguments of pllegend provide control over the location\n"
17144  " and size of the legend as well as the location and characteristics of\n"
17145  " the elements (most of which are optional) within that legend. The\n"
17146  " resulting legend is clipped at the boundaries of the current subpage.\n"
17147  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17148  " defined in the documentation of the position parameter.)\n"
17149  "\n"
17150  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17151  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17152  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17153  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17154  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17155  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17156  "\n"
17157  " This function is used in examples 4, 26, and 33.\n"
17158  "\n"
17159  "\n"
17160  "\n"
17161  "SYNOPSIS:\n"
17162  "\n"
17163  "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"
17164  "\n"
17165  "ARGUMENTS:\n"
17166  "\n"
17167  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17168  " legend width in adopted coordinates. This quantity is calculated\n"
17169  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17170  " the routine depending on nlegend and nrow), and the length\n"
17171  " (calculated internally) of the longest text string.\n"
17172  "\n"
17173  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17174  " legend height in adopted coordinates. This quantity is calculated\n"
17175  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17176  " the routine depending on nlegend and nrow).\n"
17177  "\n"
17178  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17179  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17180  " on the left of the legend and the plotted area on the right.\n"
17181  " Otherwise, put the text area on the right of the legend and the\n"
17182  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17183  " plot a (semitransparent) background for the legend. If the\n"
17184  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17185  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17186  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17187  " plot the resulting array of legend entries in row-major order.\n"
17188  " Otherwise, plot the legend entries in column-major order.\n"
17189  "\n"
17190  " position (PLINT, input) : position contains bits which control the\n"
17191  " overall position of the legend and the definition of the adopted\n"
17192  " coordinates used for positions just like what is done for the\n"
17193  " position argument for plcolorbar. However, note that the defaults\n"
17194  " for the position bits (see below) are different than the\n"
17195  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17196  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17197  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17198  " the 16 possible standard positions (the 4 corners and centers of\n"
17199  " the 4 sides for both the inside and outside cases) of the legend\n"
17200  " relative to the adopted coordinate system. The corner positions\n"
17201  " are specified by the appropriate combination of two of the\n"
17202  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17203  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17204  " value of one of those bits. The adopted coordinates are\n"
17205  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17206  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17207  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17208  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17209  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17210  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17211  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17212  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17213  "\n"
17214  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17215  " coordinates from the specified standard position of the legend.\n"
17216  " For positive x, the direction of motion away from the standard\n"
17217  " position is inward/outward from the standard corner positions or\n"
17218  " standard left or right positions if the\n"
17219  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17220  " For the standard top or bottom positions, the direction of motion\n"
17221  " is toward positive X.\n"
17222  "\n"
17223  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17224  " coordinates from the specified standard position of the legend.\n"
17225  " For positive y, the direction of motion away from the standard\n"
17226  " position is inward/outward from the standard corner positions or\n"
17227  " standard top or bottom positions if the\n"
17228  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17229  " the standard left or right positions, the direction of motion is\n"
17230  " toward positive Y.\n"
17231  "\n"
17232  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17233  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17234  " symbols are drawn) of the legend.\n"
17235  "\n"
17236  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17237  " legend (PL_LEGEND_BACKGROUND).\n"
17238  "\n"
17239  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17240  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17241  "\n"
17242  " bb_style (PLINT, input) : The pllsty style number for the\n"
17243  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17244  "\n"
17245  " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17246  " render the\n"
17247  " nlegend legend entries. For internal transformations of\n"
17248  " nrow, see further remarks under\n"
17249  " nlegend.\n"
17250  "\n"
17251  " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17252  " to render the\n"
17253  " nlegend legend entries. For internal transformations of\n"
17254  " ncolumn, see further remarks under\n"
17255  " nlegend.\n"
17256  "\n"
17257  " nlegend (PLINT, input) : Number of legend entries. The above\n"
17258  " nrow and\n"
17259  " ncolumn values are transformed internally to be consistent with\n"
17260  " nlegend. If either\n"
17261  " nrow or\n"
17262  " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17263  " of\n"
17264  " nrow and\n"
17265  " ncolumn is less than\n"
17266  " nlegend, the smaller of the two (or\n"
17267  " nrow, if\n"
17268  " nrow ==\n"
17269  " ncolumn) is increased so the product is >=\n"
17270  " nlegend. Thus, for example, the common\n"
17271  " nrow = 0,\n"
17272  " ncolumn = 0 case is transformed internally to\n"
17273  " nrow =\n"
17274  " nlegend,\n"
17275  " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
17276  " column.\n"
17277  "\n"
17278  " opt_array (PLINT_VECTOR, input) : A vector of\n"
17279  " nlegend values of options to control each individual plotted area\n"
17280  " corresponding to a legend entry. If the\n"
17281  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17282  " area. If the\n"
17283  " PL_LEGEND_COLOR_BOX,\n"
17284  " PL_LEGEND_LINE, and/or\n"
17285  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17286  " entry is plotted with a colored box; a line; and/or a line of\n"
17287  " symbols.\n"
17288  "\n"
17289  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17290  " area in units of character width.\n"
17291  "\n"
17292  " text_scale (PLFLT, input) : Character height scale for text\n"
17293  " annotations.\n"
17294  "\n"
17295  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17296  " character height from one legend entry to the next.\n"
17297  "\n"
17298  " text_justification (PLFLT, input) : Justification parameter used\n"
17299  " for text justification. The most common values of\n"
17300  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17301  " is left justified, centred, or right justified within the text\n"
17302  " area, but other values are allowed as well.\n"
17303  "\n"
17304  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17305  " nlegend cmap0 text colors.\n"
17306  "\n"
17307  " text (PLCHAR_MATRIX, input) : A vector of\n"
17308  " nlegend UTF-8 character strings containing the legend annotations.\n"
17309  "\n"
17310  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17311  " nlegend cmap0 colors for the discrete colored boxes (\n"
17312  " PL_LEGEND_COLOR_BOX).\n"
17313  "\n"
17314  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17315  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17316  " PL_LEGEND_COLOR_BOX).\n"
17317  "\n"
17318  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17319  " nlegend scales (units of fraction of character height) for the height\n"
17320  " of the discrete colored boxes (\n"
17321  " PL_LEGEND_COLOR_BOX).\n"
17322  "\n"
17323  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17324  " nlegend line widths for the patterns specified by box_patterns (\n"
17325  " PL_LEGEND_COLOR_BOX).\n"
17326  "\n"
17327  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17328  " nlegend cmap0 line colors (\n"
17329  " PL_LEGEND_LINE).\n"
17330  "\n"
17331  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17332  " nlegend line styles (plsty indices) (\n"
17333  " PL_LEGEND_LINE).\n"
17334  "\n"
17335  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17336  " nlegend line widths (\n"
17337  " PL_LEGEND_LINE).\n"
17338  "\n"
17339  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17340  " nlegend cmap0 symbol colors (\n"
17341  " PL_LEGEND_SYMBOL).\n"
17342  "\n"
17343  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17344  " nlegend scale values for the symbol height (\n"
17345  " PL_LEGEND_SYMBOL).\n"
17346  "\n"
17347  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17348  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17349  " area (\n"
17350  " PL_LEGEND_SYMBOL).\n"
17351  "\n"
17352  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17353  " nlegend UTF-8 character strings containing the legend symbols. (\n"
17354  " PL_LEGEND_SYMBOL).\n"
17355  "\n"
17356  ""},
17357  { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
17358  "Plot color bar for image, shade or gradient plots\n"
17359  "\n"
17360  "DESCRIPTION:\n"
17361  "\n"
17362  " Routine for creating a continuous color bar for image, shade, or\n"
17363  " gradient plots. (See pllegend for similar functionality for creating\n"
17364  " legends with discrete elements). The arguments of plcolorbar provide\n"
17365  " control over the location and size of the color bar as well as the\n"
17366  " location and characteristics of the elements (most of which are\n"
17367  " optional) within that color bar. The resulting color bar is clipped\n"
17368  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17369  " system used for some of the parameters is defined in the documentation\n"
17370  " of the position parameter.)\n"
17371  "\n"
17372  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17373  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17374  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17375  " labels, axis_opts, ticks, sub_ticks, values)\n"
17376  "\n"
17377  " This function is used in examples 16 and 33.\n"
17378  "\n"
17379  "\n"
17380  "\n"
17381  "SYNOPSIS:\n"
17382  "\n"
17383  "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"
17384  "\n"
17385  "ARGUMENTS:\n"
17386  "\n"
17387  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17388  " labelled and decorated color bar width in adopted coordinates.\n"
17389  "\n"
17390  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17391  " labelled and decorated color bar height in adopted coordinates.\n"
17392  "\n"
17393  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17394  " color bar. The orientation (direction of the maximum value) of\n"
17395  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17396  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17397  " specified, the default orientation is toward the top if the\n"
17398  " colorbar is placed on the left or right of the viewport or toward\n"
17399  " the right if the colorbar is placed on the top or bottom of the\n"
17400  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17401  " (semitransparent) background for the color bar. If the\n"
17402  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17403  " color bar. The type of color bar must be specified with one of\n"
17404  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17405  " more than one of those bits is set only the first one in the above\n"
17406  " list is honored. The position of the (optional) label/title can be\n"
17407  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17408  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17409  " will be drawn. If more than one of this list of bits is specified,\n"
17410  " only the first one on the list is honored. End-caps for the color\n"
17411  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17412  " If a particular color bar cap option is not specified then no cap\n"
17413  " will be drawn for that end. As a special case for\n"
17414  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17415  " specified. If this option is provided then any tick marks and tick\n"
17416  " labels will be placed at the breaks between shaded segments. TODO:\n"
17417  " This should be expanded to support custom placement of tick marks\n"
17418  " and tick labels at custom value locations for any color bar type.\n"
17419  "\n"
17420  " position (PLINT, input) : position contains bits which control the\n"
17421  " overall position of the color bar and the definition of the\n"
17422  " adopted coordinates used for positions just like what is done for\n"
17423  " the position argument for pllegend. However, note that the\n"
17424  " defaults for the position bits (see below) are different than the\n"
17425  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17426  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17427  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17428  " the 16 possible standard positions (the 4 corners and centers of\n"
17429  " the 4 sides for both the inside and outside cases) of the color\n"
17430  " bar relative to the adopted coordinate system. The corner\n"
17431  " positions are specified by the appropriate combination of two of\n"
17432  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17433  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17434  " value of one of those bits. The adopted coordinates are\n"
17435  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17436  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17437  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17438  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17439  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17440  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17441  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17442  " PL_POSITION_VIEWPORT.\n"
17443  "\n"
17444  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17445  " coordinates from the specified standard position of the color bar.\n"
17446  " For positive x, the direction of motion away from the standard\n"
17447  " position is inward/outward from the standard corner positions or\n"
17448  " standard left or right positions if the\n"
17449  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17450  " For the standard top or bottom positions, the direction of motion\n"
17451  " is toward positive X.\n"
17452  "\n"
17453  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17454  " coordinates from the specified standard position of the color bar.\n"
17455  " For positive y, the direction of motion away from the standard\n"
17456  " position is inward/outward from the standard corner positions or\n"
17457  " standard top or bottom positions if the\n"
17458  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17459  " For the standard left or right positions, the direction of motion\n"
17460  " is toward positive Y.\n"
17461  "\n"
17462  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17463  " the X direction in adopted coordinates.\n"
17464  "\n"
17465  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17466  " the Y direction in adopted coordinates.\n"
17467  "\n"
17468  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17469  " color bar (PL_COLORBAR_BACKGROUND).\n"
17470  "\n"
17471  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17472  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
17473  "\n"
17474  " bb_style (PLINT, input) : The pllsty style number for the\n"
17475  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
17476  "\n"
17477  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17478  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
17479  "\n"
17480  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17481  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
17482  "\n"
17483  " cont_color (PLINT, input) : The cmap0 contour color for\n"
17484  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17485  " it will be interpreted according to the design of plshades.\n"
17486  "\n"
17487  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17488  " plots. This is passed directly to plshades, so it will be\n"
17489  " interpreted according to the design of plshades.\n"
17490  "\n"
17491  " n_labels (PLINT, input) : Number of labels to place around the\n"
17492  " color bar.\n"
17493  "\n"
17494  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
17495  " n_labels labels.\n"
17496  "\n"
17497  " labels (PLCHAR_MATRIX, input) : A vector of\n"
17498  " n_labels UTF-8 character strings containing the labels for the color\n"
17499  " bar. Ignored if no label position is specified with one of the\n"
17500  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17501  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17502  " corresponding label_opts field.\n"
17503  "\n"
17504  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17505  " value must be greater than 0. It is typically 1 (numerical axis\n"
17506  " labels are provided for one of the long edges of the color bar),\n"
17507  " but it can be larger if multiple numerical axis labels for the\n"
17508  " long edges of the color bar are desired.\n"
17509  "\n"
17510  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
17511  " n_axes ascii character strings containing options (interpreted as for\n"
17512  " plbox) for the color bar's axis definitions.\n"
17513  "\n"
17514  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
17515  " spacing of the major tick marks (interpreted as for plbox) for the\n"
17516  " color bar's axis definitions.\n"
17517  "\n"
17518  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
17519  " number of subticks (interpreted as for plbox) for the color bar's\n"
17520  " axis definitions.\n"
17521  "\n"
17522  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
17523  " elements in each of the n_axes rows of the values matrix.\n"
17524  "\n"
17525  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
17526  " values for the data range represented by the color bar. For a row\n"
17527  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
17528  " elements in the row is specified by n_values[i_axis]. For\n"
17529  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
17530  " is 2, and the corresponding row elements of the values matrix are\n"
17531  " the minimum and maximum value represented by the colorbar. For\n"
17532  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
17533  " of the values matrix is interpreted the same as the nlevel and\n"
17534  " clevel arguments of plshades.\n"
17535  "\n"
17536  ""},
17537  { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
17538  "Sets the 3D position of the light source\n"
17539  "\n"
17540  "DESCRIPTION:\n"
17541  "\n"
17542  " Sets the 3D position of the light source for use with plsurf3d and\n"
17543  " plsurf3dl\n"
17544  "\n"
17545  " Redacted form: pllightsource(x, y, z)\n"
17546  "\n"
17547  " This function is used in example 8.\n"
17548  "\n"
17549  "\n"
17550  "\n"
17551  "SYNOPSIS:\n"
17552  "\n"
17553  "pllightsource(x, y, z)\n"
17554  "\n"
17555  "ARGUMENTS:\n"
17556  "\n"
17557  " x (PLFLT, input) : X-coordinate of the light source.\n"
17558  "\n"
17559  " y (PLFLT, input) : Y-coordinate of the light source.\n"
17560  "\n"
17561  " z (PLFLT, input) : Z-coordinate of the light source.\n"
17562  "\n"
17563  ""},
17564  { "plline", _wrap_plline, METH_VARARGS, "\n"
17565  "Draw a line\n"
17566  "\n"
17567  "DESCRIPTION:\n"
17568  "\n"
17569  " Draws line defined by n points in x and y.\n"
17570  "\n"
17571  " Redacted form: plline(x, y)\n"
17572  "\n"
17573  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
17574  " 25-27, and 29.\n"
17575  "\n"
17576  "\n"
17577  "\n"
17578  "SYNOPSIS:\n"
17579  "\n"
17580  "plline(n, x, y)\n"
17581  "\n"
17582  "ARGUMENTS:\n"
17583  "\n"
17584  " n (PLINT, input) : Number of points defining line.\n"
17585  "\n"
17586  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17587  " points.\n"
17588  "\n"
17589  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17590  " points.\n"
17591  "\n"
17592  ""},
17593  { "plline3", _wrap_plline3, METH_VARARGS, "\n"
17594  "Draw a line in 3 space\n"
17595  "\n"
17596  "DESCRIPTION:\n"
17597  "\n"
17598  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17599  " first set up the viewport, the 2d viewing window (in world\n"
17600  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17601  " more info.\n"
17602  "\n"
17603  " Redacted form: plline3(x, y, z)\n"
17604  "\n"
17605  " This function is used in example 18.\n"
17606  "\n"
17607  "\n"
17608  "\n"
17609  "SYNOPSIS:\n"
17610  "\n"
17611  "plline3(n, x, y, z)\n"
17612  "\n"
17613  "ARGUMENTS:\n"
17614  "\n"
17615  " n (PLINT, input) : Number of points defining line.\n"
17616  "\n"
17617  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17618  " points.\n"
17619  "\n"
17620  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17621  " points.\n"
17622  "\n"
17623  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
17624  " points.\n"
17625  "\n"
17626  ""},
17627  { "pllsty", _wrap_pllsty, METH_O, "\n"
17628  "Select line style\n"
17629  "\n"
17630  "DESCRIPTION:\n"
17631  "\n"
17632  " This sets the line style according to one of eight predefined patterns\n"
17633  " (also see plstyl).\n"
17634  "\n"
17635  " Redacted form: pllsty(lin)\n"
17636  "\n"
17637  " This function is used in examples 9, 12, 22, and 25.\n"
17638  "\n"
17639  "\n"
17640  "\n"
17641  "SYNOPSIS:\n"
17642  "\n"
17643  "pllsty(lin)\n"
17644  "\n"
17645  "ARGUMENTS:\n"
17646  "\n"
17647  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
17648  " a continuous line, line style 2 is a line with short dashes and\n"
17649  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17650  " 4 has long dashes and short gaps and so on.\n"
17651  "\n"
17652  ""},
17653  { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
17654  "Plot surface mesh\n"
17655  "\n"
17656  "DESCRIPTION:\n"
17657  "\n"
17658  " Plots a surface mesh within the environment set up by plw3d. The\n"
17659  " surface is defined by the matrix z[\n"
17660  " nx][\n"
17661  " ny] , the point z[i][j] being the value of the function at (\n"
17662  " x[i],\n"
17663  " y[j]). Note that the points in vectors x and y do not need to be\n"
17664  " equally spaced, but must be stored in ascending order. The parameter\n"
17665  " opt controls the way in which the surface is displayed. For further\n"
17666  " details see the PLplot documentation.\n"
17667  "\n"
17668  " Redacted form: plmesh(x, y, z, opt)\n"
17669  "\n"
17670  " This function is used in example 11.\n"
17671  "\n"
17672  "\n"
17673  "\n"
17674  "SYNOPSIS:\n"
17675  "\n"
17676  "plmesh(x, y, z, nx, ny, opt)\n"
17677  "\n"
17678  "ARGUMENTS:\n"
17679  "\n"
17680  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17681  " which the function is evaluated.\n"
17682  "\n"
17683  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17684  " which the function is evaluated.\n"
17685  "\n"
17686  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17687  " plot. Should have dimensions of\n"
17688  " nx by\n"
17689  " ny.\n"
17690  "\n"
17691  " nx (PLINT, input) : Number of x values at which function has been\n"
17692  " evaluated.\n"
17693  "\n"
17694  " ny (PLINT, input) : Number of y values at which function has been\n"
17695  " evaluated.\n"
17696  "\n"
17697  " opt (PLINT, input) : Determines the way in which the surface is\n"
17698  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17699  " function of x for each value of y[j] .\n"
17700  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17701  " for each value of x[i] .\n"
17702  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17703  " at which function is defined.\n"
17704  "\n"
17705  ""},
17706  { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
17707  "Magnitude colored plot surface mesh with contour\n"
17708  "\n"
17709  "DESCRIPTION:\n"
17710  "\n"
17711  " A more powerful form of plmesh: the surface mesh can be colored\n"
17712  " accordingly to the current z value being plotted, a contour plot can\n"
17713  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
17714  " plotted function border and the base XY plane.\n"
17715  "\n"
17716  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17717  "\n"
17718  " This function is used in example 11.\n"
17719  "\n"
17720  "\n"
17721  "\n"
17722  "SYNOPSIS:\n"
17723  "\n"
17724  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17725  "\n"
17726  "ARGUMENTS:\n"
17727  "\n"
17728  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17729  " which the function is evaluated.\n"
17730  "\n"
17731  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17732  " which the function is evaluated.\n"
17733  "\n"
17734  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17735  " plot. Should have dimensions of\n"
17736  " nx by\n"
17737  " ny.\n"
17738  "\n"
17739  " nx (PLINT, input) : Number of x values at which function is\n"
17740  " evaluated.\n"
17741  "\n"
17742  " ny (PLINT, input) : Number of y values at which function is\n"
17743  " evaluated.\n"
17744  "\n"
17745  " opt (PLINT, input) : Determines the way in which the surface is\n"
17746  " represented. To specify more than one option just add the options,\n"
17747  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
17748  " showing z as a function of x for each value of y[j] .\n"
17749  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17750  " for each value of x[i] .\n"
17751  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17752  " at which function is defined.\n"
17753  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
17754  " the z value being plotted. The color is used from the current\n"
17755  " cmap1.\n"
17756  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
17757  " using parameters\n"
17758  " nlevel and\n"
17759  " clevel.\n"
17760  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
17761  " the borders of the plotted function.\n"
17762  "\n"
17763  "\n"
17764  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
17765  " levels.\n"
17766  "\n"
17767  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
17768  "\n"
17769  ""},
17770  { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
17771  "Creates a new stream and makes it the default\n"
17772  "\n"
17773  "DESCRIPTION:\n"
17774  "\n"
17775  " Creates a new stream and makes it the default. Differs from using\n"
17776  " plsstrm, in that a free stream number is found, and returned.\n"
17777  " Unfortunately, I have to start at stream 1 and work upward, since\n"
17778  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17779  " that no initial, library-opening call is required. So stream 0 must\n"
17780  " be preallocated, and there is no simple way of determining whether it\n"
17781  " is already in use or not.\n"
17782  "\n"
17783  " Redacted form: plmkstrm(p_strm)\n"
17784  "\n"
17785  " This function is used in examples 1 and 20.\n"
17786  "\n"
17787  "\n"
17788  "\n"
17789  "SYNOPSIS:\n"
17790  "\n"
17791  "plmkstrm(p_strm)\n"
17792  "\n"
17793  "ARGUMENTS:\n"
17794  "\n"
17795  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
17796  " number of the created stream.\n"
17797  "\n"
17798  ""},
17799  { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
17800  "Write text relative to viewport boundaries\n"
17801  "\n"
17802  "DESCRIPTION:\n"
17803  "\n"
17804  " Writes text at a specified position relative to the viewport\n"
17805  " boundaries. Text may be written inside or outside the viewport, but\n"
17806  " is clipped at the subpage boundaries. The reference point of a string\n"
17807  " lies along a line passing through the string at half the height of a\n"
17808  " capital letter. The position of the reference point along this line\n"
17809  " is determined by just, and the position of the reference point\n"
17810  " relative to the viewport is set by disp and pos.\n"
17811  "\n"
17812  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17813  "\n"
17814  "\n"
17815  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
17816  " 26.\n"
17817  "\n"
17818  "\n"
17819  "\n"
17820  "SYNOPSIS:\n"
17821  "\n"
17822  "plmtex(side, disp, pos, just, text)\n"
17823  "\n"
17824  "ARGUMENTS:\n"
17825  "\n"
17826  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17827  " the side of the viewport along which the text is to be written.\n"
17828  " The string must be one of: b: Bottom of viewport, text written\n"
17829  " parallel to edge.\n"
17830  " bv: Bottom of viewport, text written at right angles to edge.\n"
17831  " l: Left of viewport, text written parallel to edge.\n"
17832  " lv: Left of viewport, text written at right angles to edge.\n"
17833  " r: Right of viewport, text written parallel to edge.\n"
17834  " rv: Right of viewport, text written at right angles to edge.\n"
17835  " t: Top of viewport, text written parallel to edge.\n"
17836  " tv: Top of viewport, text written at right angles to edge.\n"
17837  "\n"
17838  "\n"
17839  " disp (PLFLT, input) : Position of the reference point of string,\n"
17840  " measured outwards from the specified viewport edge in units of the\n"
17841  " current character height. Use negative disp to write within the\n"
17842  " viewport.\n"
17843  "\n"
17844  " pos (PLFLT, input) : Position of the reference point of string\n"
17845  " along the specified edge, expressed as a fraction of the length of\n"
17846  " the edge.\n"
17847  "\n"
17848  " just (PLFLT, input) : Specifies the position of the string relative\n"
17849  " to its reference point. If just=0. , the reference point is at\n"
17850  " the left and if just=1. , it is at the right of the string. Other\n"
17851  " values of just give intermediate justifications.\n"
17852  "\n"
17853  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17854  " written out.\n"
17855  "\n"
17856  ""},
17857  { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
17858  "Write text relative to viewport boundaries in 3D plots\n"
17859  "\n"
17860  "DESCRIPTION:\n"
17861  "\n"
17862  " Writes text at a specified position relative to the viewport\n"
17863  " boundaries. Text may be written inside or outside the viewport, but\n"
17864  " is clipped at the subpage boundaries. The reference point of a string\n"
17865  " lies along a line passing through the string at half the height of a\n"
17866  " capital letter. The position of the reference point along this line\n"
17867  " is determined by just, and the position of the reference point\n"
17868  " relative to the viewport is set by disp and pos.\n"
17869  "\n"
17870  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17871  "\n"
17872  " This function is used in example 28.\n"
17873  "\n"
17874  "\n"
17875  "\n"
17876  "SYNOPSIS:\n"
17877  "\n"
17878  "plmtex3(side, disp, pos, just, text)\n"
17879  "\n"
17880  "ARGUMENTS:\n"
17881  "\n"
17882  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17883  " the side of the viewport along which the text is to be written.\n"
17884  " The string should contain one or more of the following characters:\n"
17885  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
17886  " only label the X axis, not both the X and Y axes. x: Label the X\n"
17887  " axis.\n"
17888  " y: Label the Y axis.\n"
17889  " z: Label the Z axis.\n"
17890  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17891  " For X it is the axis that starts at y-min. For Y it is the\n"
17892  " axis that starts at x-min.\n"
17893  " s: Label the secondary axis.\n"
17894  " v: Draw the text perpendicular to the axis.\n"
17895  "\n"
17896  "\n"
17897  " disp (PLFLT, input) : Position of the reference point of string,\n"
17898  " measured outwards from the specified viewport edge in units of the\n"
17899  " current character height. Use negative disp to write within the\n"
17900  " viewport.\n"
17901  "\n"
17902  " pos (PLFLT, input) : Position of the reference point of string\n"
17903  " along the specified edge, expressed as a fraction of the length of\n"
17904  " the edge.\n"
17905  "\n"
17906  " just (PLFLT, input) : Specifies the position of the string relative\n"
17907  " to its reference point. If just=0. , the reference point is at\n"
17908  " the left and if just=1. , it is at the right of the string. Other\n"
17909  " values of just give intermediate justifications.\n"
17910  "\n"
17911  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17912  " written out.\n"
17913  "\n"
17914  ""},
17915  { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
17916  "Plot 3-d surface plot\n"
17917  "\n"
17918  "DESCRIPTION:\n"
17919  "\n"
17920  " Plots a three-dimensional surface plot within the environment set up\n"
17921  " by plw3d. The surface is defined by the matrix z[\n"
17922  " nx][\n"
17923  " ny] , the point z[i][j] being the value of the function at (\n"
17924  " x[i],\n"
17925  " y[j]). Note that the points in vectors x and y do not need to be\n"
17926  " equally spaced, but must be stored in ascending order. The parameter\n"
17927  " opt controls the way in which the surface is displayed. For further\n"
17928  " details see the PLplot documentation. The only difference between\n"
17929  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17930  " while plot3d only draws the surface as viewed from the top.\n"
17931  "\n"
17932  " Redacted form: plot3d(x, y, z, opt, side)\n"
17933  "\n"
17934  " This function is used in examples 11 and 21.\n"
17935  "\n"
17936  "\n"
17937  "\n"
17938  "SYNOPSIS:\n"
17939  "\n"
17940  "plot3d(x, y, z, nx, ny, opt, side)\n"
17941  "\n"
17942  "ARGUMENTS:\n"
17943  "\n"
17944  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17945  " which the function is evaluated.\n"
17946  "\n"
17947  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17948  " which the function is evaluated.\n"
17949  "\n"
17950  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17951  " plot. Should have dimensions of\n"
17952  " nx by\n"
17953  " ny.\n"
17954  "\n"
17955  " nx (PLINT, input) : Number of x values at which function is\n"
17956  " evaluated.\n"
17957  "\n"
17958  " ny (PLINT, input) : Number of y values at which function is\n"
17959  " evaluated.\n"
17960  "\n"
17961  " opt (PLINT, input) : Determines the way in which the surface is\n"
17962  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17963  " function of x for each value of y[j] .\n"
17964  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17965  " for each value of x[i] .\n"
17966  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17967  " at which function is defined.\n"
17968  "\n"
17969  "\n"
17970  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17971  " should be draw on the figure. If side is true sides are drawn,\n"
17972  " otherwise no sides are drawn.\n"
17973  "\n"
17974  ""},
17975  { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
17976  "Magnitude colored plot surface with contour\n"
17977  "\n"
17978  "DESCRIPTION:\n"
17979  "\n"
17980  " Aside from dropping the\n"
17981  " side functionality this is a more powerful form of plot3d: the surface\n"
17982  " mesh can be colored accordingly to the current z value being plotted,\n"
17983  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
17984  " drawn between the plotted function border and the base XY plane. The\n"
17985  " arguments are identical to those of plmeshc. The only difference\n"
17986  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
17987  " the surface, while plot3dc only draws the surface as viewed from the\n"
17988  " top.\n"
17989  "\n"
17990  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17991  "\n"
17992  "\n"
17993  " This function is used in example 21.\n"
17994  "\n"
17995  "\n"
17996  "\n"
17997  "SYNOPSIS:\n"
17998  "\n"
17999  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18000  "\n"
18001  "ARGUMENTS:\n"
18002  "\n"
18003  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18004  " which the function is evaluated.\n"
18005  "\n"
18006  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18007  " which the function is evaluated.\n"
18008  "\n"
18009  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18010  " plot. Should have dimensions of\n"
18011  " nx by\n"
18012  " ny.\n"
18013  "\n"
18014  " nx (PLINT, input) : Number of x values at which function is\n"
18015  " evaluated.\n"
18016  "\n"
18017  " ny (PLINT, input) : Number of y values at which function is\n"
18018  " evaluated.\n"
18019  "\n"
18020  " opt (PLINT, input) : Determines the way in which the surface is\n"
18021  " represented. To specify more than one option just add the options,\n"
18022  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18023  " showing z as a function of x for each value of y[j] .\n"
18024  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18025  " for each value of x[i] .\n"
18026  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18027  " at which function is defined.\n"
18028  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18029  " the z value being plotted. The color is used from the current\n"
18030  " cmap1.\n"
18031  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18032  " using parameters\n"
18033  " nlevel and\n"
18034  " clevel.\n"
18035  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18036  " the borders of the plotted function.\n"
18037  "\n"
18038  "\n"
18039  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18040  " levels.\n"
18041  "\n"
18042  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18043  "\n"
18044  ""},
18045  { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18046  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18047  "\n"
18048  "DESCRIPTION:\n"
18049  "\n"
18050  " When the implementation is completed this variant of plot3dc (see that\n"
18051  " function's documentation for more details) should be suitable for the\n"
18052  " case where the area of the x, y coordinate grid where z is defined can\n"
18053  " be non-rectangular. The implementation is incomplete so the last 4\n"
18054  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18055  " indexymax; are currently ignored and the functionality is otherwise\n"
18056  " identical to that of plot3dc.\n"
18057  "\n"
18058  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18059  " indexymin, indexymax)\n"
18060  "\n"
18061  "\n"
18062  " This function is not used in any example.\n"
18063  "\n"
18064  "\n"
18065  "\n"
18066  "SYNOPSIS:\n"
18067  "\n"
18068  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18069  "\n"
18070  "ARGUMENTS:\n"
18071  "\n"
18072  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18073  " which the function is evaluated.\n"
18074  "\n"
18075  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18076  " which the function is evaluated.\n"
18077  "\n"
18078  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18079  " plot. Should have dimensions of\n"
18080  " nx by\n"
18081  " ny.\n"
18082  "\n"
18083  " nx (PLINT, input) : Number of x values at which the function is\n"
18084  " evaluated.\n"
18085  "\n"
18086  " ny (PLINT, input) : Number of y values at which the function is\n"
18087  " evaluated.\n"
18088  "\n"
18089  " opt (PLINT, input) : Determines the way in which the surface is\n"
18090  " represented. To specify more than one option just add the options,\n"
18091  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18092  " showing z as a function of x for each value of y[j] .\n"
18093  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18094  " for each value of x[i] .\n"
18095  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18096  " at which function is defined.\n"
18097  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18098  " the z value being plotted. The color is used from the current\n"
18099  " cmap1.\n"
18100  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18101  " using parameters\n"
18102  " nlevel and\n"
18103  " clevel.\n"
18104  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18105  " the borders of the plotted function.\n"
18106  "\n"
18107  "\n"
18108  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18109  " levels.\n"
18110  "\n"
18111  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18112  "\n"
18113  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18114  " corresponds to the first x index where z is defined.\n"
18115  "\n"
18116  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18117  " which corresponds (by convention) to one more than the last x\n"
18118  " index value where z is defined.\n"
18119  "\n"
18120  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18121  " values which all must be ≥ 0. These values are the first y index\n"
18122  " where z is defined for a particular x index in the range from\n"
18123  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18124  " indexxmax.\n"
18125  "\n"
18126  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18127  " values which all must be ≤ ny. These values correspond (by\n"
18128  " convention) to one more than the last y index where z is defined\n"
18129  " for a particular x index in the range from indexxmin to indexxmax\n"
18130  " - 1. The dimension of indexymax is indexxmax.\n"
18131  "\n"
18132  ""},
18133  { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18134  "Plot shaded 3-d surface plot\n"
18135  "\n"
18136  "DESCRIPTION:\n"
18137  "\n"
18138  " Plots a three-dimensional shaded surface plot within the environment\n"
18139  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18140  " z[\n"
18141  " nx][\n"
18142  " ny], the point z[i][j] being the value of the function at (\n"
18143  " x[i],\n"
18144  " y[j]). Note that the points in vectors x and y do not need to be\n"
18145  " equally spaced, but must be stored in ascending order. For further\n"
18146  " details see the PLplot documentation.\n"
18147  "\n"
18148  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18149  "\n"
18150  " This function is not used in any examples.\n"
18151  "\n"
18152  "\n"
18153  "\n"
18154  "SYNOPSIS:\n"
18155  "\n"
18156  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18157  "\n"
18158  "ARGUMENTS:\n"
18159  "\n"
18160  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18161  " which the function is evaluated.\n"
18162  "\n"
18163  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18164  " which the function is evaluated.\n"
18165  "\n"
18166  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18167  " plot. Should have dimensions of\n"
18168  " nx by\n"
18169  " ny.\n"
18170  "\n"
18171  " nx (PLINT, input) : Number of x values at which function is\n"
18172  " evaluated.\n"
18173  "\n"
18174  " ny (PLINT, input) : Number of y values at which function is\n"
18175  " evaluated.\n"
18176  "\n"
18177  " opt (PLINT, input) : Determines the way in which the surface is\n"
18178  " represented. To specify more than one option just add the options,\n"
18179  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18180  " connecting points at which function is defined.\n"
18181  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18182  " using parameters\n"
18183  " nlevel and\n"
18184  " clevel.\n"
18185  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18186  " using parameters\n"
18187  " nlevel and\n"
18188  " clevel.\n"
18189  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18190  " the borders of the plotted function.\n"
18191  " opt=MAG_COLOR : the surface is colored according to the value\n"
18192  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18193  " according to the intensity of the reflected light in the\n"
18194  " surface from a light source whose position is set using\n"
18195  " pllightsource.\n"
18196  "\n"
18197  "\n"
18198  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18199  " levels.\n"
18200  "\n"
18201  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18202  "\n"
18203  ""},
18204  { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18205  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18206  "\n"
18207  "DESCRIPTION:\n"
18208  "\n"
18209  " This variant of plsurf3d (see that function's documentation for more\n"
18210  " details) should be suitable for the case where the area of the x, y\n"
18211  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18212  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18213  " indexymin, and indexymax.\n"
18214  "\n"
18215  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18216  " indexymax)\n"
18217  "\n"
18218  " This function is used in example 8.\n"
18219  "\n"
18220  "\n"
18221  "\n"
18222  "SYNOPSIS:\n"
18223  "\n"
18224  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18225  "\n"
18226  "ARGUMENTS:\n"
18227  "\n"
18228  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18229  " which the function is evaluated.\n"
18230  "\n"
18231  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18232  " which the function is evaluated.\n"
18233  "\n"
18234  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18235  " plot. Should have dimensions of\n"
18236  " nx by\n"
18237  " ny.\n"
18238  "\n"
18239  " nx (PLINT, input) : Number of x values at which function is\n"
18240  " evaluated.\n"
18241  "\n"
18242  " ny (PLINT, input) : Number of y values at which function is\n"
18243  " evaluated.\n"
18244  "\n"
18245  " opt (PLINT, input) : Determines the way in which the surface is\n"
18246  " represented. To specify more than one option just add the options,\n"
18247  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18248  " connecting points at which function is defined.\n"
18249  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18250  " using parameters\n"
18251  " nlevel and\n"
18252  " clevel.\n"
18253  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18254  " using parameters\n"
18255  " nlevel and\n"
18256  " clevel.\n"
18257  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18258  " the borders of the plotted function.\n"
18259  " opt=MAG_COLOR : the surface is colored according to the value\n"
18260  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18261  " according to the intensity of the reflected light in the\n"
18262  " surface from a light source whose position is set using\n"
18263  " pllightsource.\n"
18264  "\n"
18265  "\n"
18266  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18267  " levels.\n"
18268  "\n"
18269  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18270  "\n"
18271  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18272  " corresponds to the first x index where z is defined.\n"
18273  "\n"
18274  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18275  " which corresponds (by convention) to one more than the last x\n"
18276  " index value where z is defined.\n"
18277  "\n"
18278  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18279  " values which all must be ≥ 0. These values are the first y index\n"
18280  " where z is defined for a particular x index in the range from\n"
18281  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18282  " indexxmax.\n"
18283  "\n"
18284  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18285  " values which all must be ≤ ny. These values correspond (by\n"
18286  " convention) to one more than the last y index where z is defined\n"
18287  " for a particular x index in the range from indexxmin to indexxmax\n"
18288  " - 1. The dimension of indexymax is indexxmax.\n"
18289  "\n"
18290  ""},
18291  { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
18292  "Parse command-line arguments\n"
18293  "\n"
18294  "DESCRIPTION:\n"
18295  "\n"
18296  " Parse command-line arguments.\n"
18297  "\n"
18298  " plparseopts removes all recognized flags (decreasing argc\n"
18299  " accordingly), so that invalid input may be readily detected. It can\n"
18300  " also be used to process user command line flags. The user can merge\n"
18301  " an option table of type PLOptionTable into the internal option table\n"
18302  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18303  " the external table(s) be parsed by calling plClearOpts before\n"
18304  " plMergeOpts.\n"
18305  "\n"
18306  " The default action taken by plparseopts is as follows:\n"
18307  " Returns with an error if an unrecognized option or badly formed\n"
18308  " option-value pair are encountered.\n"
18309  " Returns immediately (return code 0) when the first non-option command\n"
18310  " line argument is found.\n"
18311  " Returns with the return code of the option handler, if one was called.\n"
18312  "\n"
18313  " Deletes command line arguments from argv list as they are found, and\n"
18314  " decrements argc accordingly.\n"
18315  " Does not show \"invisible\" options in usage or help messages.\n"
18316  " Assumes the program name is contained in argv[0].\n"
18317  "\n"
18318  " These behaviors may be controlled through the\n"
18319  " mode argument.\n"
18320  "\n"
18321  " Redacted form: General: plparseopts(argv, mode)\n"
18322  "\n"
18323  "\n"
18324  " This function is used in all of the examples.\n"
18325  "\n"
18326  "\n"
18327  "\n"
18328  "SYNOPSIS:\n"
18329  "\n"
18330  "PLINT plparseopts(p_argc, argv, mode)\n"
18331  "\n"
18332  "ARGUMENTS:\n"
18333  "\n"
18334  " p_argc (int *, input/output) : Number of arguments.\n"
18335  "\n"
18336  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18337  " strings containing *p_argc command-line arguments.\n"
18338  "\n"
18339  " mode (PLINT, input) : Parsing mode with the following\n"
18340  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18341  " and all error messages enabled, including program exit when an\n"
18342  " error occurs. Anything on the command line that isn't recognized\n"
18343  " as a valid option or option argument is flagged as an error.\n"
18344  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18345  " of errors.\n"
18346  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18347  " arguments.\n"
18348  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18349  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18350  " pointer to the program name.\n"
18351  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18352  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18353  " unrecognized arguments.\n"
18354  "\n"
18355  ""},
18356  { "plpat", _wrap_plpat, METH_VARARGS, "\n"
18357  "Set area line fill pattern\n"
18358  "\n"
18359  "DESCRIPTION:\n"
18360  "\n"
18361  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18362  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18363  " inclinations and spacings. The arguments to this routine are the\n"
18364  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18365  " elements) specifying the inclinations in tenths of a degree and the\n"
18366  " spacing in micrometers. (See also plpsty)\n"
18367  "\n"
18368  " Redacted form: General: plpat(inc, del)\n"
18369  "\n"
18370  "\n"
18371  " This function is used in example 15.\n"
18372  "\n"
18373  "\n"
18374  "\n"
18375  "SYNOPSIS:\n"
18376  "\n"
18377  "plpat(nlin, inc, del)\n"
18378  "\n"
18379  "ARGUMENTS:\n"
18380  "\n"
18381  " nlin (PLINT, input) : Number of sets of lines making up the\n"
18382  " pattern, either 1 or 2.\n"
18383  "\n"
18384  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18385  " inclination in tenths of a degree. (Should be between -900 and\n"
18386  " 900).\n"
18387  "\n"
18388  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18389  " spacing in micrometers between the lines making up the pattern.\n"
18390  "\n"
18391  ""},
18392  { "plpath", _wrap_plpath, METH_VARARGS, "\n"
18393  "Draw a line between two points, accounting for coordinate transforms\n"
18394  "\n"
18395  "DESCRIPTION:\n"
18396  "\n"
18397  " Joins the point (\n"
18398  " x1,\n"
18399  " y1) to (\n"
18400  " x2,\n"
18401  " y2) . If a global coordinate transform is defined then the line is\n"
18402  " broken in to n segments to approximate the path. If no transform is\n"
18403  " defined then this simply acts like a call to pljoin.\n"
18404  "\n"
18405  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18406  "\n"
18407  " This function is used in example 22.\n"
18408  "\n"
18409  "\n"
18410  "\n"
18411  "SYNOPSIS:\n"
18412  "\n"
18413  "plpath(n, x1, y1, x2, y2)\n"
18414  "\n"
18415  "ARGUMENTS:\n"
18416  "\n"
18417  " n (PLINT, input) : number of points to use to approximate the path.\n"
18418  "\n"
18419  " x1 (PLFLT, input) : x coordinate of first point.\n"
18420  "\n"
18421  " y1 (PLFLT, input) : y coordinate of first point.\n"
18422  "\n"
18423  " x2 (PLFLT, input) : x coordinate of second point.\n"
18424  "\n"
18425  " y2 (PLFLT, input) : y coordinate of second point.\n"
18426  "\n"
18427  ""},
18428  { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
18429  "Plot a glyph at the specified points\n"
18430  "\n"
18431  "DESCRIPTION:\n"
18432  "\n"
18433  " Plot a glyph at the specified points. (This function is largely\n"
18434  " superseded by plstring which gives access to many[!] more glyphs.)\n"
18435  " code=-1 means try to just draw a point. Right now it's just a move\n"
18436  " and a draw at the same place. Not ideal, since a sufficiently\n"
18437  " intelligent output device may optimize it away, or there may be faster\n"
18438  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18439  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18440  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18441  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18442  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18443  "\n"
18444  " Redacted form: plpoin(x, y, code)\n"
18445  "\n"
18446  " This function is used in examples 1, 6, 14, and 29.\n"
18447  "\n"
18448  "\n"
18449  "\n"
18450  "SYNOPSIS:\n"
18451  "\n"
18452  "plpoin(n, x, y, code)\n"
18453  "\n"
18454  "ARGUMENTS:\n"
18455  "\n"
18456  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18457  "\n"
18458  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18459  " points.\n"
18460  "\n"
18461  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18462  " points.\n"
18463  "\n"
18464  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18465  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18466  " each of the n points.\n"
18467  "\n"
18468  ""},
18469  { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
18470  "Plot a glyph at the specified 3D points\n"
18471  "\n"
18472  "DESCRIPTION:\n"
18473  "\n"
18474  " Plot a glyph at the specified 3D points. (This function is largely\n"
18475  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18476  " Set up the call to this function similar to what is done for plline3.\n"
18477  " code=-1 means try to just draw a point. Right now it's just a move\n"
18478  " and a draw at the same place. Not ideal, since a sufficiently\n"
18479  " intelligent output device may optimize it away, or there may be faster\n"
18480  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18481  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18482  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18483  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18484  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18485  "\n"
18486  " Redacted form: plpoin3(x, y, z, code)\n"
18487  "\n"
18488  " This function is not used in any example.\n"
18489  "\n"
18490  "\n"
18491  "\n"
18492  "SYNOPSIS:\n"
18493  "\n"
18494  "plpoin3(n, x, y, z, code)\n"
18495  "\n"
18496  "ARGUMENTS:\n"
18497  "\n"
18498  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18499  "\n"
18500  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18501  " points.\n"
18502  "\n"
18503  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18504  " points.\n"
18505  "\n"
18506  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18507  " points.\n"
18508  "\n"
18509  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18510  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18511  " each of the n points.\n"
18512  "\n"
18513  ""},
18514  { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
18515  "Draw a polygon in 3 space\n"
18516  "\n"
18517  "DESCRIPTION:\n"
18518  "\n"
18519  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18520  " like plline3, but differs from that function in that plpoly3 attempts\n"
18521  " to determine if the polygon is viewable depending on the order of the\n"
18522  " points within the vector and the value of ifcc. If the back of\n"
18523  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18524  " you want, then use plline3 instead.\n"
18525  "\n"
18526  " The points are assumed to be in a plane, and the directionality of the\n"
18527  " plane is determined from the first three points. Additional points do\n"
18528  " not have to lie on the plane defined by the first three, but if they\n"
18529  " do not, then the determination of visibility obviously can't be 100%\n"
18530  " accurate... So if you're 3 space polygons are too far from planar,\n"
18531  " consider breaking them into smaller polygons. 3 points define a plane\n"
18532  " :-).\n"
18533  "\n"
18534  " Bugs: If one of the first two segments is of zero length, or if they\n"
18535  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18536  " being correct. Avoid such situations :-). See x18c.c for an example\n"
18537  " of this problem. (Search for 20.1).\n"
18538  "\n"
18539  " Redacted form: plpoly3(x, y, z, code)\n"
18540  "\n"
18541  " This function is used in example 18.\n"
18542  "\n"
18543  "\n"
18544  "\n"
18545  "SYNOPSIS:\n"
18546  "\n"
18547  "plpoly3(n, x, y, z, draw, ifcc)\n"
18548  "\n"
18549  "ARGUMENTS:\n"
18550  "\n"
18551  " n (PLINT, input) : Number of points defining line.\n"
18552  "\n"
18553  " x (PLFLT_VECTOR, input) : A vector containing\n"
18554  " n x coordinates of points.\n"
18555  "\n"
18556  " y (PLFLT_VECTOR, input) : A vector containing\n"
18557  " n y coordinates of points.\n"
18558  "\n"
18559  " z (PLFLT_VECTOR, input) : A vector containing\n"
18560  " n z coordinates of points.\n"
18561  "\n"
18562  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
18563  " n-1 Boolean values which control drawing the segments of the polygon.\n"
18564  " If draw[i] is true, then the polygon segment from index [i] to\n"
18565  " [i+1] is drawn, otherwise, not.\n"
18566  "\n"
18567  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18568  " polygon is determined by assuming the points are laid out in a\n"
18569  " counter-clockwise order. Otherwise, the directionality of the\n"
18570  " polygon is determined by assuming the points are laid out in a\n"
18571  " clockwise order.\n"
18572  "\n"
18573  ""},
18574  { "plprec", _wrap_plprec, METH_VARARGS, "\n"
18575  "Set precision in numeric labels\n"
18576  "\n"
18577  "DESCRIPTION:\n"
18578  "\n"
18579  " Sets the number of places after the decimal point in numeric labels.\n"
18580  "\n"
18581  " Redacted form: plprec(setp, prec)\n"
18582  "\n"
18583  " This function is used in example 29.\n"
18584  "\n"
18585  "\n"
18586  "\n"
18587  "SYNOPSIS:\n"
18588  "\n"
18589  "plprec(setp, prec)\n"
18590  "\n"
18591  "ARGUMENTS:\n"
18592  "\n"
18593  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
18594  " automatically determines the number of places to use after the\n"
18595  " decimal point in numeric labels (like those used to label axes).\n"
18596  " If setp is 1 then prec sets the number of places.\n"
18597  "\n"
18598  " prec (PLINT, input) : The number of characters to draw after the\n"
18599  " decimal point in numeric labels.\n"
18600  "\n"
18601  ""},
18602  { "plpsty", _wrap_plpsty, METH_O, "\n"
18603  "Select area fill pattern\n"
18604  "\n"
18605  "DESCRIPTION:\n"
18606  "\n"
18607  " If\n"
18608  " patt is zero or less use either a hardware solid fill if the drivers\n"
18609  " have that capability (virtually all do) or fall back to a software\n"
18610  " emulation of a solid fill using the eighth area line fill pattern. If\n"
18611  " 0 <\n"
18612  " patt <= 8, then select one of eight predefined area line fill patterns\n"
18613  " to use (see plpat if you desire other patterns).\n"
18614  "\n"
18615  " Redacted form: plpsty(patt)\n"
18616  "\n"
18617  " This function is used in examples 12, 13, 15, 16, and 25.\n"
18618  "\n"
18619  "\n"
18620  "\n"
18621  "SYNOPSIS:\n"
18622  "\n"
18623  "plpsty(patt)\n"
18624  "\n"
18625  "ARGUMENTS:\n"
18626  "\n"
18627  " patt (PLINT, input) : The desired pattern index. If\n"
18628  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
18629  " above) used. For\n"
18630  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
18631  " line fill capability itself (most deliberately do not so that line\n"
18632  " fill patterns look identical for those drivers), the patterns\n"
18633  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
18634  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
18635  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
18636  " (8) lines at both 45 degrees and -45 degrees.\n"
18637  "\n"
18638  ""},
18639  { "plptex", _wrap_plptex, METH_VARARGS, "\n"
18640  "Write text inside the viewport\n"
18641  "\n"
18642  "DESCRIPTION:\n"
18643  "\n"
18644  " Writes text at a specified position and inclination within the\n"
18645  " viewport. Text is clipped at the viewport boundaries. The reference\n"
18646  " point of a string lies along a line passing through the string at half\n"
18647  " the height of a capital letter. The position of the reference point\n"
18648  " along this line is determined by just, the reference point is placed\n"
18649  " at world coordinates (\n"
18650  " x,\n"
18651  " y) within the viewport. The inclination of the string is specified\n"
18652  " in terms of differences of world coordinates making it easy to write\n"
18653  " text parallel to a line in a graph.\n"
18654  "\n"
18655  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18656  "\n"
18657  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
18658  "\n"
18659  "\n"
18660  "\n"
18661  "SYNOPSIS:\n"
18662  "\n"
18663  "plptex(x, y, dx, dy, just, text)\n"
18664  "\n"
18665  "ARGUMENTS:\n"
18666  "\n"
18667  " x (PLFLT, input) : x coordinate of reference point of string.\n"
18668  "\n"
18669  " y (PLFLT, input) : y coordinate of reference point of string.\n"
18670  "\n"
18671  " dx (PLFLT, input) : Together with dy, this specifies the\n"
18672  " inclination of the string. The baseline of the string is parallel\n"
18673  " to a line joining (\n"
18674  " x,\n"
18675  " y) to (\n"
18676  " x+\n"
18677  " dx,\n"
18678  " y+\n"
18679  " dy) .\n"
18680  "\n"
18681  " dy (PLFLT, input) : Together with dx, this specifies the\n"
18682  " inclination of the string.\n"
18683  "\n"
18684  " just (PLFLT, input) : Specifies the position of the string relative\n"
18685  " to its reference point. If just=0. , the reference point is at\n"
18686  " the left and if just=1. , it is at the right of the string. Other\n"
18687  " values of just give intermediate justifications.\n"
18688  "\n"
18689  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18690  " written out.\n"
18691  "\n"
18692  ""},
18693  { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
18694  "Write text inside the viewport of a 3D plot\n"
18695  "\n"
18696  "DESCRIPTION:\n"
18697  "\n"
18698  " Writes text at a specified position and inclination and with a\n"
18699  " specified shear within the viewport. Text is clipped at the viewport\n"
18700  " boundaries. The reference point of a string lies along a line passing\n"
18701  " through the string at half the height of a capital letter. The\n"
18702  " position of the reference point along this line is determined by just,\n"
18703  " and the reference point is placed at world coordinates (\n"
18704  " wx,\n"
18705  " wy,\n"
18706  " wz) within the viewport. The inclination and shear of the string is\n"
18707  " specified in terms of differences of world coordinates making it easy\n"
18708  " to write text parallel to a line in a graph.\n"
18709  "\n"
18710  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18711  "\n"
18712  " This function is used in example 28.\n"
18713  "\n"
18714  "\n"
18715  "\n"
18716  "SYNOPSIS:\n"
18717  "\n"
18718  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
18719  "\n"
18720  "ARGUMENTS:\n"
18721  "\n"
18722  " wx (PLFLT, input) : x world coordinate of reference point of\n"
18723  " string.\n"
18724  "\n"
18725  " wy (PLFLT, input) : y world coordinate of reference point of\n"
18726  " string.\n"
18727  "\n"
18728  " wz (PLFLT, input) : z world coordinate of reference point of\n"
18729  " string.\n"
18730  "\n"
18731  " dx (PLFLT, input) : Together with dy and\n"
18732  " dz , this specifies the inclination of the string. The baseline of\n"
18733  " the string is parallel to a line joining (\n"
18734  " x,\n"
18735  " y,\n"
18736  " z) to (\n"
18737  " x+\n"
18738  " dx,\n"
18739  " y+\n"
18740  " dy,\n"
18741  " z+\n"
18742  " dz) .\n"
18743  "\n"
18744  " dy (PLFLT, input) : Together with dx and\n"
18745  " dz, this specifies the inclination of the string.\n"
18746  "\n"
18747  " dz (PLFLT, input) : Together with dx and\n"
18748  " dy, this specifies the inclination of the string.\n"
18749  "\n"
18750  " sx (PLFLT, input) : Together with sy and\n"
18751  " sz , this specifies the shear of the string. The string is sheared so\n"
18752  " that the characters are vertically parallel to a line joining (\n"
18753  " x,\n"
18754  " y,\n"
18755  " z) to (\n"
18756  " x+\n"
18757  " sx,\n"
18758  " y+\n"
18759  " sy,\n"
18760  " z+\n"
18761  " sz) . If sx =\n"
18762  " sy =\n"
18763  " sz = 0.) then the text is not sheared.\n"
18764  "\n"
18765  " sy (PLFLT, input) : Together with sx and\n"
18766  " sz, this specifies shear of the string.\n"
18767  "\n"
18768  " sz (PLFLT, input) : Together with sx and\n"
18769  " sy, this specifies shear of the string.\n"
18770  "\n"
18771  " just (PLFLT, input) : Specifies the position of the string relative\n"
18772  " to its reference point. If just=0. , the reference point is at\n"
18773  " the left and if just=1. , it is at the right of the string. Other\n"
18774  " values of just give intermediate justifications.\n"
18775  "\n"
18776  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18777  " written out.\n"
18778  "\n"
18779  ""},
18780  { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
18781  "Random number generator returning a real random number in the range [0,1]\n"
18782  "\n"
18783  "DESCRIPTION:\n"
18784  "\n"
18785  " Random number generator returning a real random number in the range\n"
18786  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18787  " / compilers provide their own random number generator, and so this is\n"
18788  " provided purely for convenience and to give a consistent random number\n"
18789  " generator across all languages supported by PLplot. This is\n"
18790  " particularly useful for comparing results from the test suite of\n"
18791  " examples.\n"
18792  "\n"
18793  " Redacted form: plrandd()\n"
18794  "\n"
18795  " This function is used in examples 17 and 21.\n"
18796  "\n"
18797  "\n"
18798  "\n"
18799  "SYNOPSIS:\n"
18800  "\n"
18801  "plrandd()\n"
18802  "\n"
18803  ""},
18804  { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
18805  "Replays contents of plot buffer to current device/file\n"
18806  "\n"
18807  "DESCRIPTION:\n"
18808  "\n"
18809  " Replays contents of plot buffer to current device/file.\n"
18810  "\n"
18811  " Redacted form: plreplot()\n"
18812  "\n"
18813  " This function is used in example 1,20.\n"
18814  "\n"
18815  "\n"
18816  "\n"
18817  "SYNOPSIS:\n"
18818  "\n"
18819  "plreplot()\n"
18820  "\n"
18821  ""},
18822  { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
18823  "Convert RGB color to HLS\n"
18824  "\n"
18825  "DESCRIPTION:\n"
18826  "\n"
18827  " Convert RGB color coordinates to HLS\n"
18828  "\n"
18829  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18830  "\n"
18831  "\n"
18832  " This function is used in example 2.\n"
18833  "\n"
18834  "\n"
18835  "\n"
18836  "SYNOPSIS:\n"
18837  "\n"
18838  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18839  "\n"
18840  "ARGUMENTS:\n"
18841  "\n"
18842  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
18843  "\n"
18844  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
18845  "\n"
18846  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
18847  "\n"
18848  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
18849  " degrees (0.0-360.0) on the color cylinder.\n"
18850  "\n"
18851  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
18852  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
18853  " cylinder.\n"
18854  "\n"
18855  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
18856  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
18857  " cylinder.\n"
18858  "\n"
18859  ""},
18860  { "plschr", _wrap_plschr, METH_VARARGS, "\n"
18861  "Set character size\n"
18862  "\n"
18863  "DESCRIPTION:\n"
18864  "\n"
18865  " This sets up the size of all subsequent characters drawn. The actual\n"
18866  " height of a character is the product of the default character size and\n"
18867  " a scaling factor.\n"
18868  "\n"
18869  " Redacted form: plschr(def, scale)\n"
18870  "\n"
18871  " This function is used in examples 2, 13, 23, and 24.\n"
18872  "\n"
18873  "\n"
18874  "\n"
18875  "SYNOPSIS:\n"
18876  "\n"
18877  "plschr(def, scale)\n"
18878  "\n"
18879  "ARGUMENTS:\n"
18880  "\n"
18881  " def (PLFLT, input) : The default height of a character in\n"
18882  " millimeters, should be set to zero if the default height is to\n"
18883  " remain unchanged. For rasterized drivers the dx and dy values\n"
18884  " specified in plspage are used to convert from mm to pixels (note\n"
18885  " the different unit systems used). This dpi aware scaling is not\n"
18886  " implemented for all drivers yet.\n"
18887  "\n"
18888  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18889  " actual character height.\n"
18890  "\n"
18891  ""},
18892  { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
18893  "Set cmap0 colors by 8-bit RGB values\n"
18894  "\n"
18895  "DESCRIPTION:\n"
18896  "\n"
18897  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
18898  " documentation). This sets the entire color map -- only as many colors\n"
18899  " as specified will be allocated.\n"
18900  "\n"
18901  " Redacted form: plscmap0(r, g, b)\n"
18902  "\n"
18903  " This function is used in examples 2 and 24.\n"
18904  "\n"
18905  "\n"
18906  "\n"
18907  "SYNOPSIS:\n"
18908  "\n"
18909  "plscmap0(r, g, b, ncol0)\n"
18910  "\n"
18911  "ARGUMENTS:\n"
18912  "\n"
18913  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18914  " integers (0-255) representing the degree of red in the color.\n"
18915  "\n"
18916  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18917  " integers (0-255) representing the degree of green in the color.\n"
18918  "\n"
18919  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18920  " integers (0-255) representing the degree of blue in the color.\n"
18921  "\n"
18922  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
18923  "\n"
18924  ""},
18925  { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
18926  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
18927  "\n"
18928  "DESCRIPTION:\n"
18929  "\n"
18930  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
18931  " and PLFLT alpha transparency value. This sets the entire color map --\n"
18932  " only as many colors as specified will be allocated.\n"
18933  "\n"
18934  " Redacted form: plscmap0a(r, g, b, alpha)\n"
18935  "\n"
18936  " This function is used in examples 30.\n"
18937  "\n"
18938  "\n"
18939  "\n"
18940  "SYNOPSIS:\n"
18941  "\n"
18942  "plscmap0a(r, g, b, alpha, ncol0)\n"
18943  "\n"
18944  "ARGUMENTS:\n"
18945  "\n"
18946  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18947  " integers (0-255) representing the degree of red in the color.\n"
18948  "\n"
18949  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18950  " integers (0-255) representing the degree of green in the color.\n"
18951  "\n"
18952  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18953  " integers (0-255) representing the degree of blue in the color.\n"
18954  "\n"
18955  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
18956  " representing the alpha transparency of the color.\n"
18957  "\n"
18958  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
18959  " vectors.\n"
18960  "\n"
18961  ""},
18962  { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
18963  "Set number of colors in cmap0\n"
18964  "\n"
18965  "DESCRIPTION:\n"
18966  "\n"
18967  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
18968  " (or reallocate) cmap0, and fill with default values for those colors\n"
18969  " not previously allocated. The first 16 default colors are given in\n"
18970  " the plcol0 documentation. For larger indices the default color is\n"
18971  " red.\n"
18972  "\n"
18973  " The drivers are not guaranteed to support more than 16 colors.\n"
18974  "\n"
18975  " Redacted form: plscmap0n(ncol0)\n"
18976  "\n"
18977  " This function is used in examples 15, 16, and 24.\n"
18978  "\n"
18979  "\n"
18980  "\n"
18981  "SYNOPSIS:\n"
18982  "\n"
18983  "plscmap0n(ncol0)\n"
18984  "\n"
18985  "ARGUMENTS:\n"
18986  "\n"
18987  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18988  " the cmap0 palette. If this number is zero or less, then the value\n"
18989  " from the previous call to plscmap0n is used and if there is no\n"
18990  " previous call, then a default value is used.\n"
18991  "\n"
18992  ""},
18993  { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
18994  "Set opaque RGB cmap1 colors values\n"
18995  "\n"
18996  "DESCRIPTION:\n"
18997  "\n"
18998  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
18999  " vector values. This function also sets the number of cmap1 colors.\n"
19000  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19001  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19002  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19003  " to\n"
19004  " ncol1-1. So in order for this continuous color model to work\n"
19005  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19006  " that these RGB vectors are continuous functions of their integer\n"
19007  " indices.\n"
19008  "\n"
19009  " Redacted form: plscmap1(r, g, b)\n"
19010  "\n"
19011  " This function is used in example 31.\n"
19012  "\n"
19013  "\n"
19014  "\n"
19015  "SYNOPSIS:\n"
19016  "\n"
19017  "plscmap1(r, g, b, ncol1)\n"
19018  "\n"
19019  "ARGUMENTS:\n"
19020  "\n"
19021  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19022  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19023  " color as a continuous function of the integer index of the vector.\n"
19024  "\n"
19025  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19026  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19027  " color as a continuous function of the integer index of the vector.\n"
19028  "\n"
19029  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19030  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19031  " color as a continuous function of the integer index of the vector.\n"
19032  "\n"
19033  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19034  "\n"
19035  ""},
19036  { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19037  "Set semitransparent cmap1 RGBA colors.\n"
19038  "\n"
19039  "DESCRIPTION:\n"
19040  "\n"
19041  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19042  " RGBA vector values. This function also sets the number of cmap1\n"
19043  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19044  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19045  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19046  " vectors in the range from 0 to\n"
19047  " ncol1-1. So in order for this continuous color model to work\n"
19048  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19049  " that these RGBA vectors are continuous functions of their integer\n"
19050  " indices.\n"
19051  "\n"
19052  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19053  "\n"
19054  " This function is used in example 31.\n"
19055  "\n"
19056  "\n"
19057  "\n"
19058  "SYNOPSIS:\n"
19059  "\n"
19060  "plscmap1a(r, g, b, alpha, ncol1)\n"
19061  "\n"
19062  "ARGUMENTS:\n"
19063  "\n"
19064  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19065  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19066  " color as a continuous function of the integer index of the vector.\n"
19067  "\n"
19068  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19069  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19070  " color as a continuous function of the integer index of the vector.\n"
19071  "\n"
19072  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19073  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19074  " color as a continuous function of the integer index of the vector.\n"
19075  "\n"
19076  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19077  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19078  " completely transparent and 1.0 corresponds to completely opaque)\n"
19079  " the alpha transparency of the color as a continuous function of\n"
19080  " the integer index of the vector.\n"
19081  "\n"
19082  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19083  " vectors.\n"
19084  "\n"
19085  ""},
19086  { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19087  "Set cmap1 colors using a piece-wise linear relationship\n"
19088  "\n"
19089  "DESCRIPTION:\n"
19090  "\n"
19091  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19092  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19093  " (see the PLplot documentation). May be called at any time.\n"
19094  "\n"
19095  " The idea here is to specify a number of control points that define the\n"
19096  " mapping between input cmap1 intensity indices and HLS (or RGB).\n"
19097  " Between these points, linear interpolation is used which gives a\n"
19098  " smooth variation of color with intensity index. Any number of control\n"
19099  " points may be specified, located at arbitrary positions, although\n"
19100  " typically 2 - 4 are enough. Another way of stating this is that we are\n"
19101  " traversing a given number of lines through HLS (or RGB) space as we\n"
19102  " move through cmap1 intensity indices. The control points at the\n"
19103  " minimum and maximum position (0 and 1) must always be specified. By\n"
19104  " adding more control points you can get more variation. One good\n"
19105  " technique for plotting functions that vary about some expected average\n"
19106  " is to use an additional 2 control points in the center (position ~=\n"
19107  " 0.5) that are the same lightness as the background (typically white\n"
19108  " for paper output, black for crt), and same hue as the boundary control\n"
19109  " points. This allows the highs and lows to be very easily\n"
19110  " distinguished.\n"
19111  "\n"
19112  " Each control point must specify the cmap1 intensity index and the\n"
19113  " associated three coordinates in HLS or RGB space. The first point\n"
19114  " must correspond to position = 0, and the last to position = 1.\n"
19115  "\n"
19116  " The default behaviour is for the hue to be linearly interpolated\n"
19117  " between the control points. Since the hue lies in the range [0, 360]\n"
19118  " this corresponds to interpolation around the \"front\" of the color\n"
19119  " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19120  " alternative interpolation is used between control points i and i+1. If\n"
19121  " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n"
19122  " - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n"
19123  " this as interpolation around the \"back\" or \"reverse\" of the color\n"
19124  " wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19125  " alt_hue_path[] = false for every control point.\n"
19126  "\n"
19127  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19128  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19129  " 240]truegreen-yellow-red-magenta-blue[240\n"
19130  " 120]trueblue-magenta-red-yellow-green\n"
19131  "\n"
19132  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19133  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19134  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19135  "\n"
19136  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19137  " alt_hue_path)\n"
19138  "\n"
19139  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19140  "\n"
19141  "\n"
19142  "\n"
19143  "SYNOPSIS:\n"
19144  "\n"
19145  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19146  "\n"
19147  "ARGUMENTS:\n"
19148  "\n"
19149  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19150  "\n"
19151  " npts (PLINT, input) : number of control points\n"
19152  "\n"
19153  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19154  " intensity index (0.0-1.0) in ascending order for each control\n"
19155  " point.\n"
19156  "\n"
19157  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19158  " coordinate (H or R) for each control point.\n"
19159  "\n"
19160  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19161  " coordinate (L or G) for each control point.\n"
19162  "\n"
19163  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19164  " coordinate (S or B) for each control point.\n"
19165  "\n"
19166  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19167  " npts - 1 elements) containing the alternative interpolation method\n"
19168  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19169  " refers to the interpolation interval between the i and i + 1\n"
19170  " control points).\n"
19171  "\n"
19172  ""},
19173  { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19174  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19175  "\n"
19176  "DESCRIPTION:\n"
19177  "\n"
19178  " This is a variant of plscmap1l that supports alpha channel\n"
19179  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19180  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19181  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19182  " transparency value (0.0-1.0). It may be called at any time.\n"
19183  "\n"
19184  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19185  " alpha, alt_hue_path)\n"
19186  "\n"
19187  " This function is used in example 30.\n"
19188  "\n"
19189  "\n"
19190  "\n"
19191  "SYNOPSIS:\n"
19192  "\n"
19193  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19194  "\n"
19195  "ARGUMENTS:\n"
19196  "\n"
19197  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19198  "\n"
19199  " npts (PLINT, input) : number of control points.\n"
19200  "\n"
19201  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19202  " intensity index (0.0-1.0) in ascending order for each control\n"
19203  " point.\n"
19204  "\n"
19205  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19206  " coordinate (H or R) for each control point.\n"
19207  "\n"
19208  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19209  " coordinate (L or G) for each control point.\n"
19210  "\n"
19211  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19212  " coordinate (S or B) for each control point.\n"
19213  "\n"
19214  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19215  " transparency value (0.0-1.0) for each control point.\n"
19216  "\n"
19217  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19218  " npts - 1 elements) containing the alternative interpolation method\n"
19219  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19220  " refers to the interpolation interval between the i and i + 1\n"
19221  " control points).\n"
19222  "\n"
19223  ""},
19224  { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19225  "Set number of colors in cmap1\n"
19226  "\n"
19227  "DESCRIPTION:\n"
19228  "\n"
19229  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19230  " values if this is the first allocation (see the PLplot documentation).\n"
19231  "\n"
19232  " Redacted form: plscmap1n(ncol1)\n"
19233  "\n"
19234  " This function is used in examples 8, 11, 20, and 21.\n"
19235  "\n"
19236  "\n"
19237  "\n"
19238  "SYNOPSIS:\n"
19239  "\n"
19240  "plscmap1n(ncol1)\n"
19241  "\n"
19242  "ARGUMENTS:\n"
19243  "\n"
19244  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19245  " the cmap1 palette. If this number is zero or less, then the value\n"
19246  " from the previous call to plscmap1n is used and if there is no\n"
19247  " previous call, then a default value is used.\n"
19248  "\n"
19249  ""},
19250  { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19251  "Set the cmap1 argument range for continuous color plots\n"
19252  "\n"
19253  "DESCRIPTION:\n"
19254  "\n"
19255  " Set the cmap1 argument range for continuous color plots that\n"
19256  " corresponds to the range of data values. The maximum range\n"
19257  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19258  " the cmap1 argument range that is specified with this routine, the\n"
19259  " smaller the subset of the cmap1 color palette that is used to\n"
19260  " represent the continuous data being plotted. If\n"
19261  " min_color is greater than\n"
19262  " max_color or\n"
19263  " max_color is greater than 1.0 or\n"
19264  " min_color is less than 0.0 then no change is made to the cmap1\n"
19265  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19266  "\n"
19267  " Redacted form: plscmap1_range(min_color, max_color)\n"
19268  "\n"
19269  " This function is currently used in example 33.\n"
19270  "\n"
19271  "\n"
19272  "\n"
19273  "SYNOPSIS:\n"
19274  "\n"
19275  "plscmap1_range(min_color, max_color)\n"
19276  "\n"
19277  "ARGUMENTS:\n"
19278  "\n"
19279  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19280  " than 0.0, then 0.0 is used instead.\n"
19281  "\n"
19282  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19283  " than 1.0, then 1.0 is used instead.\n"
19284  "\n"
19285  ""},
19286  { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
19287  "Get the cmap1 argument range for continuous color plots\n"
19288  "\n"
19289  "DESCRIPTION:\n"
19290  "\n"
19291  " Get the cmap1 argument range for continuous color plots. (Use\n"
19292  " plscmap1_range to set the cmap1 argument range.)\n"
19293  "\n"
19294  " Redacted form: plgcmap1_range(min_color, max_color)\n"
19295  "\n"
19296  " This function is currently not used in any example.\n"
19297  "\n"
19298  "\n"
19299  "\n"
19300  "SYNOPSIS:\n"
19301  "\n"
19302  "plgcmap1_range(min_color, max_color)\n"
19303  "\n"
19304  "ARGUMENTS:\n"
19305  "\n"
19306  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19307  " minimum cmap1 argument.\n"
19308  "\n"
19309  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19310  " maximum cmap1 argument.\n"
19311  "\n"
19312  ""},
19313  { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
19314  "Set 8-bit RGB values for given cmap0 color index\n"
19315  "\n"
19316  "DESCRIPTION:\n"
19317  "\n"
19318  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19319  " index. Overwrites the previous color value for the given index and,\n"
19320  " thus, does not result in any additional allocation of space for\n"
19321  " colors.\n"
19322  "\n"
19323  " Redacted form: plscol0(icol0, r, g, b)\n"
19324  "\n"
19325  " This function is used in any example 31.\n"
19326  "\n"
19327  "\n"
19328  "\n"
19329  "SYNOPSIS:\n"
19330  "\n"
19331  "plscol0(icol0, r, g, b)\n"
19332  "\n"
19333  "ARGUMENTS:\n"
19334  "\n"
19335  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19336  " number of colors (which is set by default, by plscmap0n, or even\n"
19337  " by plscmap0).\n"
19338  "\n"
19339  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19340  " degree of red in the color.\n"
19341  "\n"
19342  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19343  " degree of green in the color.\n"
19344  "\n"
19345  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19346  " degree of blue in the color.\n"
19347  "\n"
19348  ""},
19349  { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
19350  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19351  "\n"
19352  "DESCRIPTION:\n"
19353  "\n"
19354  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19355  " (see the PLplot documentation) index. Overwrites the previous color\n"
19356  " value for the given index and, thus, does not result in any additional\n"
19357  " allocation of space for colors.\n"
19358  "\n"
19359  " This function is used in example 30.\n"
19360  "\n"
19361  "\n"
19362  "\n"
19363  "SYNOPSIS:\n"
19364  "\n"
19365  "plscol0a(icol0, r, g, b, alpha)\n"
19366  "\n"
19367  "ARGUMENTS:\n"
19368  "\n"
19369  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19370  " number of colors (which is set by default, by plscmap0n, or even\n"
19371  " by plscmap0).\n"
19372  "\n"
19373  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19374  " degree of red in the color.\n"
19375  "\n"
19376  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19377  " degree of green in the color.\n"
19378  "\n"
19379  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19380  " degree of blue in the color.\n"
19381  "\n"
19382  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19383  " (0.0-1.0).\n"
19384  "\n"
19385  ""},
19386  { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
19387  "Set the background color by 8-bit RGB value\n"
19388  "\n"
19389  "DESCRIPTION:\n"
19390  "\n"
19391  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19392  " the PLplot documentation).\n"
19393  "\n"
19394  " Redacted form: plscolbg(r, g, b)\n"
19395  "\n"
19396  " This function is used in examples 15 and 31.\n"
19397  "\n"
19398  "\n"
19399  "\n"
19400  "SYNOPSIS:\n"
19401  "\n"
19402  "plscolbg(r, g, b)\n"
19403  "\n"
19404  "ARGUMENTS:\n"
19405  "\n"
19406  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19407  " degree of red in the color.\n"
19408  "\n"
19409  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19410  " degree of green in the color.\n"
19411  "\n"
19412  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19413  " degree of blue in the color.\n"
19414  "\n"
19415  ""},
19416  { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
19417  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
19418  "\n"
19419  "DESCRIPTION:\n"
19420  "\n"
19421  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
19422  " PLFLT alpha transparency value (see the PLplot documentation).\n"
19423  "\n"
19424  " This function is used in example 31.\n"
19425  "\n"
19426  "\n"
19427  "\n"
19428  "SYNOPSIS:\n"
19429  "\n"
19430  "plscolbga(r, g, b, alpha)\n"
19431  "\n"
19432  "ARGUMENTS:\n"
19433  "\n"
19434  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19435  " degree of red in the color.\n"
19436  "\n"
19437  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19438  " degree of green in the color.\n"
19439  "\n"
19440  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19441  " degree of blue in the color.\n"
19442  "\n"
19443  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19444  " (0.0-1.0).\n"
19445  "\n"
19446  ""},
19447  { "plscolor", _wrap_plscolor, METH_O, "\n"
19448  "Used to globally turn color output on/off\n"
19449  "\n"
19450  "DESCRIPTION:\n"
19451  "\n"
19452  " Used to globally turn color output on/off for those drivers/devices\n"
19453  " that support it.\n"
19454  "\n"
19455  " Redacted form: plscolor(color)\n"
19456  "\n"
19457  " This function is used in example 31.\n"
19458  "\n"
19459  "\n"
19460  "\n"
19461  "SYNOPSIS:\n"
19462  "\n"
19463  "plscolor(color)\n"
19464  "\n"
19465  "ARGUMENTS:\n"
19466  "\n"
19467  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19468  " turned off. If non-zero, color is turned on.\n"
19469  "\n"
19470  ""},
19471  { "plscompression", _wrap_plscompression, METH_O, "\n"
19472  "Set device-compression level\n"
19473  "\n"
19474  "DESCRIPTION:\n"
19475  "\n"
19476  " Set device-compression level. Only used for drivers that provide\n"
19477  " compression. This function, if used, should be invoked before a call\n"
19478  " to plinit.\n"
19479  "\n"
19480  " Redacted form: plscompression(compression)\n"
19481  "\n"
19482  " This function is used in example 31.\n"
19483  "\n"
19484  "\n"
19485  "\n"
19486  "SYNOPSIS:\n"
19487  "\n"
19488  "plscompression(compression)\n"
19489  "\n"
19490  "ARGUMENTS:\n"
19491  "\n"
19492  " compression (PLINT, input) : The desired compression level. This is\n"
19493  " a device-dependent value. Currently only the jpeg and png devices\n"
19494  " use these values. For jpeg value is the jpeg quality which should\n"
19495  " normally be in the range 0-95. Higher values denote higher quality\n"
19496  " and hence larger image sizes. For png values are in the range -1\n"
19497  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19498  " A value of -1 denotes the default zlib compression level. Values\n"
19499  " in the range 10-99 are divided by 10 and then used as the zlib\n"
19500  " compression level. Higher compression levels correspond to greater\n"
19501  " compression and small file sizes at the expense of more\n"
19502  " computation.\n"
19503  "\n"
19504  ""},
19505  { "plsdev", _wrap_plsdev, METH_O, "\n"
19506  "Set the device (keyword) name\n"
19507  "\n"
19508  "DESCRIPTION:\n"
19509  "\n"
19510  " Set the device (keyword) name.\n"
19511  "\n"
19512  " Redacted form: plsdev(devname)\n"
19513  "\n"
19514  " This function is used in examples 1, 14, and 20.\n"
19515  "\n"
19516  "\n"
19517  "\n"
19518  "SYNOPSIS:\n"
19519  "\n"
19520  "plsdev(devname)\n"
19521  "\n"
19522  "ARGUMENTS:\n"
19523  "\n"
19524  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
19525  " containing the device name keyword of the required output device.\n"
19526  " If\n"
19527  " devname is NULL or if the first character of the string is a ``?'',\n"
19528  " the normal (prompted) start up is used.\n"
19529  "\n"
19530  ""},
19531  { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
19532  "Set parameters that define current device-space window\n"
19533  "\n"
19534  "DESCRIPTION:\n"
19535  "\n"
19536  " Set relative margin width, aspect ratio, and relative justification\n"
19537  " that define current device-space window. If you want to just use the\n"
19538  " previous value for any of these, just pass in the magic value\n"
19539  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19540  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19541  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19542  " to a device-specific value.\n"
19543  "\n"
19544  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19545  "\n"
19546  " This function is used in example 31.\n"
19547  "\n"
19548  "\n"
19549  "\n"
19550  "SYNOPSIS:\n"
19551  "\n"
19552  "plsdidev(mar, aspect, jx, jy)\n"
19553  "\n"
19554  "ARGUMENTS:\n"
19555  "\n"
19556  " mar (PLFLT, input) : Relative margin width.\n"
19557  "\n"
19558  " aspect (PLFLT, input) : Aspect ratio.\n"
19559  "\n"
19560  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19561  " the range -0.5 to 0.5.\n"
19562  "\n"
19563  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19564  " the range -0.5 to 0.5.\n"
19565  "\n"
19566  ""},
19567  { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
19568  "Set up transformation from metafile coordinates\n"
19569  "\n"
19570  "DESCRIPTION:\n"
19571  "\n"
19572  " Set up transformation from metafile coordinates. The size of the plot\n"
19573  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19574  " general-purpose facility just yet (not sure why the user would need\n"
19575  " it, for one).\n"
19576  "\n"
19577  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19578  " dimypmm)\n"
19579  "\n"
19580  " This function is not used in any examples.\n"
19581  "\n"
19582  "\n"
19583  "\n"
19584  "SYNOPSIS:\n"
19585  "\n"
19586  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19587  "\n"
19588  "ARGUMENTS:\n"
19589  "\n"
19590  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
19591  "\n"
19592  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
19593  "\n"
19594  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
19595  "\n"
19596  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
19597  "\n"
19598  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19599  "\n"
19600  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19601  "\n"
19602  ""},
19603  { "plsdiori", _wrap_plsdiori, METH_O, "\n"
19604  "Set plot orientation\n"
19605  "\n"
19606  "DESCRIPTION:\n"
19607  "\n"
19608  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19609  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19610  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19611  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19612  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19613  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19614  " not called the default value of rot is 0.\n"
19615  "\n"
19616  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19617  " probably want to change the aspect ratio to a value suitable for the\n"
19618  " plot orientation using a call to plsdidev or the command-line options\n"
19619  " -a or -freeaspect. For more documentation of those options see the\n"
19620  " PLplot documentation. Such command-line options can be set internally\n"
19621  " using plsetopt or set directly using the command line and parsed using\n"
19622  " a call to plparseopts.\n"
19623  "\n"
19624  " Redacted form: plsdiori(rot)\n"
19625  "\n"
19626  " This function is not used in any examples.\n"
19627  "\n"
19628  "\n"
19629  "\n"
19630  "SYNOPSIS:\n"
19631  "\n"
19632  "plsdiori(rot)\n"
19633  "\n"
19634  "ARGUMENTS:\n"
19635  "\n"
19636  " rot (PLFLT, input) : Plot orientation parameter.\n"
19637  "\n"
19638  ""},
19639  { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
19640  "Set parameters that define current plot-space window\n"
19641  "\n"
19642  "DESCRIPTION:\n"
19643  "\n"
19644  " Set relative minima and maxima that define the current plot-space\n"
19645  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19646  " xmax, and ymax are 0., 0., 1., and 1.\n"
19647  "\n"
19648  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19649  "\n"
19650  " This function is used in example 31.\n"
19651  "\n"
19652  "\n"
19653  "\n"
19654  "SYNOPSIS:\n"
19655  "\n"
19656  "plsdiplt(xmin, ymin, xmax, ymax)\n"
19657  "\n"
19658  "ARGUMENTS:\n"
19659  "\n"
19660  " xmin (PLFLT, input) : Relative minimum in x.\n"
19661  "\n"
19662  " ymin (PLFLT, input) : Relative minimum in y.\n"
19663  "\n"
19664  " xmax (PLFLT, input) : Relative maximum in x.\n"
19665  "\n"
19666  " ymax (PLFLT, input) : Relative maximum in y.\n"
19667  "\n"
19668  ""},
19669  { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
19670  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
19671  "\n"
19672  "DESCRIPTION:\n"
19673  "\n"
19674  " Set relative minima and maxima incrementally (zoom mode) that define\n"
19675  " the current plot-space window. This function has the same effect as\n"
19676  " plsdiplt if that function has not been previously called. Otherwise,\n"
19677  " this function implements zoom mode using the transformation min_used =\n"
19678  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
19679  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19680  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
19681  "\n"
19682  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
19683  "\n"
19684  " This function is used in example 31.\n"
19685  "\n"
19686  "\n"
19687  "\n"
19688  "SYNOPSIS:\n"
19689  "\n"
19690  "plsdiplz(xmin, ymin, xmax, ymax)\n"
19691  "\n"
19692  "ARGUMENTS:\n"
19693  "\n"
19694  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
19695  "\n"
19696  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
19697  "\n"
19698  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
19699  "\n"
19700  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
19701  "\n"
19702  ""},
19703  { "plseed", _wrap_plseed, METH_O, "\n"
19704  "Set seed for internal random number generator.\n"
19705  "\n"
19706  "DESCRIPTION:\n"
19707  "\n"
19708  " Set the seed for the internal random number generator. See plrandd for\n"
19709  " further details.\n"
19710  "\n"
19711  " Redacted form: plseed(seed)\n"
19712  "\n"
19713  " This function is used in example 21.\n"
19714  "\n"
19715  "\n"
19716  "\n"
19717  "SYNOPSIS:\n"
19718  "\n"
19719  "plseed(seed)\n"
19720  "\n"
19721  "ARGUMENTS:\n"
19722  "\n"
19723  " seed (unsigned int, input) : Seed for random number generator.\n"
19724  "\n"
19725  ""},
19726  { "plsesc", _wrap_plsesc, METH_O, "\n"
19727  "Set the escape character for text strings\n"
19728  "\n"
19729  "DESCRIPTION:\n"
19730  "\n"
19731  " Set the escape character for text strings. From C (in contrast to\n"
19732  " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
19733  " characters are allowed to prevent the user from shooting himself in\n"
19734  " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
19735  " use of backslash as a character escape). Here are the allowed escape\n"
19736  " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
19737  " #, ASCII 35\n"
19738  " $, ASCII 36\n"
19739  " %, ASCII 37\n"
19740  " &, ASCII 38\n"
19741  " *, ASCII 42\n"
19742  " @, ASCII 64\n"
19743  " ^, ASCII 94\n"
19744  " ~, ASCII 126\n"
19745  "\n"
19746  "\n"
19747  " Redacted form: General: plsesc(esc)\n"
19748  "\n"
19749  "\n"
19750  " This function is used in example 29.\n"
19751  "\n"
19752  "\n"
19753  "\n"
19754  "SYNOPSIS:\n"
19755  "\n"
19756  "plsesc(esc)\n"
19757  "\n"
19758  "ARGUMENTS:\n"
19759  "\n"
19760  " esc (char, input) : Escape character.\n"
19761  "\n"
19762  ""},
19763  { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
19764  "Set any command-line option\n"
19765  "\n"
19766  "DESCRIPTION:\n"
19767  "\n"
19768  " Set any command-line option internally from a program before it\n"
19769  " invokes plinit. opt is the name of the command-line option and optarg\n"
19770  " is the corresponding command-line option argument.\n"
19771  "\n"
19772  " This function returns 0 on success.\n"
19773  "\n"
19774  " Redacted form: plsetopt(opt, optarg)\n"
19775  "\n"
19776  " This function is used in example 14.\n"
19777  "\n"
19778  "\n"
19779  "\n"
19780  "SYNOPSIS:\n"
19781  "\n"
19782  "PLINT plsetopt(opt, optarg)\n"
19783  "\n"
19784  "ARGUMENTS:\n"
19785  "\n"
19786  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19787  " the command-line option.\n"
19788  "\n"
19789  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
19790  " containing the argument of the command-line option.\n"
19791  "\n"
19792  ""},
19793  { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
19794  "Set family file parameters\n"
19795  "\n"
19796  "DESCRIPTION:\n"
19797  "\n"
19798  " Sets variables dealing with output file familying. Does nothing if\n"
19799  " familying not supported by the driver. This routine, if used, must be\n"
19800  " called before initializing PLplot. See the PLplot documentation for\n"
19801  " more information.\n"
19802  "\n"
19803  " Redacted form: plsfam(fam, num, bmax)\n"
19804  "\n"
19805  " This function is used in examples 14 and 31.\n"
19806  "\n"
19807  "\n"
19808  "\n"
19809  "SYNOPSIS:\n"
19810  "\n"
19811  "plsfam(fam, num, bmax)\n"
19812  "\n"
19813  "ARGUMENTS:\n"
19814  "\n"
19815  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
19816  " is enabled.\n"
19817  "\n"
19818  " num (PLINT, input) : Current family file number.\n"
19819  "\n"
19820  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19821  " file.\n"
19822  "\n"
19823  ""},
19824  { "plsfci", _wrap_plsfci, METH_O, "\n"
19825  "Set FCI (font characterization integer)\n"
19826  "\n"
19827  "DESCRIPTION:\n"
19828  "\n"
19829  " Sets font characteristics to be used at the start of the next string\n"
19830  " using the FCI approach. See the PLplot documentation for more\n"
19831  " information. Note, plsfont (which calls plsfci internally) provides a\n"
19832  " more user-friendly API for setting the font characterisitics.\n"
19833  "\n"
19834  " Redacted form: General: plsfci(fci)\n"
19835  "\n"
19836  "\n"
19837  " This function is used in example 23.\n"
19838  "\n"
19839  "\n"
19840  "\n"
19841  "SYNOPSIS:\n"
19842  "\n"
19843  "plsfci(fci)\n"
19844  "\n"
19845  "ARGUMENTS:\n"
19846  "\n"
19847  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19848  " of FCI.\n"
19849  "\n"
19850  ""},
19851  { "plsfnam", _wrap_plsfnam, METH_O, "\n"
19852  "Set output file name\n"
19853  "\n"
19854  "DESCRIPTION:\n"
19855  "\n"
19856  " Sets the current output file name, if applicable. If the file name\n"
19857  " has not been specified and is required by the driver, the user will be\n"
19858  " prompted for it. If using the X-windows output driver, this sets the\n"
19859  " display name. This routine, if used, must be called before\n"
19860  " initializing PLplot.\n"
19861  "\n"
19862  " Redacted form: plsfnam(fnam)\n"
19863  "\n"
19864  " This function is used in examples 1 and 20.\n"
19865  "\n"
19866  "\n"
19867  "\n"
19868  "SYNOPSIS:\n"
19869  "\n"
19870  "plsfnam(fnam)\n"
19871  "\n"
19872  "ARGUMENTS:\n"
19873  "\n"
19874  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19875  " the file name.\n"
19876  "\n"
19877  ""},
19878  { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
19879  "Set family, style and weight of the current font\n"
19880  "\n"
19881  "DESCRIPTION:\n"
19882  "\n"
19883  " Sets the current font. See the PLplot documentation for more\n"
19884  " information on font selection.\n"
19885  "\n"
19886  " Redacted form: plsfont(family, style, weight)\n"
19887  "\n"
19888  " This function is used in example 23.\n"
19889  "\n"
19890  "\n"
19891  "\n"
19892  "SYNOPSIS:\n"
19893  "\n"
19894  "plsfont(family, style, weight)\n"
19895  "\n"
19896  "ARGUMENTS:\n"
19897  "\n"
19898  " family (PLINT, input) : Font family to select for the current font.\n"
19899  " The available values are given by the PL_FCI_* constants in\n"
19900  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
19901  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19902  " signifies that the font family should not be altered.\n"
19903  "\n"
19904  " style (PLINT, input) : Font style to select for the current font.\n"
19905  " The available values are given by the PL_FCI_* constants in\n"
19906  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19907  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19908  " should not be altered.\n"
19909  "\n"
19910  " weight (PLINT, input) : Font weight to select for the current font.\n"
19911  " The available values are given by the PL_FCI_* constants in\n"
19912  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19913  " negative value signifies that the font weight should not be\n"
19914  " altered.\n"
19915  "\n"
19916  ""},
19917  { "plshades", _wrap_plshades, METH_VARARGS, "\n"
19918  "Shade regions on the basis of value\n"
19919  "\n"
19920  "DESCRIPTION:\n"
19921  "\n"
19922  " Shade regions on the basis of value. This is the high-level routine\n"
19923  " for making continuous color shaded plots with cmap1 while plshade\n"
19924  " should be used to plot individual shaded regions using either cmap0 or\n"
19925  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
19926  " our supported languages.\n"
19927  "\n"
19928  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19929  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19930  " pltr_data)\n"
19931  "\n"
19932  "\n"
19933  " This function is used in examples 16, 21, and 22.\n"
19934  "\n"
19935  "\n"
19936  "\n"
19937  "SYNOPSIS:\n"
19938  "\n"
19939  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19940  "\n"
19941  "ARGUMENTS:\n"
19942  "\n"
19943  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19944  " plot. Should have dimensions of\n"
19945  " nx by\n"
19946  " ny.\n"
19947  "\n"
19948  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
19949  "\n"
19950  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
19951  "\n"
19952  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
19953  " the region that should be plotted in the shade plot. This\n"
19954  " function accepts x and y coordinates as input arguments and must\n"
19955  " return 1 if the point is to be included in the shade plot and 0\n"
19956  " otherwise. If you want to plot the entire shade plot (the usual\n"
19957  " case), this argument should be set to NULL.\n"
19958  "\n"
19959  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
19960  " pltr below for how these arguments are used (only for the special case\n"
19961  " when the callback function\n"
19962  " pltr is not supplied).\n"
19963  "\n"
19964  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
19965  " corresponding to the edges of each shaded region that will be\n"
19966  " plotted by this function. To work properly the levels should be\n"
19967  " monotonic.\n"
19968  "\n"
19969  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19970  " of shade edge values in clevel).\n"
19971  "\n"
19972  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
19973  " pattern.\n"
19974  "\n"
19975  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
19976  " contours defining edges of shaded regions. The pen color is only\n"
19977  " temporary set for the contour drawing. Set this value to zero or\n"
19978  " less if no shade edge contours are wanted.\n"
19979  "\n"
19980  " cont_width (PLFLT, input) : Defines line width used for contours\n"
19981  " defining edges of shaded regions. This value may not be honored\n"
19982  " by all drivers. The pen width is only temporary set for the\n"
19983  " contour drawing. Set this value to zero or less if no shade edge\n"
19984  " contours are wanted.\n"
19985  "\n"
19986  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
19987  " region. Use plfill for this purpose.\n"
19988  "\n"
19989  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19990  " map to rectangles after coordinate transformation with pltrl.\n"
19991  " Otherwise, set rectangular to false. If rectangular is set to\n"
19992  " true, plshade tries to save time by filling large rectangles.\n"
19993  " This optimization fails if the coordinate transformation distorts\n"
19994  " the shape of rectangles. For example a plot in polar coordinates\n"
19995  " has to have rectangular set to false.\n"
19996  "\n"
19997  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
19998  " defines the transformation between the zero-based indices of the\n"
19999  " matrix a and world coordinates. If\n"
20000  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20001  " indices of a are mapped to the range\n"
20002  " xmin through\n"
20003  " xmax and the y indices of a are mapped to the range\n"
20004  " ymin through\n"
20005  " ymax.For the C case, transformation functions are provided in the\n"
20006  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20007  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20008  " matrices. In addition, C callback routines for the transformation\n"
20009  " can be supplied by the user such as the mypltr function in\n"
20010  " examples/c/x09c.c which provides a general linear transformation\n"
20011  " between index coordinates and world coordinates.For languages\n"
20012  " other than C you should consult the PLplot documentation for the\n"
20013  " details concerning how PLTRANSFORM_callback arguments are\n"
20014  " interfaced. However, in general, a particular pattern of\n"
20015  " callback-associated arguments such as a tr vector with 6 elements;\n"
20016  " xg and yg vectors; or xg and yg matrices are respectively\n"
20017  " interfaced to a linear-transformation routine similar to the above\n"
20018  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20019  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20020  " support native language callbacks for handling index to\n"
20021  " world-coordinate transformations. Examples of these various\n"
20022  " approaches are given in examples/<language>x09*,\n"
20023  " examples/<language>x16*, examples/<language>x20*,\n"
20024  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20025  " supported languages.\n"
20026  "\n"
20027  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20028  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20029  " externally supplied.\n"
20030  "\n"
20031  ""},
20032  { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20033  "Shade individual region on the basis of value\n"
20034  "\n"
20035  "DESCRIPTION:\n"
20036  "\n"
20037  " Shade individual region on the basis of value. Use plshades if you\n"
20038  " want to shade a number of contiguous regions using continuous colors.\n"
20039  " In particular the edge contours are treated properly in plshades. If\n"
20040  " you attempt to do contiguous regions with plshade the contours at the\n"
20041  " edge of the shade are partially obliterated by subsequent plots of\n"
20042  " contiguous shaded regions.\n"
20043  "\n"
20044  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20045  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20046  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20047  "\n"
20048  "\n"
20049  " This function is used in example 15.\n"
20050  "\n"
20051  "\n"
20052  "\n"
20053  "SYNOPSIS:\n"
20054  "\n"
20055  "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"
20056  "\n"
20057  "ARGUMENTS:\n"
20058  "\n"
20059  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20060  " plot. Should have dimensions of\n"
20061  " nx by\n"
20062  " ny.\n"
20063  "\n"
20064  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20065  "\n"
20066  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20067  "\n"
20068  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20069  " the region that should be plotted in the shade plot. This\n"
20070  " function accepts x and y coordinates as input arguments and must\n"
20071  " return 1 if the point is to be included in the shade plot and 0\n"
20072  " otherwise. If you want to plot the entire shade plot (the usual\n"
20073  " case), this argument should be set to NULL.\n"
20074  "\n"
20075  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20076  " pltr below for how these arguments are used (only for the special case\n"
20077  " when the callback function\n"
20078  " pltr is not supplied).\n"
20079  "\n"
20080  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20081  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20082  "\n"
20083  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20084  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20085  "\n"
20086  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20087  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20088  " then sh_color is interpreted as a cmap1 argument in the range\n"
20089  " (0.0-1.0).\n"
20090  "\n"
20091  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20092  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20093  "\n"
20094  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20095  "\n"
20096  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20097  " boundary of shaded region. The min values are used for the\n"
20098  " shade_min boundary, and the max values are used on the shade_max\n"
20099  " boundary. Set color and width to zero for no plotted boundaries.\n"
20100  "\n"
20101  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20102  " boundary of shaded region. The min values are used for the\n"
20103  " shade_min boundary, and the max values are used on the shade_max\n"
20104  " boundary. Set color and width to zero for no plotted boundaries.\n"
20105  "\n"
20106  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20107  " boundary of shaded region. The min values are used for the\n"
20108  " shade_min boundary, and the max values are used on the shade_max\n"
20109  " boundary. Set color and width to zero for no plotted boundaries.\n"
20110  "\n"
20111  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20112  " boundary of shaded region. The min values are used for the\n"
20113  " shade_min boundary, and the max values are used on the shade_max\n"
20114  " boundary. Set color and width to zero for no plotted boundaries.\n"
20115  "\n"
20116  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20117  " Use plfill. Future version of PLplot may have other fill\n"
20118  " routines.\n"
20119  "\n"
20120  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20121  " map to rectangles after coordinate transformation with pltrl.\n"
20122  " Otherwise, set rectangular to false. If rectangular is set to\n"
20123  " true, plshade tries to save time by filling large rectangles.\n"
20124  " This optimization fails if the coordinate transformation distorts\n"
20125  " the shape of rectangles. For example a plot in polar coordinates\n"
20126  " has to have rectangular set to false.\n"
20127  "\n"
20128  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20129  " defines the transformation between the zero-based indices of the\n"
20130  " matrix a and world coordinates. If\n"
20131  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20132  " indices of a are mapped to the range\n"
20133  " xmin through\n"
20134  " xmax and the y indices of a are mapped to the range\n"
20135  " ymin through\n"
20136  " ymax.For the C case, transformation functions are provided in the\n"
20137  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20138  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20139  " matrices. In addition, C callback routines for the transformation\n"
20140  " can be supplied by the user such as the mypltr function in\n"
20141  " examples/c/x09c.c which provides a general linear transformation\n"
20142  " between index coordinates and world coordinates.For languages\n"
20143  " other than C you should consult the PLplot documentation for the\n"
20144  " details concerning how PLTRANSFORM_callback arguments are\n"
20145  " interfaced. However, in general, a particular pattern of\n"
20146  " callback-associated arguments such as a tr vector with 6 elements;\n"
20147  " xg and yg vectors; or xg and yg matrices are respectively\n"
20148  " interfaced to a linear-transformation routine similar to the above\n"
20149  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20150  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20151  " support native language callbacks for handling index to\n"
20152  " world-coordinate transformations. Examples of these various\n"
20153  " approaches are given in examples/<language>x09*,\n"
20154  " examples/<language>x16*, examples/<language>x20*,\n"
20155  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20156  " supported languages.\n"
20157  "\n"
20158  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20159  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20160  " externally supplied.\n"
20161  "\n"
20162  ""},
20163  { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20164  "Assign a function to use for generating custom axis labels\n"
20165  "\n"
20166  "DESCRIPTION:\n"
20167  "\n"
20168  " This function allows a user to provide their own function to provide\n"
20169  " axis label text. The user function is given the numeric value for a\n"
20170  " point on an axis and returns a string label to correspond with that\n"
20171  " value. Custom axis labels can be enabled by passing appropriate\n"
20172  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20173  "\n"
20174  " This function is used in example 19.\n"
20175  "\n"
20176  "\n"
20177  "\n"
20178  "SYNOPSIS:\n"
20179  "\n"
20180  "plslabelfunc(label_func, label_data)\n"
20181  "\n"
20182  "ARGUMENTS:\n"
20183  "\n"
20184  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20185  " label function. In order to reset to the default labelling, set\n"
20186  " this to NULL. The labelling function parameters are, in order:\n"
20187  " axis: This indicates which axis a label is being requested for.\n"
20188  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20189  "\n"
20190  " value: This is the value along the axis which is being labelled.\n"
20191  "\n"
20192  " label_text: The string representation of the label value.\n"
20193  "\n"
20194  " length: The maximum length in characters allowed for label_text.\n"
20195  "\n"
20196  "\n"
20197  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20198  " data to the label_func function.\n"
20199  "\n"
20200  ""},
20201  { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20202  "Set length of major ticks\n"
20203  "\n"
20204  "DESCRIPTION:\n"
20205  "\n"
20206  " This sets up the length of the major ticks. The actual length is the\n"
20207  " product of the default length and a scaling factor as for character\n"
20208  " height.\n"
20209  "\n"
20210  " Redacted form: plsmaj(def, scale)\n"
20211  "\n"
20212  " This function is used in example 29.\n"
20213  "\n"
20214  "\n"
20215  "\n"
20216  "SYNOPSIS:\n"
20217  "\n"
20218  "plsmaj(def, scale)\n"
20219  "\n"
20220  "ARGUMENTS:\n"
20221  "\n"
20222  " def (PLFLT, input) : The default length of a major tick in\n"
20223  " millimeters, should be set to zero if the default length is to\n"
20224  " remain unchanged.\n"
20225  "\n"
20226  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20227  " actual tick length.\n"
20228  "\n"
20229  ""},
20230  { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20231  "Set the memory area to be plotted (RGB)\n"
20232  "\n"
20233  "DESCRIPTION:\n"
20234  "\n"
20235  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20236  " the dev member of the stream structure. Also set the number of pixels\n"
20237  " in the memory passed in\n"
20238  " plotmem, which is a block of memory\n"
20239  " maxy by\n"
20240  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20241  "\n"
20242  " This memory will have to be freed by the user!\n"
20243  "\n"
20244  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20245  "\n"
20246  " This function is not used in any examples.\n"
20247  "\n"
20248  "\n"
20249  "\n"
20250  "SYNOPSIS:\n"
20251  "\n"
20252  "plsmem(maxx, maxy, plotmem)\n"
20253  "\n"
20254  "ARGUMENTS:\n"
20255  "\n"
20256  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20257  "\n"
20258  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20259  "\n"
20260  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20261  " user-supplied writeable memory area.\n"
20262  "\n"
20263  ""},
20264  { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20265  "Set the memory area to be plotted (RGBA)\n"
20266  "\n"
20267  "DESCRIPTION:\n"
20268  "\n"
20269  " Set the memory area to be plotted (with the memcairo driver) as the\n"
20270  " dev member of the stream structure. Also set the number of pixels in\n"
20271  " the memory passed in\n"
20272  " plotmem, which is a block of memory\n"
20273  " maxy by\n"
20274  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20275  "\n"
20276  " This memory will have to be freed by the user!\n"
20277  "\n"
20278  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20279  "\n"
20280  " This function is not used in any examples.\n"
20281  "\n"
20282  "\n"
20283  "\n"
20284  "SYNOPSIS:\n"
20285  "\n"
20286  "plsmema(maxx, maxy, plotmem)\n"
20287  "\n"
20288  "ARGUMENTS:\n"
20289  "\n"
20290  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20291  "\n"
20292  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20293  "\n"
20294  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20295  " user-supplied writeable memory area.\n"
20296  "\n"
20297  ""},
20298  { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
20299  "Set length of minor ticks\n"
20300  "\n"
20301  "DESCRIPTION:\n"
20302  "\n"
20303  " This sets up the length of the minor ticks and the length of the\n"
20304  " terminals on error bars. The actual length is the product of the\n"
20305  " default length and a scaling factor as for character height.\n"
20306  "\n"
20307  " Redacted form: plsmin(def, scale)\n"
20308  "\n"
20309  " This function is used in example 29.\n"
20310  "\n"
20311  "\n"
20312  "\n"
20313  "SYNOPSIS:\n"
20314  "\n"
20315  "plsmin(def, scale)\n"
20316  "\n"
20317  "ARGUMENTS:\n"
20318  "\n"
20319  " def (PLFLT, input) : The default length of a minor tick in\n"
20320  " millimeters, should be set to zero if the default length is to\n"
20321  " remain unchanged.\n"
20322  "\n"
20323  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20324  " actual tick length.\n"
20325  "\n"
20326  ""},
20327  { "plsori", _wrap_plsori, METH_O, "\n"
20328  "Set orientation\n"
20329  "\n"
20330  "DESCRIPTION:\n"
20331  "\n"
20332  " Set integer plot orientation parameter. This function is identical to\n"
20333  " plsdiori except for the type of the argument, and should be used in\n"
20334  " the same way. See the documentation of plsdiori for details.\n"
20335  "\n"
20336  " Redacted form: plsori(ori)\n"
20337  "\n"
20338  " This function is used in example 3.\n"
20339  "\n"
20340  "\n"
20341  "\n"
20342  "SYNOPSIS:\n"
20343  "\n"
20344  "plsori(ori)\n"
20345  "\n"
20346  "ARGUMENTS:\n"
20347  "\n"
20348  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20349  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20350  " angle.\n"
20351  "\n"
20352  ""},
20353  { "plspage", _wrap_plspage, METH_VARARGS, "\n"
20354  "Set page parameters\n"
20355  "\n"
20356  "DESCRIPTION:\n"
20357  "\n"
20358  " Sets the page configuration (optional). If an individual parameter is\n"
20359  " zero then that parameter value is not updated. Not all parameters are\n"
20360  " recognized by all drivers and the interpretation is device-dependent.\n"
20361  " The X-window driver uses the length and offset parameters to determine\n"
20362  " the window size and location. The length and offset values are\n"
20363  " expressed in units that are specific to the current driver. For\n"
20364  " instance: screen drivers will usually interpret them as number of\n"
20365  " pixels, whereas printer drivers will usually use mm.\n"
20366  "\n"
20367  " This routine, if used, must be called before initializing PLplot. It\n"
20368  " may be called at later times for interactive drivers to change only\n"
20369  " the dpi for subsequent redraws which you can force via a call to\n"
20370  " plreplot. If this function is not called then the page size defaults\n"
20371  " to landscape A4 for drivers which use real world page sizes and 744\n"
20372  " pixels wide by 538 pixels high for raster drivers. The default value\n"
20373  " for dx and dy is 90 pixels per inch for raster drivers.\n"
20374  "\n"
20375  "\n"
20376  "\n"
20377  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20378  "\n"
20379  " This function is used in examples 14 and 31.\n"
20380  "\n"
20381  "\n"
20382  "\n"
20383  "SYNOPSIS:\n"
20384  "\n"
20385  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20386  "\n"
20387  "ARGUMENTS:\n"
20388  "\n"
20389  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20390  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20391  " (e.g. mm).\n"
20392  "\n"
20393  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20394  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20395  " (e.g. mm).\n"
20396  "\n"
20397  " xleng (PLINT, input) : Page length, x.\n"
20398  "\n"
20399  " yleng (PLINT, input) : Page length, y.\n"
20400  "\n"
20401  " xoff (PLINT, input) : Page offset, x.\n"
20402  "\n"
20403  " yoff (PLINT, input) : Page offset, y.\n"
20404  "\n"
20405  ""},
20406  { "plspal0", _wrap_plspal0, METH_O, "\n"
20407  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
20408  "\n"
20409  "DESCRIPTION:\n"
20410  "\n"
20411  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
20412  "\n"
20413  " Redacted form: plspal0(filename)\n"
20414  "\n"
20415  " This function is in example 16.\n"
20416  "\n"
20417  "\n"
20418  "\n"
20419  "SYNOPSIS:\n"
20420  "\n"
20421  "plspal0(filename)\n"
20422  "\n"
20423  "ARGUMENTS:\n"
20424  "\n"
20425  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20426  " containing the name of the cmap0*.pal file. If this string is\n"
20427  " empty, use the default cmap0*.pal file.\n"
20428  "\n"
20429  ""},
20430  { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
20431  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
20432  "\n"
20433  "DESCRIPTION:\n"
20434  "\n"
20435  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
20436  "\n"
20437  " Redacted form: plspal1(filename, interpolate)\n"
20438  "\n"
20439  " This function is used in example 16.\n"
20440  "\n"
20441  "\n"
20442  "\n"
20443  "SYNOPSIS:\n"
20444  "\n"
20445  "plspal1(filename, interpolate)\n"
20446  "\n"
20447  "ARGUMENTS:\n"
20448  "\n"
20449  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20450  " containing the name of the cmap1*.pal file. If this string is\n"
20451  " empty, use the default cmap1*.pal file.\n"
20452  "\n"
20453  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20454  " columns containing the intensity index, r, g, b, alpha and\n"
20455  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20456  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20457  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20458  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20459  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20460  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20461  " are used instead to set the cmap1 palette directly with a call to\n"
20462  " plscmap1a.\n"
20463  "\n"
20464  ""},
20465  { "plspause", _wrap_plspause, METH_O, "\n"
20466  "Set the pause (on end-of-page) status\n"
20467  "\n"
20468  "DESCRIPTION:\n"
20469  "\n"
20470  " Set the pause (on end-of-page) status.\n"
20471  "\n"
20472  " Redacted form: plspause(pause)\n"
20473  "\n"
20474  " This function is in examples 14,20.\n"
20475  "\n"
20476  "\n"
20477  "\n"
20478  "SYNOPSIS:\n"
20479  "\n"
20480  "plspause(pause)\n"
20481  "\n"
20482  "ARGUMENTS:\n"
20483  "\n"
20484  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20485  " end-of-page for those drivers which support this. Otherwise there\n"
20486  " is no pause.\n"
20487  "\n"
20488  ""},
20489  { "plsstrm", _wrap_plsstrm, METH_O, "\n"
20490  "Set current output stream\n"
20491  "\n"
20492  "DESCRIPTION:\n"
20493  "\n"
20494  " Sets the number of the current output stream. The stream number\n"
20495  " defaults to 0 unless changed by this routine. The first use of this\n"
20496  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
20497  "\n"
20498  " Redacted form: plsstrm(strm)\n"
20499  "\n"
20500  " This function is examples 1,14,20.\n"
20501  "\n"
20502  "\n"
20503  "\n"
20504  "SYNOPSIS:\n"
20505  "\n"
20506  "plsstrm(strm)\n"
20507  "\n"
20508  "ARGUMENTS:\n"
20509  "\n"
20510  " strm (PLINT, input) : The current stream number.\n"
20511  "\n"
20512  ""},
20513  { "plssub", _wrap_plssub, METH_VARARGS, "\n"
20514  "Set the number of subpages in x and y\n"
20515  "\n"
20516  "DESCRIPTION:\n"
20517  "\n"
20518  " Set the number of subpages in x and y.\n"
20519  "\n"
20520  " Redacted form: plssub(nx, ny)\n"
20521  "\n"
20522  " This function is examples 1,2,14,21,25,27.\n"
20523  "\n"
20524  "\n"
20525  "\n"
20526  "SYNOPSIS:\n"
20527  "\n"
20528  "plssub(nx, ny)\n"
20529  "\n"
20530  "ARGUMENTS:\n"
20531  "\n"
20532  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20533  " of window columns).\n"
20534  "\n"
20535  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20536  " of window rows).\n"
20537  "\n"
20538  ""},
20539  { "plssym", _wrap_plssym, METH_VARARGS, "\n"
20540  "Set symbol size\n"
20541  "\n"
20542  "DESCRIPTION:\n"
20543  "\n"
20544  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20545  " plsym. The actual height of a symbol is the product of the default\n"
20546  " symbol size and a scaling factor as for the character height.\n"
20547  "\n"
20548  " Redacted form: plssym(def, scale)\n"
20549  "\n"
20550  " This function is used in example 29.\n"
20551  "\n"
20552  "\n"
20553  "\n"
20554  "SYNOPSIS:\n"
20555  "\n"
20556  "plssym(def, scale)\n"
20557  "\n"
20558  "ARGUMENTS:\n"
20559  "\n"
20560  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20561  " should be set to zero if the default height is to remain\n"
20562  " unchanged.\n"
20563  "\n"
20564  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20565  " actual symbol height.\n"
20566  "\n"
20567  ""},
20568  { "plstar", _wrap_plstar, METH_VARARGS, "\n"
20569  "Initialization\n"
20570  "\n"
20571  "DESCRIPTION:\n"
20572  "\n"
20573  " Initializing the plotting package. The program prompts for the device\n"
20574  " keyword or number of the desired output device. Hitting a RETURN in\n"
20575  " response to the prompt is the same as selecting the first device. If\n"
20576  " only one device is enabled when PLplot is installed, plstar will issue\n"
20577  " no prompt. The output device is divided into nx by ny subpages, each\n"
20578  " of which may be used independently. The subroutine pladv is used to\n"
20579  " advance from one subpage to the next.\n"
20580  "\n"
20581  " Redacted form: plstar(nx, ny)\n"
20582  "\n"
20583  " This function is used in example 1.\n"
20584  "\n"
20585  "\n"
20586  "\n"
20587  "SYNOPSIS:\n"
20588  "\n"
20589  "plstar(nx, ny)\n"
20590  "\n"
20591  "ARGUMENTS:\n"
20592  "\n"
20593  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20594  " x direction.\n"
20595  "\n"
20596  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20597  " y direction.\n"
20598  "\n"
20599  ""},
20600  { "plstart", _wrap_plstart, METH_VARARGS, "\n"
20601  "Initialization\n"
20602  "\n"
20603  "DESCRIPTION:\n"
20604  "\n"
20605  " Alternative to plstar for initializing the plotting package. The\n"
20606  " device name keyword for the desired output device must be supplied as\n"
20607  " an argument. These keywords are the same as those printed out by\n"
20608  " plstar. If the requested device is not available, or if the input\n"
20609  " string is empty or begins with ``?'', the prompted start up of plstar\n"
20610  " is used. This routine also divides the output device page into nx by\n"
20611  " ny subpages, each of which may be used independently. The subroutine\n"
20612  " pladv is used to advance from one subpage to the next.\n"
20613  "\n"
20614  " Redacted form: General: plstart(devname, nx, ny)\n"
20615  "\n"
20616  "\n"
20617  " This function is not used in any examples.\n"
20618  "\n"
20619  "\n"
20620  "\n"
20621  "SYNOPSIS:\n"
20622  "\n"
20623  "plstart(devname, nx, ny)\n"
20624  "\n"
20625  "ARGUMENTS:\n"
20626  "\n"
20627  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20628  " containing the device name keyword of the required output device.\n"
20629  " If\n"
20630  " devname is NULL or if the first character of the string is a ``?'',\n"
20631  " the normal (prompted) start up is used.\n"
20632  "\n"
20633  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20634  " x direction.\n"
20635  "\n"
20636  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20637  " y direction.\n"
20638  "\n"
20639  ""},
20640  { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
20641  "Set a global coordinate transform function\n"
20642  "\n"
20643  "DESCRIPTION:\n"
20644  "\n"
20645  " This function can be used to define a coordinate transformation which\n"
20646  " affects all elements drawn within the current plot window. The\n"
20647  " coordinate_transform callback function is similar to that provided for\n"
20648  " the plmap and plmeridians functions. The coordinate_transform_data\n"
20649  " parameter may be used to pass extra data to coordinate_transform.\n"
20650  "\n"
20651  " Redacted form: General: plstransform(coordinate_transform,\n"
20652  " coordinate_transform_data)\n"
20653  "\n"
20654  "\n"
20655  " This function is used in examples 19 and 22.\n"
20656  "\n"
20657  "\n"
20658  "\n"
20659  "SYNOPSIS:\n"
20660  "\n"
20661  "plstransform(coordinate_transform, coordinate_transform_data)\n"
20662  "\n"
20663  "ARGUMENTS:\n"
20664  "\n"
20665  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
20666  " function that defines the transformation from the input (x, y)\n"
20667  " world coordinates to new PLplot world coordinates. If\n"
20668  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
20669  " case), then no transform is applied.\n"
20670  "\n"
20671  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
20672  " for\n"
20673  " coordinate_transform.\n"
20674  "\n"
20675  ""},
20676  { "plstring", _wrap_plstring, METH_VARARGS, "\n"
20677  "Plot a glyph at the specified points\n"
20678  "\n"
20679  "DESCRIPTION:\n"
20680  "\n"
20681  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20682  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
20683  " is specified with a PLplot user string. Note that the user string is\n"
20684  " not actually limited to one glyph so it is possible (but not normally\n"
20685  " useful) to plot more than one glyph at the specified points with this\n"
20686  " function. As with plmtex and plptex, the user string can contain FCI\n"
20687  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20688  " else PLplot escapes for Hershey or unicode text to determine the\n"
20689  " glyph.\n"
20690  "\n"
20691  " Redacted form: plstring(x, y, string)\n"
20692  "\n"
20693  " This function is used in examples 4, 21 and 26.\n"
20694  "\n"
20695  "\n"
20696  "\n"
20697  "SYNOPSIS:\n"
20698  "\n"
20699  "plstring(n, x, y, string)\n"
20700  "\n"
20701  "ARGUMENTS:\n"
20702  "\n"
20703  " n (PLINT, input) : Number of points in the x and y vectors.\n"
20704  "\n"
20705  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20706  " the points.\n"
20707  "\n"
20708  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20709  " the points.\n"
20710  "\n"
20711  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20712  " the glyph(s) to be plotted at each of the n points.\n"
20713  "\n"
20714  ""},
20715  { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
20716  "Plot a glyph at the specified 3D points\n"
20717  "\n"
20718  "DESCRIPTION:\n"
20719  "\n"
20720  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20721  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20722  " this function similar to what is done for plline3. The glyph is\n"
20723  " specified with a PLplot user string. Note that the user string is not\n"
20724  " actually limited to one glyph so it is possible (but not normally\n"
20725  " useful) to plot more than one glyph at the specified points with this\n"
20726  " function. As with plmtex and plptex, the user string can contain FCI\n"
20727  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20728  " else PLplot escapes for Hershey or unicode text to determine the\n"
20729  " glyph.\n"
20730  "\n"
20731  " Redacted form: plstring3(x, y, z, string)\n"
20732  "\n"
20733  " This function is used in example 18.\n"
20734  "\n"
20735  "\n"
20736  "\n"
20737  "SYNOPSIS:\n"
20738  "\n"
20739  "plstring3(n, x, y, z, string)\n"
20740  "\n"
20741  "ARGUMENTS:\n"
20742  "\n"
20743  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
20744  "\n"
20745  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20746  " the points.\n"
20747  "\n"
20748  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20749  " the points.\n"
20750  "\n"
20751  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
20752  " the points.\n"
20753  "\n"
20754  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20755  " the glyph(s) to be plotted at each of the n points. points.\n"
20756  "\n"
20757  ""},
20758  { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
20759  "Add a point to a strip chart\n"
20760  "\n"
20761  "DESCRIPTION:\n"
20762  "\n"
20763  " Add a point to a given pen of a given strip chart. There is no need\n"
20764  " for all pens to have the same number of points or to be equally\n"
20765  " sampled in the x coordinate. Allocates memory and rescales as\n"
20766  " necessary.\n"
20767  "\n"
20768  " Redacted form: plstripa(id, pen, x, y)\n"
20769  "\n"
20770  " This function is used in example 17.\n"
20771  "\n"
20772  "\n"
20773  "\n"
20774  "SYNOPSIS:\n"
20775  "\n"
20776  "plstripa(id, pen, x, y)\n"
20777  "\n"
20778  "ARGUMENTS:\n"
20779  "\n"
20780  " id (PLINT, input) : Identification number of the strip chart (set\n"
20781  " up in plstripc).\n"
20782  "\n"
20783  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
20784  "\n"
20785  " x (PLFLT, input) : X coordinate of point to plot.\n"
20786  "\n"
20787  " y (PLFLT, input) : Y coordinate of point to plot.\n"
20788  "\n"
20789  ""},
20790  { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
20791  "Create a 4-pen strip chart\n"
20792  "\n"
20793  "DESCRIPTION:\n"
20794  "\n"
20795  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20796  "\n"
20797  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20798  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20799  " styline, legline, labx, laby, labz)\n"
20800  "\n"
20801  "\n"
20802  " This function is used in example 17.\n"
20803  "\n"
20804  "\n"
20805  "\n"
20806  "SYNOPSIS:\n"
20807  "\n"
20808  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20809  "\n"
20810  "ARGUMENTS:\n"
20811  "\n"
20812  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
20813  " number of the strip chart to use on plstripa and plstripd.\n"
20814  "\n"
20815  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20816  " the x-axis specification as in plbox.\n"
20817  "\n"
20818  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20819  " the y-axis specification as in plbox.\n"
20820  "\n"
20821  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20822  " change as data are added.\n"
20823  "\n"
20824  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20825  " change as data are added.\n"
20826  "\n"
20827  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
20828  " is multiplied by the factor (1 +\n"
20829  " xjump) .\n"
20830  "\n"
20831  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20832  " change as data are added.\n"
20833  "\n"
20834  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20835  " change as data are added.\n"
20836  "\n"
20837  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
20838  "\n"
20839  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
20840  "\n"
20841  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
20842  " true, otherwise not.\n"
20843  "\n"
20844  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
20845  " otherwise slide display.\n"
20846  "\n"
20847  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
20848  "\n"
20849  " collab (PLINT, input) : Legend color index (cmap0).\n"
20850  "\n"
20851  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
20852  " indices for the 4 pens.\n"
20853  "\n"
20854  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
20855  " indices for the 4 pens.\n"
20856  "\n"
20857  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
20858  " strings containing legends for the 4 pens.\n"
20859  "\n"
20860  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20861  " the label for the x axis.\n"
20862  "\n"
20863  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20864  " the label for the y axis.\n"
20865  "\n"
20866  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20867  " the plot title.\n"
20868  "\n"
20869  ""},
20870  { "plstripd", _wrap_plstripd, METH_O, "\n"
20871  "Deletes and releases memory used by a strip chart\n"
20872  "\n"
20873  "DESCRIPTION:\n"
20874  "\n"
20875  " Deletes and releases memory used by a strip chart.\n"
20876  "\n"
20877  " Redacted form: plstripd(id)\n"
20878  "\n"
20879  " This function is used in example 17.\n"
20880  "\n"
20881  "\n"
20882  "\n"
20883  "SYNOPSIS:\n"
20884  "\n"
20885  "plstripd(id)\n"
20886  "\n"
20887  "ARGUMENTS:\n"
20888  "\n"
20889  " id (PLINT, input) : Identification number of strip chart to delete.\n"
20890  "\n"
20891  ""},
20892  { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
20893  "Set line style\n"
20894  "\n"
20895  "DESCRIPTION:\n"
20896  "\n"
20897  " This sets up the line style for all lines subsequently drawn. A line\n"
20898  " consists of segments in which the pen is alternately down and up. The\n"
20899  " lengths of these segments are passed in the vectors mark and space\n"
20900  " respectively. The number of mark-space pairs is specified by nms. In\n"
20901  " order to return the line style to the default continuous line, plstyl\n"
20902  " should be called with nms =0 .(see also pllsty)\n"
20903  "\n"
20904  " Redacted form: plstyl(mark, space)\n"
20905  "\n"
20906  " This function is used in examples 1, 9, and 14.\n"
20907  "\n"
20908  "\n"
20909  "\n"
20910  "SYNOPSIS:\n"
20911  "\n"
20912  "plstyl(nms, mark, space)\n"
20913  "\n"
20914  "ARGUMENTS:\n"
20915  "\n"
20916  " nms (PLINT, input) : The number of mark and space elements in a\n"
20917  " line. Thus a simple broken line can be obtained by setting nms=1\n"
20918  " . A continuous line is specified by setting nms=0 .\n"
20919  "\n"
20920  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
20921  " segments during which the pen is down, measured in micrometers.\n"
20922  "\n"
20923  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
20924  " the segments during which the pen is up, measured in micrometers.\n"
20925  "\n"
20926  ""},
20927  { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
20928  "Set arrow style for vector plots\n"
20929  "\n"
20930  "DESCRIPTION:\n"
20931  "\n"
20932  " Set the style for the arrow used by plvect to plot vectors.\n"
20933  "\n"
20934  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20935  "\n"
20936  " This function is used in example 22.\n"
20937  "\n"
20938  "\n"
20939  "\n"
20940  "SYNOPSIS:\n"
20941  "\n"
20942  "plsvect(arrowx, arrowy, npts, fill)\n"
20943  "\n"
20944  "ARGUMENTS:\n"
20945  "\n"
20946  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
20947  " the x and y points which make up the arrow. The arrow is plotted\n"
20948  " by joining these points to form a polygon. The scaling assumes\n"
20949  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
20950  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
20951  " will be reset to its default.\n"
20952  "\n"
20953  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
20954  " arrowy.\n"
20955  "\n"
20956  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
20957  " fill is false then the arrow is open.\n"
20958  "\n"
20959  ""},
20960  { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
20961  "Specify viewport in absolute coordinates\n"
20962  "\n"
20963  "DESCRIPTION:\n"
20964  "\n"
20965  " Alternate routine to plvpor for setting up the viewport. This routine\n"
20966  " should be used only if the viewport is required to have a definite\n"
20967  " size in millimeters. The routine plgspa is useful for finding out the\n"
20968  " size of the current subpage.\n"
20969  "\n"
20970  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20971  "\n"
20972  " This function is used in example 10.\n"
20973  "\n"
20974  "\n"
20975  "\n"
20976  "SYNOPSIS:\n"
20977  "\n"
20978  "plsvpa(xmin, xmax, ymin, ymax)\n"
20979  "\n"
20980  "ARGUMENTS:\n"
20981  "\n"
20982  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20983  " viewport from the left-hand edge of the subpage in millimeters.\n"
20984  "\n"
20985  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20986  " viewport from the left-hand edge of the subpage in millimeters.\n"
20987  "\n"
20988  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20989  " viewport from the bottom edge of the subpage in millimeters.\n"
20990  "\n"
20991  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20992  " from the bottom edge of the subpage in millimeters.\n"
20993  "\n"
20994  ""},
20995  { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
20996  "Set x axis parameters\n"
20997  "\n"
20998  "DESCRIPTION:\n"
20999  "\n"
21000  " Sets values of the digmax and digits flags for the x axis. See the\n"
21001  " PLplot documentation for more information.\n"
21002  "\n"
21003  " Redacted form: plsxax(digmax, digits)\n"
21004  "\n"
21005  " This function is used in example 31.\n"
21006  "\n"
21007  "\n"
21008  "\n"
21009  "SYNOPSIS:\n"
21010  "\n"
21011  "plsxax(digmax, digits)\n"
21012  "\n"
21013  "ARGUMENTS:\n"
21014  "\n"
21015  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21016  " digits for the x axis. If nonzero, the printed label will be\n"
21017  " switched to a floating-point representation when the number of\n"
21018  " digits exceeds digmax.\n"
21019  "\n"
21020  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21021  " its value here has no effect since it is set only by plbox or\n"
21022  " plbox3. However, the user may obtain its value after a call to\n"
21023  " either of these functions by calling plgxax.\n"
21024  "\n"
21025  ""},
21026  { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21027  "Set y axis parameters\n"
21028  "\n"
21029  "DESCRIPTION:\n"
21030  "\n"
21031  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21032  " the description of plsxax for more detail.\n"
21033  "\n"
21034  " Redacted form: plsyax(digmax, digits)\n"
21035  "\n"
21036  " This function is used in examples 1, 14, and 31.\n"
21037  "\n"
21038  "\n"
21039  "\n"
21040  "SYNOPSIS:\n"
21041  "\n"
21042  "plsyax(digmax, digits)\n"
21043  "\n"
21044  "ARGUMENTS:\n"
21045  "\n"
21046  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21047  " digits for the y axis. If nonzero, the printed label will be\n"
21048  " switched to a floating-point representation when the number of\n"
21049  " digits exceeds digmax.\n"
21050  "\n"
21051  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21052  " its value here has no effect since it is set only by plbox or\n"
21053  " plbox3. However, the user may obtain its value after a call to\n"
21054  " either of these functions by calling plgyax.\n"
21055  "\n"
21056  ""},
21057  { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21058  "Plot a glyph at the specified points\n"
21059  "\n"
21060  "DESCRIPTION:\n"
21061  "\n"
21062  " Plot a glyph at the specified points. (This function is largely\n"
21063  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21064  "\n"
21065  " Redacted form: plsym(x, y, code)\n"
21066  "\n"
21067  " This function is used in example 7.\n"
21068  "\n"
21069  "\n"
21070  "\n"
21071  "SYNOPSIS:\n"
21072  "\n"
21073  "plsym(n, x, y, code)\n"
21074  "\n"
21075  "ARGUMENTS:\n"
21076  "\n"
21077  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21078  "\n"
21079  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21080  " the points.\n"
21081  "\n"
21082  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21083  " the points.\n"
21084  "\n"
21085  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21086  " to be plotted at each of the n points.\n"
21087  "\n"
21088  ""},
21089  { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21090  "Set z axis parameters\n"
21091  "\n"
21092  "DESCRIPTION:\n"
21093  "\n"
21094  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21095  " the description of plsxax for more detail.\n"
21096  "\n"
21097  " Redacted form: plszax(digmax, digits)\n"
21098  "\n"
21099  " This function is used in example 31.\n"
21100  "\n"
21101  "\n"
21102  "\n"
21103  "SYNOPSIS:\n"
21104  "\n"
21105  "plszax(digmax, digits)\n"
21106  "\n"
21107  "ARGUMENTS:\n"
21108  "\n"
21109  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21110  " digits for the z axis. If nonzero, the printed label will be\n"
21111  " switched to a floating-point representation when the number of\n"
21112  " digits exceeds digmax.\n"
21113  "\n"
21114  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21115  " its value here has no effect since it is set only by plbox or\n"
21116  " plbox3. However, the user may obtain its value after a call to\n"
21117  " either of these functions by calling plgzax.\n"
21118  "\n"
21119  ""},
21120  { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21121  "Switch to text screen\n"
21122  "\n"
21123  "DESCRIPTION:\n"
21124  "\n"
21125  " Sets an interactive device to text mode, used in conjunction with\n"
21126  " plgra to allow graphics and text to be interspersed. On a device\n"
21127  " which supports separate text and graphics windows, this command causes\n"
21128  " control to be switched to the text window. This can be useful for\n"
21129  " printing diagnostic messages or getting user input, which would\n"
21130  " otherwise interfere with the plots. The program must switch back to\n"
21131  " the graphics window before issuing plot commands, as the text (or\n"
21132  " console) device will probably become quite confused otherwise. If\n"
21133  " already in text mode, this command is ignored. It is also ignored on\n"
21134  " devices which only support a single window or use a different method\n"
21135  " for shifting focus (see also plgra).\n"
21136  "\n"
21137  " Redacted form: pltext()\n"
21138  "\n"
21139  " This function is used in example 1.\n"
21140  "\n"
21141  "\n"
21142  "\n"
21143  "SYNOPSIS:\n"
21144  "\n"
21145  "pltext()\n"
21146  "\n"
21147  ""},
21148  { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21149  "Set format for date / time labels\n"
21150  "\n"
21151  "DESCRIPTION:\n"
21152  "\n"
21153  " Sets the format for date / time labels. To enable date / time format\n"
21154  " labels see the options to plbox, plbox3, and plenv.\n"
21155  "\n"
21156  " Redacted form: pltimefmt(fmt)\n"
21157  "\n"
21158  " This function is used in example 29.\n"
21159  "\n"
21160  "\n"
21161  "\n"
21162  "SYNOPSIS:\n"
21163  "\n"
21164  "pltimefmt(fmt)\n"
21165  "\n"
21166  "ARGUMENTS:\n"
21167  "\n"
21168  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21169  " interpreted similarly to the format specifier of typical system\n"
21170  " strftime routines except that PLplot ignores locale and also\n"
21171  " supplies some useful extensions in the context of plotting. All\n"
21172  " text in the string is printed as-is other than conversion\n"
21173  " specifications which take the form of a '%' character followed by\n"
21174  " further conversion specification character. The conversion\n"
21175  " specifications which are similar to those provided by system\n"
21176  " strftime routines are the following: %a: The abbreviated (English)\n"
21177  " weekday name.\n"
21178  " %A: The full (English) weekday name.\n"
21179  " %b: The abbreviated (English) month name.\n"
21180  " %B: The full (English) month name.\n"
21181  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21182  " %C: The century number (year/100) as a 2-digit integer.\n"
21183  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21184  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21185  " %e: Like %d, but a leading zero is replaced by a space.\n"
21186  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21187  " %h: Equivalent to %b.\n"
21188  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21189  " 00 to 23).\n"
21190  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21191  " 01 to 12).\n"
21192  " %j: The day of the year as a decimal number (range 001 to\n"
21193  " 366).\n"
21194  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21195  " 23); single digits are preceded by a blank. (See also %H.)\n"
21196  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21197  " 12); single digits are preceded by a blank. (See also %I.)\n"
21198  " %m: The month as a decimal number (range 01 to 12).\n"
21199  " %M: The minute as a decimal number (range 00 to 59).\n"
21200  " %n: A newline character.\n"
21201  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21202  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21203  " %r: Equivalent to %I:%M:%S %p.\n"
21204  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21205  " including the seconds, see %T below.\n"
21206  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21207  " +0000 (UTC).\n"
21208  " %S: The second as a decimal number (range 00 to 60). (The\n"
21209  " range is up to 60 to allow for occasional leap seconds.)\n"
21210  " %t: A tab character.\n"
21211  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21212  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21213  " being 1. See also %w.\n"
21214  " %U: The week number of the current year as a decimal number,\n"
21215  " range 00 to 53, starting with the first Sunday as the first\n"
21216  " day of week 01. See also %V and %W.\n"
21217  " %v: Equivalent to %e-%b-%Y.\n"
21218  " %V: The ISO 8601 week number of the current year as a decimal\n"
21219  " number, range 01 to 53, where week 1 is the first week that\n"
21220  " has at least 4 days in the new year. See also %U and %W.\n"
21221  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21222  " being 0. See also %u.\n"
21223  " %W: The week number of the current year as a decimal number,\n"
21224  " range 00 to 53, starting with the first Monday as the first\n"
21225  " day of week 01.\n"
21226  " %x: Equivalent to %a %b %d %Y.\n"
21227  " %X: Equivalent to %T.\n"
21228  " %y: The year as a decimal number without a century (range 00\n"
21229  " to 99).\n"
21230  " %Y: The year as a decimal number including a century.\n"
21231  " %z: The UTC time-zone string = \"+0000\".\n"
21232  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21233  " %+: The UTC date and time in default format of the Unix date\n"
21234  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21235  " %%: A literal \"%\" character.\n"
21236  " The conversion specifications which are extensions to those normally\n"
21237  " provided by system strftime routines are the following: %(0-9):\n"
21238  " The fractional part of the seconds field (including leading\n"
21239  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21240  " seconds to millisecond accuracy (00.000).\n"
21241  " %.: The fractional part of the seconds field (including\n"
21242  " leading decimal point) to the maximum available accuracy. Thus\n"
21243  " %S%. would give seconds with fractional part up to 9 decimal\n"
21244  " places if available.\n"
21245  "\n"
21246  ""},
21247  { "plvasp", _wrap_plvasp, METH_O, "\n"
21248  "Specify viewport using aspect ratio only\n"
21249  "\n"
21250  "DESCRIPTION:\n"
21251  "\n"
21252  " Selects the largest viewport with the given aspect ratio within the\n"
21253  " subpage that leaves a standard margin (left-hand margin of eight\n"
21254  " character heights, and a margin around the other three sides of five\n"
21255  " character heights).\n"
21256  "\n"
21257  " Redacted form: plvasp(aspect)\n"
21258  "\n"
21259  " This function is used in example 13.\n"
21260  "\n"
21261  "\n"
21262  "\n"
21263  "SYNOPSIS:\n"
21264  "\n"
21265  "plvasp(aspect)\n"
21266  "\n"
21267  "ARGUMENTS:\n"
21268  "\n"
21269  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21270  " axis of resulting viewport.\n"
21271  "\n"
21272  ""},
21273  { "plvect", _wrap_plvect, METH_VARARGS, "\n"
21274  "Vector plot\n"
21275  "\n"
21276  "DESCRIPTION:\n"
21277  "\n"
21278  " Draws a plot of vector data contained in the matrices (\n"
21279  " u[\n"
21280  " nx][\n"
21281  " ny],\n"
21282  " v[\n"
21283  " nx][\n"
21284  " ny]) . The scaling factor for the vectors is given by scale. A\n"
21285  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21286  " additional data required by the transformation routine to map indices\n"
21287  " within the matrices to the world coordinates. The style of the vector\n"
21288  " arrow may be set using plsvect.\n"
21289  "\n"
21290  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21291  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21292  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21293  " with either one or two dimensions.\n"
21294  "\n"
21295  " This function is used in example 22.\n"
21296  "\n"
21297  "\n"
21298  "\n"
21299  "SYNOPSIS:\n"
21300  "\n"
21301  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21302  "\n"
21303  "ARGUMENTS:\n"
21304  "\n"
21305  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21306  " and y components of the vector data to be plotted.\n"
21307  "\n"
21308  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21309  "\n"
21310  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21311  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21312  " automatically calculated for the data. If scale < 0 then the\n"
21313  " scaling factor is automatically calculated for the data and then\n"
21314  " multiplied by -\n"
21315  " scale. If scale > 0 then the scaling factor is set to scale.\n"
21316  "\n"
21317  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21318  " defines the transformation between the zero-based indices of the\n"
21319  " matrices u and v and world coordinates.For the C case,\n"
21320  " transformation functions are provided in the PLplot library: pltr0\n"
21321  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21322  " mappings respectively defined by vectors and matrices. In\n"
21323  " addition, C callback routines for the transformation can be\n"
21324  " supplied by the user such as the mypltr function in\n"
21325  " examples/c/x09c.c which provides a general linear transformation\n"
21326  " between index coordinates and world coordinates.For languages\n"
21327  " other than C you should consult the PLplot documentation for the\n"
21328  " details concerning how PLTRANSFORM_callback arguments are\n"
21329  " interfaced. However, in general, a particular pattern of\n"
21330  " callback-associated arguments such as a tr vector with 6 elements;\n"
21331  " xg and yg vectors; or xg and yg matrices are respectively\n"
21332  " interfaced to a linear-transformation routine similar to the above\n"
21333  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21334  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21335  " support native language callbacks for handling index to\n"
21336  " world-coordinate transformations. Examples of these various\n"
21337  " approaches are given in examples/<language>x09*,\n"
21338  " examples/<language>x16*, examples/<language>x20*,\n"
21339  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21340  " supported languages.\n"
21341  "\n"
21342  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21343  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
21344  " that is externally supplied.\n"
21345  "\n"
21346  ""},
21347  { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
21348  "Specify viewport using coordinates and aspect ratio\n"
21349  "\n"
21350  "DESCRIPTION:\n"
21351  "\n"
21352  " Device-independent routine for setting up the viewport. The viewport\n"
21353  " is chosen to be the largest with the given aspect ratio that fits\n"
21354  " within the specified region (in terms of normalized subpage\n"
21355  " coordinates). This routine is functionally equivalent to plvpor when\n"
21356  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21357  " routine reserves no extra space at the edges for labels.\n"
21358  "\n"
21359  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21360  "\n"
21361  " This function is used in example 9.\n"
21362  "\n"
21363  "\n"
21364  "\n"
21365  "SYNOPSIS:\n"
21366  "\n"
21367  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21368  "\n"
21369  "ARGUMENTS:\n"
21370  "\n"
21371  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21372  " left-hand edge of the viewport.\n"
21373  "\n"
21374  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21375  " right-hand edge of the viewport.\n"
21376  "\n"
21377  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21378  " bottom edge of the viewport.\n"
21379  "\n"
21380  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21381  " edge of the viewport.\n"
21382  "\n"
21383  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21384  " axis.\n"
21385  "\n"
21386  ""},
21387  { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
21388  "Specify viewport using normalized subpage coordinates\n"
21389  "\n"
21390  "DESCRIPTION:\n"
21391  "\n"
21392  " Device-independent routine for setting up the viewport. This defines\n"
21393  " the viewport in terms of normalized subpage coordinates which run from\n"
21394  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21395  " current subpage. Use the alternate routine plsvpa in order to create\n"
21396  " a viewport of a definite size.\n"
21397  "\n"
21398  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21399  "\n"
21400  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
21401  " 24, 26, 27, and 31.\n"
21402  "\n"
21403  "\n"
21404  "\n"
21405  "SYNOPSIS:\n"
21406  "\n"
21407  "plvpor(xmin, xmax, ymin, ymax)\n"
21408  "\n"
21409  "ARGUMENTS:\n"
21410  "\n"
21411  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21412  " left-hand edge of the viewport.\n"
21413  "\n"
21414  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21415  " right-hand edge of the viewport.\n"
21416  "\n"
21417  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21418  " bottom edge of the viewport.\n"
21419  "\n"
21420  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21421  " edge of the viewport.\n"
21422  "\n"
21423  ""},
21424  { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
21425  "Select standard viewport\n"
21426  "\n"
21427  "DESCRIPTION:\n"
21428  "\n"
21429  " Selects the largest viewport within the subpage that leaves a standard\n"
21430  " margin (left-hand margin of eight character heights, and a margin\n"
21431  " around the other three sides of five character heights).\n"
21432  "\n"
21433  " Redacted form: plvsta()\n"
21434  "\n"
21435  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
21436  "\n"
21437  "\n"
21438  "\n"
21439  "SYNOPSIS:\n"
21440  "\n"
21441  "plvsta()\n"
21442  "\n"
21443  ""},
21444  { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
21445  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
21446  "\n"
21447  "DESCRIPTION:\n"
21448  "\n"
21449  " Configure the transformations required for projecting a 3D surface on\n"
21450  " an existing 2D window. Those transformations (see the PLplot\n"
21451  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
21452  " surface which has its limits expressed in 3D world coordinates and\n"
21453  " also normalized 3D coordinates (used for interpreting the altitude and\n"
21454  " azimuth of the viewing angle). The transformations consist of the\n"
21455  " linear transform from 3D world coordinates to normalized 3D\n"
21456  " coordinates, and the 3D rotation of normalized coordinates required to\n"
21457  " align the pole of the new 3D coordinate system with the viewing\n"
21458  " direction specified by altitude and azimuth so that x and y of the\n"
21459  " surface elements in that transformed coordinate system are the\n"
21460  " projection of the 3D surface with given viewing direction on the 2D\n"
21461  " window.\n"
21462  "\n"
21463  " The enclosing rectangular cuboid for the surface plot is defined by\n"
21464  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
21465  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
21466  " sizes of basex by basey by height so that xmin maps to -\n"
21467  " basex/2, xmax maps to basex/2, ymin maps to -\n"
21468  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21469  " The resulting rectangular cuboid in normalized coordinates is then\n"
21470  " viewed by an observer at altitude alt and azimuth az. This routine\n"
21471  " must be called before plbox3 or any of the 3D surface plotting\n"
21472  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
21473  " plsurf3dl or plfill3.\n"
21474  "\n"
21475  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21476  " zmin, zmax, alt, az)\n"
21477  "\n"
21478  " This function is examples 8, 11, 18, and 21.\n"
21479  "\n"
21480  "\n"
21481  "\n"
21482  "SYNOPSIS:\n"
21483  "\n"
21484  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21485  "\n"
21486  "ARGUMENTS:\n"
21487  "\n"
21488  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
21489  " rectangular cuboid.\n"
21490  "\n"
21491  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
21492  " rectangular cuboid.\n"
21493  "\n"
21494  " height (PLFLT, input) : The normalized z coordinate size of the\n"
21495  " rectangular cuboid.\n"
21496  "\n"
21497  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
21498  " rectangular cuboid.\n"
21499  "\n"
21500  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
21501  " rectangular cuboid.\n"
21502  "\n"
21503  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
21504  " rectangular cuboid.\n"
21505  "\n"
21506  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
21507  " rectangular cuboid.\n"
21508  "\n"
21509  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
21510  " rectangular cuboid.\n"
21511  "\n"
21512  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
21513  " rectangular cuboid.\n"
21514  "\n"
21515  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
21516  " plane of the rectangular cuboid in normalized coordinates.\n"
21517  "\n"
21518  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
21519  " rectangular cuboid in normalized coordinates. When az=0, the\n"
21520  " observer is looking face onto the zx plane of the rectangular\n"
21521  " cuboid in normalized coordinates, and as az is increased, the\n"
21522  " observer moves clockwise around that cuboid when viewed from above\n"
21523  " the xy plane.\n"
21524  "\n"
21525  ""},
21526  { "plwidth", _wrap_plwidth, METH_O, "\n"
21527  "Set pen width\n"
21528  "\n"
21529  "DESCRIPTION:\n"
21530  "\n"
21531  " Sets the pen width.\n"
21532  "\n"
21533  " Redacted form: plwidth(width)\n"
21534  "\n"
21535  " This function is used in examples 1 and 2.\n"
21536  "\n"
21537  "\n"
21538  "\n"
21539  "SYNOPSIS:\n"
21540  "\n"
21541  "plwidth(width)\n"
21542  "\n"
21543  "ARGUMENTS:\n"
21544  "\n"
21545  " width (PLFLT, input) : The desired pen width. If width is negative\n"
21546  " or the same as the previous value no action is taken. width = 0.\n"
21547  " should be interpreted as as the minimum valid pen width for the\n"
21548  " device. The interpretation of positive width values is also\n"
21549  " device dependent.\n"
21550  "\n"
21551  ""},
21552  { "plwind", _wrap_plwind, METH_VARARGS, "\n"
21553  "Specify window\n"
21554  "\n"
21555  "DESCRIPTION:\n"
21556  "\n"
21557  " Specify the window, i.e., the world coordinates of the edges of the\n"
21558  " viewport.\n"
21559  "\n"
21560  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21561  "\n"
21562  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
21563  " 29, and 31.\n"
21564  "\n"
21565  "\n"
21566  "\n"
21567  "SYNOPSIS:\n"
21568  "\n"
21569  "plwind(xmin, xmax, ymin, ymax)\n"
21570  "\n"
21571  "ARGUMENTS:\n"
21572  "\n"
21573  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21574  " of the viewport.\n"
21575  "\n"
21576  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21577  " of the viewport.\n"
21578  "\n"
21579  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21580  " the viewport.\n"
21581  "\n"
21582  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21583  " viewport.\n"
21584  "\n"
21585  ""},
21586  { "plxormod", _wrap_plxormod, METH_O, "\n"
21587  "Enter or leave xor mode\n"
21588  "\n"
21589  "DESCRIPTION:\n"
21590  "\n"
21591  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21592  " those drivers (e.g., the xwin driver) that support it. Enables\n"
21593  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21594  " is not capable of xor operation it returns a status of false.\n"
21595  "\n"
21596  " Redacted form: plxormod(mode, status)\n"
21597  "\n"
21598  " This function is used in examples 1 and 20.\n"
21599  "\n"
21600  "\n"
21601  "\n"
21602  "SYNOPSIS:\n"
21603  "\n"
21604  "plxormod(mode, status)\n"
21605  "\n"
21606  "ARGUMENTS:\n"
21607  "\n"
21608  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21609  " is false means leave xor mode.\n"
21610  "\n"
21611  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
21612  " modestatus of true (false) means driver is capable (incapable) of\n"
21613  " xor mode.\n"
21614  "\n"
21615  ""},
21616  { "plmap", _wrap_plmap, METH_VARARGS, "\n"
21617  "Plot continental outline or shapefile data in world coordinates\n"
21618  "\n"
21619  "DESCRIPTION:\n"
21620  "\n"
21621  " Plots continental outlines or shapefile data in world coordinates. A\n"
21622  " demonstration of how to use this function to create different\n"
21623  " projections can be found in examples/c/x19c. PLplot is provided with\n"
21624  " basic coastal outlines and USA state borders. To use the map\n"
21625  " functionality PLplot must be compiled with the shapelib library.\n"
21626  " Shapefiles have become a popular standard for geographical data and\n"
21627  " data in this format can be easily found from a number of online\n"
21628  " sources. Shapefile data is actually provided as three or more files\n"
21629  " with the same filename, but different extensions. The .shp and .shx\n"
21630  " files are required for plotting Shapefile data with PLplot.\n"
21631  "\n"
21632  " PLplot currently supports the point, multipoint, polyline and polygon\n"
21633  " objects within shapefiles. However holes in polygons are not\n"
21634  " supported. When plmap is used the type of object is derived from the\n"
21635  " shapefile, if you wish to override the type then use one of the other\n"
21636  " plmap variants. The built in maps have line data only.\n"
21637  "\n"
21638  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21639  "\n"
21640  " This function is used in example 19.\n"
21641  "\n"
21642  "\n"
21643  "\n"
21644  "SYNOPSIS:\n"
21645  "\n"
21646  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21647  "\n"
21648  "ARGUMENTS:\n"
21649  "\n"
21650  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21651  " transform the original map data coordinates to a new coordinate\n"
21652  " system. The PLplot-supplied map data is provided as latitudes and\n"
21653  " longitudes; other Shapefile data may be provided in other\n"
21654  " coordinate systems as can be found in their .prj plain text files.\n"
21655  " For example, by using this transform we can change from a\n"
21656  " longitude, latitude coordinate to a polar stereographic\n"
21657  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
21658  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
21659  " corresponding y coordinates (latitudes for the PLplot supplied\n"
21660  " data). After the call to mapform(), x[] and y[] should be\n"
21661  " replaced by the corresponding plot coordinates. If no transform is\n"
21662  " desired, mapform can be replaced by NULL.\n"
21663  "\n"
21664  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21665  " the type of map plotted. This is either one of the PLplot built-in\n"
21666  " maps or the file name of a set of Shapefile files without the file\n"
21667  " extensions. For the PLplot built-in maps the possible values are:\n"
21668  " \"globe\" -- continental outlines\n"
21669  " \"usa\" -- USA and state boundaries\n"
21670  " \"cglobe\" -- continental outlines and countries\n"
21671  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
21672  "\n"
21673  "\n"
21674  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21675  " drawn. The units must match the shapefile (built in maps are\n"
21676  " degrees lat/lon). Objects in the file which do not encroach on the\n"
21677  " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
21678  " note this is simply an optimisation, not a clipping so for objects\n"
21679  " with some points inside the box and some points outside the box\n"
21680  " all the points will be rendered. These parameters also define\n"
21681  " latitude and longitude wrapping for shapefiles using these units.\n"
21682  " Longitude points will be wrapped by integer multiples of 360\n"
21683  " degrees to place them in the box. This allows the same data to be\n"
21684  " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
21685  " you plot from -180-540 you will get two cycles of data drawn. The\n"
21686  " value of minx must be less than the value of maxx. Passing in a\n"
21687  " nan, max/-max floating point number or +/-infinity will case the\n"
21688  " bounding box from the shapefile to be used.\n"
21689  "\n"
21690  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21691  " drawn - see minx.\n"
21692  "\n"
21693  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21694  " drawn - see minx.\n"
21695  "\n"
21696  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21697  " drawn - see minx.\n"
21698  "\n"
21699  ""},
21700  { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
21701  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
21702  "\n"
21703  "DESCRIPTION:\n"
21704  "\n"
21705  " Plot all or a subset of Shapefile data using lines in world\n"
21706  " coordinates. Our 19th standard example demonstrates how to use this\n"
21707  " function. This function plots data from a Shapefile using lines as in\n"
21708  " plmap, however it also has the option of also only drawing specified\n"
21709  " elements from the Shapefile. The vector of indices of the required\n"
21710  " elements are passed as a function argument. The Shapefile data should\n"
21711  " include a metadata file (extension.dbf) listing all items within the\n"
21712  " Shapefile. This file can be opened by most popular spreadsheet\n"
21713  " programs and can be used to decide which indices to pass to this\n"
21714  " function.\n"
21715  "\n"
21716  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21717  " plotentries)\n"
21718  "\n"
21719  " This function is used in example 19.\n"
21720  "\n"
21721  "\n"
21722  "\n"
21723  "SYNOPSIS:\n"
21724  "\n"
21725  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21726  "\n"
21727  "ARGUMENTS:\n"
21728  "\n"
21729  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21730  " transform the coordinates given in the shapefile into a plot\n"
21731  " coordinate system. By using this transform, we can change from a\n"
21732  " longitude, latitude coordinate to a polar stereographic project,\n"
21733  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21734  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21735  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21736  " plot coordinates. If no transform is desired, mapform can be\n"
21737  " replaced by NULL.\n"
21738  "\n"
21739  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21740  " the file name of a set of Shapefile files without the file\n"
21741  " extension.\n"
21742  "\n"
21743  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21744  " be in the same units as used by the Shapefile. You could use a\n"
21745  " very large negative number to plot everything, but you can improve\n"
21746  " performance by limiting the area drawn. The units must match those\n"
21747  " of the Shapefile projection, which may be for example longitude or\n"
21748  " distance. The value of minx must be less than the value of maxx.\n"
21749  "\n"
21750  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21751  " use a very large number to plot everything, but you can improve\n"
21752  " performance by limiting the area drawn.\n"
21753  "\n"
21754  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21755  " be in the same units as used by the Shapefile. You could use a\n"
21756  " very large negative number to plot everything, but you can improve\n"
21757  " performance by limiting the area drawn. The units must match those\n"
21758  " of the Shapefile projection, which may be for example latitude or\n"
21759  " distance. The value of miny must be less than the value of maxy.\n"
21760  "\n"
21761  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21762  " use a very large number to plot everything, but you can improve\n"
21763  " performance by limiting the area drawn.\n"
21764  "\n"
21765  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21766  " zero-based indices of the Shapefile elements which will be drawn.\n"
21767  " Setting\n"
21768  " plotentries to NULL will plot all elements of the Shapefile.\n"
21769  "\n"
21770  " nplotentries (PLINT, input) : The number of items in\n"
21771  " plotentries. Ignored if\n"
21772  " plotentries is NULL.\n"
21773  "\n"
21774  ""},
21775  { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
21776  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
21777  "\n"
21778  "DESCRIPTION:\n"
21779  "\n"
21780  " As per plmapline, however the items are plotted as strings or points\n"
21781  " in the same way as plstring.\n"
21782  "\n"
21783  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
21784  " maxy, plotentries)\n"
21785  "\n"
21786  " This function is not used in any examples.\n"
21787  "\n"
21788  "\n"
21789  "\n"
21790  "SYNOPSIS:\n"
21791  "\n"
21792  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21793  "\n"
21794  "ARGUMENTS:\n"
21795  "\n"
21796  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21797  " transform the coordinates given in the shapefile into a plot\n"
21798  " coordinate system. By using this transform, we can change from a\n"
21799  " longitude, latitude coordinate to a polar stereographic project,\n"
21800  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21801  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21802  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21803  " plot coordinates. If no transform is desired, mapform can be\n"
21804  " replaced by NULL.\n"
21805  "\n"
21806  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21807  " the file name of a set of Shapefile files without the file\n"
21808  " extension.\n"
21809  "\n"
21810  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
21811  " drawn.\n"
21812  "\n"
21813  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21814  " be in the same units as used by the Shapefile. You could use a\n"
21815  " very large negative number to plot everything, but you can improve\n"
21816  " performance by limiting the area drawn. The units must match those\n"
21817  " of the Shapefile projection, which may be for example longitude or\n"
21818  " distance. The value of minx must be less than the value of maxx.\n"
21819  "\n"
21820  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21821  " use a very large number to plot everything, but you can improve\n"
21822  " performance by limiting the area drawn.\n"
21823  "\n"
21824  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21825  " be in the same units as used by the Shapefile. You could use a\n"
21826  " very large negative number to plot everything, but you can improve\n"
21827  " performance by limiting the area drawn. The units must match those\n"
21828  " of the Shapefile projection, which may be for example latitude or\n"
21829  " distance. The value of miny must be less than the value of maxy.\n"
21830  "\n"
21831  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21832  " use a very large number to plot everything, but you can improve\n"
21833  " performance by limiting the area drawn.\n"
21834  "\n"
21835  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21836  " zero-based indices of the Shapefile elements which will be drawn.\n"
21837  " Setting\n"
21838  " plotentries to NULL will plot all elements of the Shapefile.\n"
21839  "\n"
21840  " nplotentries (PLINT, input) : The number of items in\n"
21841  " plotentries. Ignored if\n"
21842  " plotentries is NULL.\n"
21843  "\n"
21844  ""},
21845  { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
21846  "Draw text at points defined by Shapefile data in world coordinates\n"
21847  "\n"
21848  "DESCRIPTION:\n"
21849  "\n"
21850  " As per plmapline, however the items are plotted as text in the same\n"
21851  " way as plptex.\n"
21852  "\n"
21853  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
21854  " miny, maxy, plotentry)\n"
21855  "\n"
21856  " This function is used in example 19.\n"
21857  "\n"
21858  "\n"
21859  "\n"
21860  "SYNOPSIS:\n"
21861  "\n"
21862  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
21863  "\n"
21864  "ARGUMENTS:\n"
21865  "\n"
21866  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21867  " transform the coordinates given in the shapefile into a plot\n"
21868  " coordinate system. By using this transform, we can change from a\n"
21869  " longitude, latitude coordinate to a polar stereographic project,\n"
21870  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21871  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21872  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21873  " plot coordinates. If no transform is desired, mapform can be\n"
21874  " replaced by NULL.\n"
21875  "\n"
21876  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21877  " the file name of a set of Shapefile files without the file\n"
21878  " extension.\n"
21879  "\n"
21880  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
21881  " dy/dx.\n"
21882  "\n"
21883  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
21884  " dy/dx.\n"
21885  "\n"
21886  " just (PLFLT, input) : Set the justification of the text. The value\n"
21887  " given will be the fraction of the distance along the string that\n"
21888  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
21889  " centralized text and 1.0 gives right aligned text.\n"
21890  "\n"
21891  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
21892  "\n"
21893  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21894  " be in the same units as used by the Shapefile. You could use a\n"
21895  " very large negative number to plot everything, but you can improve\n"
21896  " performance by limiting the area drawn. The units must match those\n"
21897  " of the Shapefile projection, which may be for example longitude or\n"
21898  " distance. The value of minx must be less than the value of maxx.\n"
21899  "\n"
21900  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21901  " use a very large number to plot everything, but you can improve\n"
21902  " performance by limiting the area drawn.\n"
21903  "\n"
21904  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21905  " be in the same units as used by the Shapefile. You could use a\n"
21906  " very large negative number to plot everything, but you can improve\n"
21907  " performance by limiting the area drawn. The units must match those\n"
21908  " of the Shapefile projection, which may be for example latitude or\n"
21909  " distance. The value of miny must be less than the value of maxy.\n"
21910  "\n"
21911  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21912  " use a very large number to plot everything, but you can improve\n"
21913  " performance by limiting the area drawn.\n"
21914  "\n"
21915  " plotentry (PLINT, input) : An integer indicating which text string\n"
21916  " of the Shapefile (zero indexed) will be drawn.\n"
21917  "\n"
21918  ""},
21919  { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
21920  "Plot all or a subset of Shapefile data, filling the polygons\n"
21921  "\n"
21922  "DESCRIPTION:\n"
21923  "\n"
21924  " As per plmapline, however the items are filled in the same way as\n"
21925  " plfill.\n"
21926  "\n"
21927  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
21928  " plotentries)\n"
21929  "\n"
21930  " This function is used in example 19.\n"
21931  "\n"
21932  "\n"
21933  "\n"
21934  "SYNOPSIS:\n"
21935  "\n"
21936  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21937  "\n"
21938  "ARGUMENTS:\n"
21939  "\n"
21940  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21941  " transform the coordinates given in the shapefile into a plot\n"
21942  " coordinate system. By using this transform, we can change from a\n"
21943  " longitude, latitude coordinate to a polar stereographic project,\n"
21944  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21945  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21946  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21947  " plot coordinates. If no transform is desired, mapform can be\n"
21948  " replaced by NULL.\n"
21949  "\n"
21950  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21951  " the file name of a set of Shapefile files without the file\n"
21952  " extension.\n"
21953  "\n"
21954  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21955  " be in the same units as used by the Shapefile. You could use a\n"
21956  " very large negative number to plot everything, but you can improve\n"
21957  " performance by limiting the area drawn. The units must match those\n"
21958  " of the Shapefile projection, which may be for example longitude or\n"
21959  " distance. The value of minx must be less than the value of maxx.\n"
21960  "\n"
21961  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21962  " use a very large number to plot everything, but you can improve\n"
21963  " performance by limiting the area drawn.\n"
21964  "\n"
21965  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21966  " be in the same units as used by the Shapefile. You could use a\n"
21967  " very large negative number to plot everything, but you can improve\n"
21968  " performance by limiting the area drawn. The units must match those\n"
21969  " of the Shapefile projection, which may be for example latitude or\n"
21970  " distance. The value of miny must be less than the value of maxy.\n"
21971  "\n"
21972  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21973  " use a very large number to plot everything, but you can improve\n"
21974  " performance by limiting the area drawn.\n"
21975  "\n"
21976  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21977  " zero-based indices of the Shapefile elements which will be drawn.\n"
21978  " Setting\n"
21979  " plotentries to NULL will plot all elements of the Shapefile.\n"
21980  "\n"
21981  " nplotentries (PLINT, input) : The number of items in\n"
21982  " plotentries. Ignored if\n"
21983  " plotentries is NULL.\n"
21984  "\n"
21985  ""},
21986  { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
21987  "Plot latitude and longitude lines\n"
21988  "\n"
21989  "DESCRIPTION:\n"
21990  "\n"
21991  " Displays latitude and longitude on the current plot. The lines are\n"
21992  " plotted in the current color and line style.\n"
21993  "\n"
21994  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
21995  " minlat, maxlat)\n"
21996  "\n"
21997  " This function is used in example 19.\n"
21998  "\n"
21999  "\n"
22000  "\n"
22001  "SYNOPSIS:\n"
22002  "\n"
22003  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22004  "\n"
22005  "ARGUMENTS:\n"
22006  "\n"
22007  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22008  " transform the coordinate longitudes and latitudes to a plot\n"
22009  " coordinate system. By using this transform, we can change from a\n"
22010  " longitude, latitude coordinate to a polar stereographic project,\n"
22011  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22012  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22013  " mapform(), x[] and y[] should be replaced by the corresponding\n"
22014  " plot coordinates. If no transform is desired, mapform can be\n"
22015  " replaced by NULL.\n"
22016  "\n"
22017  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22018  " longitude lines are to be plotted.\n"
22019  "\n"
22020  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22021  " lines are to be plotted.\n"
22022  "\n"
22023  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22024  " side of the plot. The value of minlong must be less than the value\n"
22025  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22026  " equal to 360.\n"
22027  "\n"
22028  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22029  " side of the plot.\n"
22030  "\n"
22031  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22032  " background. One can always use -90.0 as the boundary outside the\n"
22033  " plot window will be automatically eliminated. However, the\n"
22034  " program will be faster if one can reduce the size of the\n"
22035  " background plotted.\n"
22036  "\n"
22037  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22038  " background. One can always use 90.0 as the boundary outside the\n"
22039  " plot window will be automatically eliminated.\n"
22040  "\n"
22041  ""},
22042  { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22043  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22044  "\n"
22045  "DESCRIPTION:\n"
22046  "\n"
22047  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22048  " automatically adjusted to use the maximum and minimum values in idata\n"
22049  " as valuemin and valuemax in a call to plimagefr.\n"
22050  "\n"
22051  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22052  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22053  "\n"
22054  "\n"
22055  " This function is used in example 20.\n"
22056  "\n"
22057  "\n"
22058  "\n"
22059  "SYNOPSIS:\n"
22060  "\n"
22061  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22062  "\n"
22063  "ARGUMENTS:\n"
22064  "\n"
22065  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22066  " to plot. Should have dimensions of\n"
22067  " nx by\n"
22068  " ny.\n"
22069  "\n"
22070  " nx, ny (PLINT, input) : Dimensions of idata\n"
22071  "\n"
22072  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22073  " are linearly transformed to these world coordinate ranges such\n"
22074  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22075  " - 1] corresponds to (xmax, ymax).\n"
22076  "\n"
22077  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22078  " (inclusive) will be plotted.\n"
22079  "\n"
22080  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22081  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22082  " Dymin) to (Dxmax, Dymax).\n"
22083  "\n"
22084  ""},
22085  { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22086  "Plot a 2D matrix using cmap1\n"
22087  "\n"
22088  "DESCRIPTION:\n"
22089  "\n"
22090  " Plot a 2D matrix using cmap1.\n"
22091  "\n"
22092  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22093  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22094  "\n"
22095  "\n"
22096  " This function is used in example 20.\n"
22097  "\n"
22098  "\n"
22099  "\n"
22100  "SYNOPSIS:\n"
22101  "\n"
22102  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22103  "\n"
22104  "ARGUMENTS:\n"
22105  "\n"
22106  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22107  " plot. Should have dimensions of\n"
22108  " nx by\n"
22109  " ny.\n"
22110  "\n"
22111  " nx, ny (PLINT, input) : Dimensions of idata\n"
22112  "\n"
22113  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22114  " pltr below for how these arguments are used (only for the special case\n"
22115  " when the callback function\n"
22116  " pltr is not supplied).\n"
22117  "\n"
22118  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22119  " (inclusive) will be plotted.\n"
22120  "\n"
22121  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22122  " values to use for value to color mappings. A datum equal to or\n"
22123  " less than valuemin will be plotted with color 0.0, while a datum\n"
22124  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22125  " Data between valuemin and valuemax map linearly to colors in the\n"
22126  " range (0.0-1.0).\n"
22127  "\n"
22128  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22129  " defines the transformation between the zero-based indices of the\n"
22130  " matrix idata and world coordinates. If\n"
22131  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22132  " indices of idata are mapped to the range\n"
22133  " xmin through\n"
22134  " xmax and the y indices of idata are mapped to the range\n"
22135  " ymin through\n"
22136  " ymax.For the C case, transformation functions are provided in the\n"
22137  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22138  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22139  " matrices. In addition, C callback routines for the transformation\n"
22140  " can be supplied by the user such as the mypltr function in\n"
22141  " examples/c/x09c.c which provides a general linear transformation\n"
22142  " between index coordinates and world coordinates.For languages\n"
22143  " other than C you should consult the PLplot documentation for the\n"
22144  " details concerning how PLTRANSFORM_callback arguments are\n"
22145  " interfaced. However, in general, a particular pattern of\n"
22146  " callback-associated arguments such as a tr vector with 6 elements;\n"
22147  " xg and yg vectors; or xg and yg matrices are respectively\n"
22148  " interfaced to a linear-transformation routine similar to the above\n"
22149  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22150  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22151  " support native language callbacks for handling index to\n"
22152  " world-coordinate transformations. Examples of these various\n"
22153  " approaches are given in examples/<language>x09*,\n"
22154  " examples/<language>x16*, examples/<language>x20*,\n"
22155  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22156  " supported languages.\n"
22157  "\n"
22158  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22159  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22160  " externally supplied.\n"
22161  "\n"
22162  ""},
22163  { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22164  { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22165  { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22166  { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22167  { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22168  { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22169  "Wait for graphics input event and translate to world coordinates.\n"
22170  "\n"
22171  "DESCRIPTION:\n"
22172  "\n"
22173  " Wait for graphics input event and translate to world coordinates.\n"
22174  " Returns 0 if no translation to world coordinates is possible.\n"
22175  "\n"
22176  " This function returns 1 on success and 0 if no translation to world\n"
22177  " coordinates is possible.\n"
22178  "\n"
22179  " Redacted form: plGetCursor(gin)\n"
22180  "\n"
22181  " This function is used in examples 1 and 20.\n"
22182  "\n"
22183  "\n"
22184  "\n"
22185  "SYNOPSIS:\n"
22186  "\n"
22187  "PLINT plGetCursor(gin)\n"
22188  "\n"
22189  "ARGUMENTS:\n"
22190  "\n"
22191  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22192  " which will contain the output. The structure is not allocated by\n"
22193  " the routine and must exist before the function is called.\n"
22194  "\n"
22195  ""},
22196  { NULL, NULL, 0, NULL }
22197 };
22198 
22199 
22200 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22201 
22202 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22203 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22204 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22205 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22206 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22207 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};
22208 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};
22209 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};
22210 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};
22211 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};
22212 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22213 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22214 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22215 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22216 
22221  &_swigt__p_char,
22228  &_swigt__p_int,
22232 };
22233 
22234 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22235 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22236 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22237 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22238 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22244 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22245 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22246 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22247 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22248 
22260  _swigc__p_int,
22264 };
22265 
22266 
22267 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22268 
22270 {0, 0, 0, 0.0, 0, 0}};
22271 
22272 #ifdef __cplusplus
22273 }
22274 #endif
22275 /* -----------------------------------------------------------------------------
22276  * Type initialization:
22277  * This problem is tough by the requirement that no dynamic
22278  * memory is used. Also, since swig_type_info structures store pointers to
22279  * swig_cast_info structures and swig_cast_info structures store pointers back
22280  * to swig_type_info structures, we need some lookup code at initialization.
22281  * The idea is that swig generates all the structures that are needed.
22282  * The runtime then collects these partially filled structures.
22283  * The SWIG_InitializeModule function takes these initial arrays out of
22284  * swig_module, and does all the lookup, filling in the swig_module.types
22285  * array with the correct data and linking the correct swig_cast_info
22286  * structures together.
22287  *
22288  * The generated swig_type_info structures are assigned statically to an initial
22289  * array. We just loop through that array, and handle each type individually.
22290  * First we lookup if this type has been already loaded, and if so, use the
22291  * loaded structure instead of the generated one. Then we have to fill in the
22292  * cast linked list. The cast data is initially stored in something like a
22293  * two-dimensional array. Each row corresponds to a type (there are the same
22294  * number of rows as there are in the swig_type_initial array). Each entry in
22295  * a column is one of the swig_cast_info structures for that type.
22296  * The cast_initial array is actually an array of arrays, because each row has
22297  * a variable number of columns. So to actually build the cast linked list,
22298  * we find the array of casts associated with the type, and loop through it
22299  * adding the casts to the list. The one last trick we need to do is making
22300  * sure the type pointer in the swig_cast_info struct is correct.
22301  *
22302  * First off, we lookup the cast->type name to see if it is already loaded.
22303  * There are three cases to handle:
22304  * 1) If the cast->type has already been loaded AND the type we are adding
22305  * casting info to has not been loaded (it is in this module), THEN we
22306  * replace the cast->type pointer with the type pointer that has already
22307  * been loaded.
22308  * 2) If BOTH types (the one we are adding casting info to, and the
22309  * cast->type) are loaded, THEN the cast info has already been loaded by
22310  * the previous module so we just ignore it.
22311  * 3) Finally, if cast->type has not already been loaded, then we add that
22312  * swig_cast_info to the linked list (because the cast->type) pointer will
22313  * be correct.
22314  * ----------------------------------------------------------------------------- */
22315 
22316 #ifdef __cplusplus
22317 extern "C" {
22318 #if 0
22319 } /* c-mode */
22320 #endif
22321 #endif
22322 
22323 #if 0
22324 #define SWIGRUNTIME_DEBUG
22325 #endif
22326 
22327 
22328 SWIGRUNTIME void
22329 SWIG_InitializeModule(void *clientdata) {
22330  size_t i;
22331  swig_module_info *module_head, *iter;
22332  int init;
22333 
22334  /* check to see if the circular list has been setup, if not, set it up */
22335  if (swig_module.next==0) {
22336  /* Initialize the swig_module */
22340  init = 1;
22341  } else {
22342  init = 0;
22343  }
22344 
22345  /* Try and load any already created modules */
22346  module_head = SWIG_GetModule(clientdata);
22347  if (!module_head) {
22348  /* This is the first module loaded for this interpreter */
22349  /* so set the swig module into the interpreter */
22350  SWIG_SetModule(clientdata, &swig_module);
22351  } else {
22352  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22353  iter=module_head;
22354  do {
22355  if (iter==&swig_module) {
22356  /* Our module is already in the list, so there's nothing more to do. */
22357  return;
22358  }
22359  iter=iter->next;
22360  } while (iter!= module_head);
22361 
22362  /* otherwise we must add our module into the list */
22363  swig_module.next = module_head->next;
22364  module_head->next = &swig_module;
22365  }
22366 
22367  /* When multiple interpreters are used, a module could have already been initialized in
22368  a different interpreter, but not yet have a pointer in this interpreter.
22369  In this case, we do not want to continue adding types... everything should be
22370  set up already */
22371  if (init == 0) return;
22372 
22373  /* Now work on filling in swig_module.types */
22374 #ifdef SWIGRUNTIME_DEBUG
22375  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22376 #endif
22377  for (i = 0; i < swig_module.size; ++i) {
22378  swig_type_info *type = 0;
22379  swig_type_info *ret;
22380  swig_cast_info *cast;
22381 
22382 #ifdef SWIGRUNTIME_DEBUG
22383  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22384 #endif
22385 
22386  /* if there is another module already loaded */
22387  if (swig_module.next != &swig_module) {
22389  }
22390  if (type) {
22391  /* Overwrite clientdata field */
22392 #ifdef SWIGRUNTIME_DEBUG
22393  printf("SWIG_InitializeModule: found type %s\n", type->name);
22394 #endif
22397 #ifdef SWIGRUNTIME_DEBUG
22398  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22399 #endif
22400  }
22401  } else {
22402  type = swig_module.type_initial[i];
22403  }
22404 
22405  /* Insert casting types */
22406  cast = swig_module.cast_initial[i];
22407  while (cast->type) {
22408  /* Don't need to add information already in the list */
22409  ret = 0;
22410 #ifdef SWIGRUNTIME_DEBUG
22411  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22412 #endif
22413  if (swig_module.next != &swig_module) {
22415 #ifdef SWIGRUNTIME_DEBUG
22416  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22417 #endif
22418  }
22419  if (ret) {
22420  if (type == swig_module.type_initial[i]) {
22421 #ifdef SWIGRUNTIME_DEBUG
22422  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22423 #endif
22424  cast->type = ret;
22425  ret = 0;
22426  } else {
22427  /* Check for casting already in the list */
22428  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22429 #ifdef SWIGRUNTIME_DEBUG
22430  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22431 #endif
22432  if (!ocast) ret = 0;
22433  }
22434  }
22435 
22436  if (!ret) {
22437 #ifdef SWIGRUNTIME_DEBUG
22438  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22439 #endif
22440  if (type->cast) {
22441  type->cast->prev = cast;
22442  cast->next = type->cast;
22443  }
22444  type->cast = cast;
22445  }
22446  cast++;
22447  }
22448  /* Set entry in modules->types array equal to the type */
22449  swig_module.types[i] = type;
22450  }
22451  swig_module.types[i] = 0;
22452 
22453 #ifdef SWIGRUNTIME_DEBUG
22454  printf("**** SWIG_InitializeModule: Cast List ******\n");
22455  for (i = 0; i < swig_module.size; ++i) {
22456  int j = 0;
22458  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22459  while (cast->type) {
22460  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22461  cast++;
22462  ++j;
22463  }
22464  printf("---- Total casts: %d\n",j);
22465  }
22466  printf("**** SWIG_InitializeModule: Cast List ******\n");
22467 #endif
22468 }
22469 
22470 /* This function will propagate the clientdata field of type to
22471 * any new swig_type_info structures that have been added into the list
22472 * of equivalent types. It is like calling
22473 * SWIG_TypeClientData(type, clientdata) a second time.
22474 */
22475 SWIGRUNTIME void
22477  size_t i;
22478  swig_cast_info *equiv;
22479  static int init_run = 0;
22480 
22481  if (init_run) return;
22482  init_run = 1;
22483 
22484  for (i = 0; i < swig_module.size; i++) {
22485  if (swig_module.types[i]->clientdata) {
22486  equiv = swig_module.types[i]->cast;
22487  while (equiv) {
22488  if (!equiv->converter) {
22489  if (equiv->type && !equiv->type->clientdata)
22491  }
22492  equiv = equiv->next;
22493  }
22494  }
22495  }
22496 }
22497 
22498 #ifdef __cplusplus
22499 #if 0
22500 {
22501  /* c-mode */
22502 #endif
22503 }
22504 #endif
22505 
22506 
22507 
22508 #ifdef __cplusplus
22509 extern "C" {
22510 #endif
22511 
22512  /* Python-specific SWIG API */
22513 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22514 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22515 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22516 
22517  /* -----------------------------------------------------------------------------
22518  * global variable support code.
22519  * ----------------------------------------------------------------------------- */
22520 
22521  typedef struct swig_globalvar {
22522  char *name; /* Name of global variable */
22523  PyObject *(*get_attr)(void); /* Return the current value */
22524  int (*set_attr)(PyObject *); /* Set the value */
22526  } swig_globalvar;
22527 
22528  typedef struct swig_varlinkobject {
22529  PyObject_HEAD
22532 
22533  SWIGINTERN PyObject *
22535 #if PY_VERSION_HEX >= 0x03000000
22536  return PyUnicode_InternFromString("<Swig global variables>");
22537 #else
22538  return PyString_FromString("<Swig global variables>");
22539 #endif
22540  }
22541 
22542  SWIGINTERN PyObject *
22544 #if PY_VERSION_HEX >= 0x03000000
22545  PyObject *str = PyUnicode_InternFromString("(");
22546  PyObject *tail;
22547  PyObject *joined;
22548  swig_globalvar *var;
22549  for (var = v->vars; var; var=var->next) {
22550  tail = PyUnicode_FromString(var->name);
22551  joined = PyUnicode_Concat(str, tail);
22552  Py_DecRef(str);
22553  Py_DecRef(tail);
22554  str = joined;
22555  if (var->next) {
22556  tail = PyUnicode_InternFromString(", ");
22557  joined = PyUnicode_Concat(str, tail);
22558  Py_DecRef(str);
22559  Py_DecRef(tail);
22560  str = joined;
22561  }
22562  }
22563  tail = PyUnicode_InternFromString(")");
22564  joined = PyUnicode_Concat(str, tail);
22565  Py_DecRef(str);
22566  Py_DecRef(tail);
22567  str = joined;
22568 #else
22569  PyObject *str = PyString_FromString("(");
22570  swig_globalvar *var;
22571  for (var = v->vars; var; var=var->next) {
22572  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22573  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22574  }
22575  PyString_ConcatAndDel(&str,PyString_FromString(")"));
22576 #endif
22577  return str;
22578  }
22579 
22580  SWIGINTERN int
22582  PyObject *str = swig_varlink_str(v);
22583  const char *tmp = SWIG_Python_str_AsChar(str);
22584  fprintf(fp,"Swig global variables ");
22585  fprintf(fp,"%s\n", tmp ? tmp : "Invalid global variable");
22587  Py_DECREF(str);
22588  return 0;
22589  }
22590 
22591  SWIGINTERN void
22593  swig_globalvar *var = v->vars;
22594  while (var) {
22595  swig_globalvar *n = var->next;
22596  free(var->name);
22597  free(var);
22598  var = n;
22599  }
22600  }
22601 
22602  SWIGINTERN PyObject *
22604  PyObject *res = NULL;
22605  swig_globalvar *var = v->vars;
22606  while (var) {
22607  if (strcmp(var->name,n) == 0) {
22608  res = (*var->get_attr)();
22609  break;
22610  }
22611  var = var->next;
22612  }
22613  if (res == NULL && !PyErr_Occurred()) {
22614  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22615  }
22616  return res;
22617  }
22618 
22619  SWIGINTERN int
22620  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22621  int res = 1;
22622  swig_globalvar *var = v->vars;
22623  while (var) {
22624  if (strcmp(var->name,n) == 0) {
22625  res = (*var->set_attr)(p);
22626  break;
22627  }
22628  var = var->next;
22629  }
22630  if (res == 1 && !PyErr_Occurred()) {
22631  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22632  }
22633  return res;
22634  }
22635 
22636  SWIGINTERN PyTypeObject*
22638  static char varlink__doc__[] = "Swig var link object";
22639  static PyTypeObject varlink_type;
22640  static int type_init = 0;
22641  if (!type_init) {
22642  const PyTypeObject tmp = {
22643 #if PY_VERSION_HEX >= 0x03000000
22644  PyVarObject_HEAD_INIT(NULL, 0)
22645 #else
22646  PyObject_HEAD_INIT(NULL)
22647  0, /* ob_size */
22648 #endif
22649  "swigvarlink", /* tp_name */
22650  sizeof(swig_varlinkobject), /* tp_basicsize */
22651  0, /* tp_itemsize */
22652  (destructor) swig_varlink_dealloc, /* tp_dealloc */
22653  (printfunc) swig_varlink_print, /* tp_print */
22654  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22655  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22656  0, /* tp_compare */
22657  (reprfunc) swig_varlink_repr, /* tp_repr */
22658  0, /* tp_as_number */
22659  0, /* tp_as_sequence */
22660  0, /* tp_as_mapping */
22661  0, /* tp_hash */
22662  0, /* tp_call */
22663  (reprfunc) swig_varlink_str, /* tp_str */
22664  0, /* tp_getattro */
22665  0, /* tp_setattro */
22666  0, /* tp_as_buffer */
22667  0, /* tp_flags */
22668  varlink__doc__, /* tp_doc */
22669  0, /* tp_traverse */
22670  0, /* tp_clear */
22671  0, /* tp_richcompare */
22672  0, /* tp_weaklistoffset */
22673  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22674  0, /* tp_del */
22675  0, /* tp_version_tag */
22676 #if PY_VERSION_HEX >= 0x03040000
22677  0, /* tp_finalize */
22678 #endif
22679 #ifdef COUNT_ALLOCS
22680  0, /* tp_allocs */
22681  0, /* tp_frees */
22682  0, /* tp_maxalloc */
22683  0, /* tp_prev */
22684  0 /* tp_next */
22685 #endif
22686  };
22687  varlink_type = tmp;
22688  type_init = 1;
22689  if (PyType_Ready(&varlink_type) < 0)
22690  return NULL;
22691  }
22692  return &varlink_type;
22693  }
22694 
22695  /* Create a variable linking object for use later */
22696  SWIGINTERN PyObject *
22698  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22699  if (result) {
22700  result->vars = 0;
22701  }
22702  return ((PyObject*) result);
22703  }
22704 
22705  SWIGINTERN void
22706  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22708  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22709  if (gv) {
22710  size_t size = strlen(name)+1;
22711  gv->name = (char *)malloc(size);
22712  if (gv->name) {
22713  memcpy(gv->name, name, size);
22714  gv->get_attr = get_attr;
22715  gv->set_attr = set_attr;
22716  gv->next = v->vars;
22717  }
22718  }
22719  v->vars = gv;
22720  }
22721 
22722  SWIGINTERN PyObject *
22724  static PyObject *_SWIG_globals = 0;
22725  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22726  return _SWIG_globals;
22727  }
22728 
22729  /* -----------------------------------------------------------------------------
22730  * constants/methods manipulation
22731  * ----------------------------------------------------------------------------- */
22732 
22733  /* Install Constants */
22734  SWIGINTERN void
22735  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22736  PyObject *obj = 0;
22737  size_t i;
22738  for (i = 0; constants[i].type; ++i) {
22739  switch(constants[i].type) {
22740  case SWIG_PY_POINTER:
22741  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22742  break;
22743  case SWIG_PY_BINARY:
22744  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22745  break;
22746  default:
22747  obj = 0;
22748  break;
22749  }
22750  if (obj) {
22751  PyDict_SetItemString(d, constants[i].name, obj);
22752  Py_DECREF(obj);
22753  }
22754  }
22755  }
22756 
22757  /* -----------------------------------------------------------------------------*/
22758  /* Fix SwigMethods to carry the callback ptrs when needed */
22759  /* -----------------------------------------------------------------------------*/
22760 
22761  SWIGINTERN void
22762  SWIG_Python_FixMethods(PyMethodDef *methods,
22763  swig_const_info *const_table,
22764  swig_type_info **types,
22765  swig_type_info **types_initial) {
22766  size_t i;
22767  for (i = 0; methods[i].ml_name; ++i) {
22768  const char *c = methods[i].ml_doc;
22769  if (!c) continue;
22770  c = strstr(c, "swig_ptr: ");
22771  if (c) {
22772  int j;
22773  swig_const_info *ci = 0;
22774  const char *name = c + 10;
22775  for (j = 0; const_table[j].type; ++j) {
22776  if (strncmp(const_table[j].name, name,
22777  strlen(const_table[j].name)) == 0) {
22778  ci = &(const_table[j]);
22779  break;
22780  }
22781  }
22782  if (ci) {
22783  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22784  if (ptr) {
22785  size_t shift = (ci->ptype) - types;
22786  swig_type_info *ty = types_initial[shift];
22787  size_t ldoc = (c - methods[i].ml_doc);
22788  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22789  char *ndoc = (char*)malloc(ldoc + lptr + 10);
22790  if (ndoc) {
22791  char *buff = ndoc;
22792  memcpy(buff, methods[i].ml_doc, ldoc);
22793  buff += ldoc;
22794  memcpy(buff, "swig_ptr: ", 10);
22795  buff += 10;
22796  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22797  methods[i].ml_doc = ndoc;
22798  }
22799  }
22800  }
22801  }
22802  }
22803  }
22804 
22805 #ifdef __cplusplus
22806 }
22807 #endif
22808 
22809 /* -----------------------------------------------------------------------------*
22810  * Partial Init method
22811  * -----------------------------------------------------------------------------*/
22812 
22813 #ifdef __cplusplus
22814 extern "C"
22815 #endif
22816 
22817 SWIGEXPORT
22818 #if PY_VERSION_HEX >= 0x03000000
22819 PyObject*
22820 #else
22821 void
22822 #endif
22823 SWIG_init(void) {
22824  PyObject *m, *d, *md;
22825 #if PY_VERSION_HEX >= 0x03000000
22826  static struct PyModuleDef SWIG_module = {
22827  PyModuleDef_HEAD_INIT,
22828  SWIG_name,
22829  NULL,
22830  -1,
22831  SwigMethods,
22832  NULL,
22833  NULL,
22834  NULL,
22835  NULL
22836  };
22837 #endif
22838 
22839 #if defined(SWIGPYTHON_BUILTIN)
22840  static SwigPyClientData SwigPyObject_clientdata = {
22841  0, 0, 0, 0, 0, 0, 0
22842  };
22843  static PyGetSetDef this_getset_def = {
22844  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22845  };
22846  static SwigPyGetSet thisown_getset_closure = {
22849  };
22850  static PyGetSetDef thisown_getset_def = {
22851  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22852  };
22853  PyTypeObject *builtin_pytype;
22854  int builtin_base_count;
22855  swig_type_info *builtin_basetype;
22856  PyObject *tuple;
22857  PyGetSetDescrObject *static_getset;
22858  PyTypeObject *metatype;
22859  PyTypeObject *swigpyobject;
22860  SwigPyClientData *cd;
22861  PyObject *public_interface, *public_symbol;
22862  PyObject *this_descr;
22863  PyObject *thisown_descr;
22864  PyObject *self = 0;
22865  int i;
22866 
22867  (void)builtin_pytype;
22868  (void)builtin_base_count;
22869  (void)builtin_basetype;
22870  (void)tuple;
22871  (void)static_getset;
22872  (void)self;
22873 
22874  /* Metaclass is used to implement static member variables */
22875  metatype = SwigPyObjectType();
22876  assert(metatype);
22877 #endif
22878 
22879  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
22880  SWIG_This();
22883 #ifndef SWIGPYTHON_BUILTIN
22885 #endif
22886 
22887  /* Fix SwigMethods to carry the callback ptrs when needed */
22889 
22890 #if PY_VERSION_HEX >= 0x03000000
22891  m = PyModule_Create(&SWIG_module);
22892 #else
22893  m = Py_InitModule(SWIG_name, SwigMethods);
22894 #endif
22895 
22896  md = d = PyModule_GetDict(m);
22897  (void)md;
22898 
22900 
22901 #ifdef SWIGPYTHON_BUILTIN
22902  swigpyobject = SwigPyObject_TypeOnce();
22903 
22904  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
22905  assert(SwigPyObject_stype);
22906  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
22907  if (!cd) {
22908  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
22909  SwigPyObject_clientdata.pytype = swigpyobject;
22910  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
22911  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
22912 # if PY_VERSION_HEX >= 0x03000000
22913  return NULL;
22914 # else
22915  return;
22916 # endif
22917  }
22918 
22919  /* All objects have a 'this' attribute */
22920  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
22921  (void)this_descr;
22922 
22923  /* All objects have a 'thisown' attribute */
22924  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
22925  (void)thisown_descr;
22926 
22927  public_interface = PyList_New(0);
22928  public_symbol = 0;
22929  (void)public_symbol;
22930 
22931  PyDict_SetItemString(md, "__all__", public_interface);
22932  Py_DECREF(public_interface);
22933  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
22934  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
22935  for (i = 0; swig_const_table[i].name != 0; ++i)
22936  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
22937 #endif
22938 
22940 
22941 
22942  import_array();
22943 
22944  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
22945  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
22946  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
22947  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
22948  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
22949  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
22950  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
22951  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
22952  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
22953  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
22954  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
22955  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
22956  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
22957  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
22958  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
22959  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
22960  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
22961  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
22962  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
22963  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
22964  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
22965  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
22966  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
22967  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
22968  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
22969  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
22970  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
22971  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
22972  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
22973  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
22974  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
22975  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
22976  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
22977  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
22978  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
22979  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
22980  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
22981  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
22982  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
22983  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
22984  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
22985  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
22986  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
22987  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
22988  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
22989  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
22990  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
22991  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
22992  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
22993  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
22994  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
22995  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
22996  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
22997  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
22998  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
22999  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23000  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23001  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23002  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23003  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23004  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23005  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23006  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23007  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23008  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23009  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23010  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23011  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23012  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23013  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23014  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23015  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23016  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23017  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23018  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23019  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23020  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23021  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23022  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23023  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23024  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23025  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23026  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23027  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23028  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23029  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23030  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23031  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23032  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23033  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23034  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23035  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23036  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23037  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23038  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23039  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23040  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23041  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23042  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23043  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23044  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23045  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23046  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23047  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23048  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23049  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23050  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23051  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23052  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23053  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23054  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23055  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23056  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23057  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23058  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23059  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23060  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23061  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23062  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23063  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23064  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23065  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23066  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23067  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23068  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23069  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23070  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23071  SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23072  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23073  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23074  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23075  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23076  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23077  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23078  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23079  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23080  SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23081  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23082  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23083  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23084  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23085  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23086  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23087  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23088  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23089  SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23090  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23091  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23092  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23093  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23094  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23095  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23096  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23097  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23098  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23099  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23100  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23101  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23102  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23103  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23104  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23105  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23106  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23107  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23108  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23109  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23110  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23111  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23112  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23113  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23114  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23115  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23116  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23117  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23118  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23119  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23120  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23121 #if PY_VERSION_HEX >= 0x03000000
23122  return m;
23123 #else
23124  return;
23125 #endif
23126 }
23127 
#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 SWIGPY_CAPSULE_NAME
#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:8391
#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)
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)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
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
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)
#define plschr
Definition: plplot.h:779
#define plsdev
Definition: plplot.h:795
#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)
int min(int a, int b)
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 * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
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
#define plbtime
Definition: plplot.h:688
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
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
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstyl
Definition: plplot.h:835
SWIGRUNTIME PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
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 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)
static int error
Definition: plcont.c:61
#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)
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
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)
static PyObject * Swig_This_global
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:8399
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)
#define plshades
Definition: plplot.h:813
PLINT PLBOOL
Definition: plplot.h:199
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
#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 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)
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)
#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:8403
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)
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)
def plResetOpts
Definition: plplotc.py:8395
#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)
#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 plline3
Definition: plplot.h:751
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
def plsxwin
Definition: plplotc.py:313
#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
#define SWIG_ValueError
def plMinMax2dGrid
Definition: plplotc.py:8407
#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
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)
int max(int a, int b)
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
#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)
#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
#define SWIG_newvarlink()
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
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
static swig_cast_info _swigc__p_PLcGrid[]
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 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)
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(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)
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
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)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
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)