PLplot  5.11.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplotcmodulePYTHON_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13 
14 /* -----------------------------------------------------------------------------
15  * This section contains generic SWIG labels for method/variable
16  * declarations/attributes, and other compiler dependent labels.
17  * ----------------------------------------------------------------------------- */
18 
19 /* template workaround for compilers that cannot correctly implement the C++ standard */
20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22 # define SWIGTEMPLATEDISAMBIGUATOR template
23 # elif defined(__HP_aCC)
24 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26 # define SWIGTEMPLATEDISAMBIGUATOR template
27 # else
28 # define SWIGTEMPLATEDISAMBIGUATOR
29 # endif
30 #endif
31 
32 /* inline attribute */
33 #ifndef SWIGINLINE
34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35 # define SWIGINLINE inline
36 # else
37 # define SWIGINLINE
38 # endif
39 #endif
40 
41 /* attribute recognised by some compilers to avoid 'unused' warnings */
42 #ifndef SWIGUNUSED
43 # if defined(__GNUC__)
44 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45 # define SWIGUNUSED __attribute__ ((__unused__))
46 # else
47 # define SWIGUNUSED
48 # endif
49 # elif defined(__ICC)
50 # define SWIGUNUSED __attribute__ ((__unused__))
51 # else
52 # define SWIGUNUSED
53 # endif
54 #endif
55 
56 #ifndef SWIG_MSC_UNSUPPRESS_4505
57 # if defined(_MSC_VER)
58 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
59 # endif
60 #endif
61 
62 #ifndef SWIGUNUSEDPARM
63 # ifdef __cplusplus
64 # define SWIGUNUSEDPARM(p)
65 # else
66 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
67 # endif
68 #endif
69 
70 /* internal SWIG method */
71 #ifndef SWIGINTERN
72 # define SWIGINTERN static SWIGUNUSED
73 #endif
74 
75 /* internal inline SWIG method */
76 #ifndef SWIGINTERNINLINE
77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78 #endif
79 
80 /* exporting methods */
81 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
82 # ifndef GCC_HASCLASSVISIBILITY
83 # define GCC_HASCLASSVISIBILITY
84 # endif
85 #endif
86 
87 #ifndef SWIGEXPORT
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # if defined(STATIC_LINKED)
90 # define SWIGEXPORT
91 # else
92 # define SWIGEXPORT __declspec(dllexport)
93 # endif
94 # else
95 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
96 # define SWIGEXPORT __attribute__ ((visibility("default")))
97 # else
98 # define SWIGEXPORT
99 # endif
100 # endif
101 #endif
102 
103 /* calling conventions for Windows */
104 #ifndef SWIGSTDCALL
105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
106 # define SWIGSTDCALL __stdcall
107 # else
108 # define SWIGSTDCALL
109 # endif
110 #endif
111 
112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
114 # define _CRT_SECURE_NO_DEPRECATE
115 #endif
116 
117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
119 # define _SCL_SECURE_NO_DEPRECATE
120 #endif
121 
122 
123 
124 /* Python.h has to appear first */
125 #include <Python.h>
126 
127 /* -----------------------------------------------------------------------------
128  * swigrun.swg
129  *
130  * This file contains generic C API SWIG runtime support for pointer
131  * type checking.
132  * ----------------------------------------------------------------------------- */
133 
134 /* This should only be incremented when either the layout of swig_type_info changes,
135  or for whatever reason, the runtime changes incompatibly */
136 #define SWIG_RUNTIME_VERSION "4"
137 
138 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
139 #ifdef SWIG_TYPE_TABLE
140 # define SWIG_QUOTE_STRING(x) #x
141 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
142 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
143 #else
144 # define SWIG_TYPE_TABLE_NAME
145 #endif
146 
147 /*
148  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
149  creating a static or dynamic library from the SWIG runtime code.
150  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
151 
152  But only do this if strictly necessary, ie, if you have problems
153  with your compiler or suchlike.
154 */
155 
156 #ifndef SWIGRUNTIME
157 # define SWIGRUNTIME SWIGINTERN
158 #endif
159 
160 #ifndef SWIGRUNTIMEINLINE
161 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
162 #endif
163 
164 /* Generic buffer size */
165 #ifndef SWIG_BUFFER_SIZE
166 # define SWIG_BUFFER_SIZE 1024
167 #endif
168 
169 /* Flags for pointer conversions */
170 #define SWIG_POINTER_DISOWN 0x1
171 #define SWIG_CAST_NEW_MEMORY 0x2
172 
173 /* Flags for new pointer objects */
174 #define SWIG_POINTER_OWN 0x1
175 
176 
177 /*
178  Flags/methods for returning states.
179 
180  The SWIG conversion methods, as ConvertPtr, return an integer
181  that tells if the conversion was successful or not. And if not,
182  an error code can be returned (see swigerrors.swg for the codes).
183 
184  Use the following macros/flags to set or process the returning
185  states.
186 
187  In old versions of SWIG, code such as the following was usually written:
188 
189  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
190  // success code
191  } else {
192  //fail code
193  }
194 
195  Now you can be more explicit:
196 
197  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
198  if (SWIG_IsOK(res)) {
199  // success code
200  } else {
201  // fail code
202  }
203 
204  which is the same really, but now you can also do
205 
206  Type *ptr;
207  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
208  if (SWIG_IsOK(res)) {
209  // success code
210  if (SWIG_IsNewObj(res) {
211  ...
212  delete *ptr;
213  } else {
214  ...
215  }
216  } else {
217  // fail code
218  }
219 
220  I.e., now SWIG_ConvertPtr can return new objects and you can
221  identify the case and take care of the deallocation. Of course that
222  also requires SWIG_ConvertPtr to return new result values, such as
223 
224  int SWIG_ConvertPtr(obj, ptr,...) {
225  if (<obj is ok>) {
226  if (<need new object>) {
227  *ptr = <ptr to new allocated object>;
228  return SWIG_NEWOBJ;
229  } else {
230  *ptr = <ptr to old object>;
231  return SWIG_OLDOBJ;
232  }
233  } else {
234  return SWIG_BADOBJ;
235  }
236  }
237 
238  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
239  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
240  SWIG errors code.
241 
242  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
243  allows to return the 'cast rank', for example, if you have this
244 
245  int food(double)
246  int fooi(int);
247 
248  and you call
249 
250  food(1) // cast rank '1' (1 -> 1.0)
251  fooi(1) // cast rank '0'
252 
253  just use the SWIG_AddCast()/SWIG_CheckState()
254 */
255 
256 #define SWIG_OK (0)
257 #define SWIG_ERROR (-1)
258 #define SWIG_IsOK(r) (r >= 0)
259 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
260 
261 /* The CastRankLimit says how many bits are used for the cast rank */
262 #define SWIG_CASTRANKLIMIT (1 << 8)
263 /* The NewMask denotes the object was created (using new/malloc) */
264 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
265 /* The TmpMask is for in/out typemaps that use temporal objects */
266 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
267 /* Simple returning values */
268 #define SWIG_BADOBJ (SWIG_ERROR)
269 #define SWIG_OLDOBJ (SWIG_OK)
270 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
271 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
272 /* Check, add and del mask methods */
273 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279 
280 /* Cast-Rank Mode */
281 #if defined(SWIG_CASTRANK_MODE)
282 # ifndef SWIG_TypeRank
283 # define SWIG_TypeRank unsigned long
284 # endif
285 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
286 # define SWIG_MAXCASTRANK (2)
287 # endif
288 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
289 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
290 SWIGINTERNINLINE int SWIG_AddCast(int r) {
291  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
292 }
293 SWIGINTERNINLINE int SWIG_CheckState(int r) {
294  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
295 }
296 #else /* no cast-rank mode */
297 # define SWIG_AddCast
298 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
299 #endif
300 
301 
302 #include <string.h>
303 
304 #ifdef __cplusplus
305 extern "C" {
306 #endif
307 
308 typedef void *(*swig_converter_func)(void *, int *);
309 typedef struct swig_type_info *(*swig_dycast_func)(void **);
310 
311 /* Structure to store information on one type */
312 typedef struct swig_type_info {
313  const char *name; /* mangled name of this type */
314  const char *str; /* human readable name of this type */
315  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
316  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
317  void *clientdata; /* language specific type data */
318  int owndata; /* flag if the structure owns the clientdata */
320 
321 /* Structure to store a type and conversion function used for casting */
322 typedef struct swig_cast_info {
323  swig_type_info *type; /* pointer to type that is equivalent to this type */
324  swig_converter_func converter; /* function to cast the void pointers */
325  struct swig_cast_info *next; /* pointer to next cast in linked list */
326  struct swig_cast_info *prev; /* pointer to the previous cast */
328 
329 /* Structure used to store module information
330  * Each module generates one structure like this, and the runtime collects
331  * all of these structures and stores them in a circularly linked list.*/
332 typedef struct swig_module_info {
333  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
334  size_t size; /* Number of types in this module */
335  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
336  swig_type_info **type_initial; /* Array of initially generated type structures */
337  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
338  void *clientdata; /* Language specific module data */
340 
341 /*
342  Compare two type names skipping the space characters, therefore
343  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
344 
345  Return 0 when the two name types are equivalent, as in
346  strncmp, but skipping ' '.
347 */
348 SWIGRUNTIME int
349 SWIG_TypeNameComp(const char *f1, const char *l1,
350  const char *f2, const char *l2) {
351  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
352  while ((*f1 == ' ') && (f1 != l1)) ++f1;
353  while ((*f2 == ' ') && (f2 != l2)) ++f2;
354  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
355  }
356  return (int)((l1 - f1) - (l2 - f2));
357 }
358 
359 /*
360  Check type equivalence in a name list like <name1>|<name2>|...
361  Return 0 if not equal, 1 if equal
362 */
363 SWIGRUNTIME int
364 SWIG_TypeEquiv(const char *nb, const char *tb) {
365  int equiv = 0;
366  const char* te = tb + strlen(tb);
367  const char* ne = nb;
368  while (!equiv && *ne) {
369  for (nb = ne; *ne; ++ne) {
370  if (*ne == '|') break;
371  }
372  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
373  if (*ne) ++ne;
374  }
375  return equiv;
376 }
377 
378 /*
379  Check type equivalence in a name list like <name1>|<name2>|...
380  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
381 */
382 SWIGRUNTIME int
383 SWIG_TypeCompare(const char *nb, const char *tb) {
384  int equiv = 0;
385  const char* te = tb + strlen(tb);
386  const char* ne = nb;
387  while (!equiv && *ne) {
388  for (nb = ne; *ne; ++ne) {
389  if (*ne == '|') break;
390  }
391  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
392  if (*ne) ++ne;
393  }
394  return equiv;
395 }
396 
397 
398 /*
399  Check the typename
400 */
402 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
403  if (ty) {
404  swig_cast_info *iter = ty->cast;
405  while (iter) {
406  if (strcmp(iter->type->name, c) == 0) {
407  if (iter == ty->cast)
408  return iter;
409  /* Move iter to the top of the linked list */
410  iter->prev->next = iter->next;
411  if (iter->next)
412  iter->next->prev = iter->prev;
413  iter->next = ty->cast;
414  iter->prev = 0;
415  if (ty->cast) ty->cast->prev = iter;
416  ty->cast = iter;
417  return iter;
418  }
419  iter = iter->next;
420  }
421  }
422  return 0;
423 }
424 
425 /*
426  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
427 */
430  if (ty) {
431  swig_cast_info *iter = ty->cast;
432  while (iter) {
433  if (iter->type == from) {
434  if (iter == ty->cast)
435  return iter;
436  /* Move iter to the top of the linked list */
437  iter->prev->next = iter->next;
438  if (iter->next)
439  iter->next->prev = iter->prev;
440  iter->next = ty->cast;
441  iter->prev = 0;
442  if (ty->cast) ty->cast->prev = iter;
443  ty->cast = iter;
444  return iter;
445  }
446  iter = iter->next;
447  }
448  }
449  return 0;
450 }
451 
452 /*
453  Cast a pointer up an inheritance hierarchy
454 */
455 SWIGRUNTIMEINLINE void *
456 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
457  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
458 }
459 
460 /*
461  Dynamic pointer casting. Down an inheritance hierarchy
462 */
465  swig_type_info *lastty = ty;
466  if (!ty || !ty->dcast) return ty;
467  while (ty && (ty->dcast)) {
468  ty = (*ty->dcast)(ptr);
469  if (ty) lastty = ty;
470  }
471  return lastty;
472 }
473 
474 /*
475  Return the name associated with this type
476 */
477 SWIGRUNTIMEINLINE const char *
479  return ty->name;
480 }
481 
482 /*
483  Return the pretty name associated with this type,
484  that is an unmangled type name in a form presentable to the user.
485 */
486 SWIGRUNTIME const char *
488  /* The "str" field contains the equivalent pretty names of the
489  type, separated by vertical-bar characters. We choose
490  to print the last name, as it is often (?) the most
491  specific. */
492  if (!type) return NULL;
493  if (type->str != NULL) {
494  const char *last_name = type->str;
495  const char *s;
496  for (s = type->str; *s; s++)
497  if (*s == '|') last_name = s+1;
498  return last_name;
499  }
500  else
501  return type->name;
502 }
503 
504 /*
505  Set the clientdata field for a type
506 */
507 SWIGRUNTIME void
509  swig_cast_info *cast = ti->cast;
510  /* if (ti->clientdata == clientdata) return; */
511  ti->clientdata = clientdata;
512 
513  while (cast) {
514  if (!cast->converter) {
515  swig_type_info *tc = cast->type;
516  if (!tc->clientdata) {
517  SWIG_TypeClientData(tc, clientdata);
518  }
519  }
520  cast = cast->next;
521  }
522 }
523 SWIGRUNTIME void
525  SWIG_TypeClientData(ti, clientdata);
526  ti->owndata = 1;
527 }
528 
529 /*
530  Search for a swig_type_info structure only by mangled name
531  Search is a O(log #types)
532 
533  We start searching at module start, and finish searching when start == end.
534  Note: if start == end at the beginning of the function, we go all the way around
535  the circular list.
536 */
539  swig_module_info *end,
540  const char *name) {
541  swig_module_info *iter = start;
542  do {
543  if (iter->size) {
544  register size_t l = 0;
545  register size_t r = iter->size - 1;
546  do {
547  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
548  register size_t i = (l + r) >> 1;
549  const char *iname = iter->types[i]->name;
550  if (iname) {
551  register int compare = strcmp(name, iname);
552  if (compare == 0) {
553  return iter->types[i];
554  } else if (compare < 0) {
555  if (i) {
556  r = i - 1;
557  } else {
558  break;
559  }
560  } else if (compare > 0) {
561  l = i + 1;
562  }
563  } else {
564  break; /* should never happen */
565  }
566  } while (l <= r);
567  }
568  iter = iter->next;
569  } while (iter != end);
570  return 0;
571 }
572 
573 /*
574  Search for a swig_type_info structure for either a mangled name or a human readable name.
575  It first searches the mangled names of the types, which is a O(log #types)
576  If a type is not found it then searches the human readable names, which is O(#types).
577 
578  We start searching at module start, and finish searching when start == end.
579  Note: if start == end at the beginning of the function, we go all the way around
580  the circular list.
581 */
584  swig_module_info *end,
585  const char *name) {
586  /* STEP 1: Search the name field using binary search */
587  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
588  if (ret) {
589  return ret;
590  } else {
591  /* STEP 2: If the type hasn't been found, do a complete search
592  of the str field (the human readable name) */
593  swig_module_info *iter = start;
594  do {
595  register size_t i = 0;
596  for (; i < iter->size; ++i) {
597  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
598  return iter->types[i];
599  }
600  iter = iter->next;
601  } while (iter != end);
602  }
603 
604  /* neither found a match */
605  return 0;
606 }
607 
608 /*
609  Pack binary data into a string
610 */
611 SWIGRUNTIME char *
612 SWIG_PackData(char *c, void *ptr, size_t sz) {
613  static const char hex[17] = "0123456789abcdef";
614  register const unsigned char *u = (unsigned char *) ptr;
615  register const unsigned char *eu = u + sz;
616  for (; u != eu; ++u) {
617  register unsigned char uu = *u;
618  *(c++) = hex[(uu & 0xf0) >> 4];
619  *(c++) = hex[uu & 0xf];
620  }
621  return c;
622 }
623 
624 /*
625  Unpack binary data from a string
626 */
627 SWIGRUNTIME const char *
628 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
629  register unsigned char *u = (unsigned char *) ptr;
630  register const unsigned char *eu = u + sz;
631  for (; u != eu; ++u) {
632  register char d = *(c++);
633  register unsigned char uu;
634  if ((d >= '0') && (d <= '9'))
635  uu = ((d - '0') << 4);
636  else if ((d >= 'a') && (d <= 'f'))
637  uu = ((d - ('a'-10)) << 4);
638  else
639  return (char *) 0;
640  d = *(c++);
641  if ((d >= '0') && (d <= '9'))
642  uu |= (d - '0');
643  else if ((d >= 'a') && (d <= 'f'))
644  uu |= (d - ('a'-10));
645  else
646  return (char *) 0;
647  *u = uu;
648  }
649  return c;
650 }
651 
652 /*
653  Pack 'void *' into a string buffer.
654 */
655 SWIGRUNTIME char *
656 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
657  char *r = buff;
658  if ((2*sizeof(void *) + 2) > bsz) return 0;
659  *(r++) = '_';
660  r = SWIG_PackData(r,&ptr,sizeof(void *));
661  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
662  strcpy(r,name);
663  return buff;
664 }
665 
666 SWIGRUNTIME const char *
667 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
668  if (*c != '_') {
669  if (strcmp(c,"NULL") == 0) {
670  *ptr = (void *) 0;
671  return name;
672  } else {
673  return 0;
674  }
675  }
676  return SWIG_UnpackData(++c,ptr,sizeof(void *));
677 }
678 
679 SWIGRUNTIME char *
680 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
681  char *r = buff;
682  size_t lname = (name ? strlen(name) : 0);
683  if ((2*sz + 2 + lname) > bsz) return 0;
684  *(r++) = '_';
685  r = SWIG_PackData(r,ptr,sz);
686  if (lname) {
687  strncpy(r,name,lname+1);
688  } else {
689  *r = 0;
690  }
691  return buff;
692 }
693 
694 SWIGRUNTIME const char *
695 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
696  if (*c != '_') {
697  if (strcmp(c,"NULL") == 0) {
698  memset(ptr,0,sz);
699  return name;
700  } else {
701  return 0;
702  }
703  }
704  return SWIG_UnpackData(++c,ptr,sz);
705 }
706 
707 #ifdef __cplusplus
708 }
709 #endif
710 
711 /* Errors in SWIG */
712 #define SWIG_UnknownError -1
713 #define SWIG_IOError -2
714 #define SWIG_RuntimeError -3
715 #define SWIG_IndexError -4
716 #define SWIG_TypeError -5
717 #define SWIG_DivisionByZero -6
718 #define SWIG_OverflowError -7
719 #define SWIG_SyntaxError -8
720 #define SWIG_ValueError -9
721 #define SWIG_SystemError -10
722 #define SWIG_AttributeError -11
723 #define SWIG_MemoryError -12
724 #define SWIG_NullReferenceError -13
725 
726 
727 
728 /* Compatibility macros for Python 3 */
729 #if PY_VERSION_HEX >= 0x03000000
730 
731 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
732 #define PyInt_Check(x) PyLong_Check(x)
733 #define PyInt_AsLong(x) PyLong_AsLong(x)
734 #define PyInt_FromLong(x) PyLong_FromLong(x)
735 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
736 #define PyString_Check(name) PyBytes_Check(name)
737 #define PyString_FromString(x) PyUnicode_FromString(x)
738 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
739 #define PyString_AsString(str) PyBytes_AsString(str)
740 #define PyString_Size(str) PyBytes_Size(str)
741 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
742 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
743 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
744 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
745 
746 #endif
747 
748 #ifndef Py_TYPE
749 # define Py_TYPE(op) ((op)->ob_type)
750 #endif
751 
752 /* SWIG APIs for compatibility of both Python 2 & 3 */
753 
754 #if PY_VERSION_HEX >= 0x03000000
755 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
756 #else
757 # define SWIG_Python_str_FromFormat PyString_FromFormat
758 #endif
759 
760 
761 /* Warning: This function will allocate a new string in Python 3,
762  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
763  */
764 SWIGINTERN char*
766 {
767 #if PY_VERSION_HEX >= 0x03000000
768  char *cstr;
769  char *newstr;
770  Py_ssize_t len;
771  str = PyUnicode_AsUTF8String(str);
772  PyBytes_AsStringAndSize(str, &cstr, &len);
773  newstr = (char *) malloc(len+1);
774  memcpy(newstr, cstr, len+1);
775  Py_XDECREF(str);
776  return newstr;
777 #else
778  return PyString_AsString(str);
779 #endif
780 }
781 
782 #if PY_VERSION_HEX >= 0x03000000
783 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
784 #else
785 # define SWIG_Python_str_DelForPy3(x)
786 #endif
787 
788 
789 SWIGINTERN PyObject*
791 {
792 #if PY_VERSION_HEX >= 0x03000000
793  return PyUnicode_FromString(c);
794 #else
795  return PyString_FromString(c);
796 #endif
797 }
798 
799 /* Add PyOS_snprintf for old Pythons */
800 #if PY_VERSION_HEX < 0x02020000
801 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
802 # define PyOS_snprintf _snprintf
803 # else
804 # define PyOS_snprintf snprintf
805 # endif
806 #endif
807 
808 /* A crude PyString_FromFormat implementation for old Pythons */
809 #if PY_VERSION_HEX < 0x02020000
810 
811 #ifndef SWIG_PYBUFFER_SIZE
812 # define SWIG_PYBUFFER_SIZE 1024
813 #endif
814 
815 static PyObject *
816 PyString_FromFormat(const char *fmt, ...) {
817  va_list ap;
818  char buf[SWIG_PYBUFFER_SIZE * 2];
819  int res;
820  va_start(ap, fmt);
821  res = vsnprintf(buf, sizeof(buf), fmt, ap);
822  va_end(ap);
823  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
824 }
825 #endif
826 
827 /* Add PyObject_Del for old Pythons */
828 #if PY_VERSION_HEX < 0x01060000
829 # define PyObject_Del(op) PyMem_DEL((op))
830 #endif
831 #ifndef PyObject_DEL
832 # define PyObject_DEL PyObject_Del
833 #endif
834 
835 /* A crude PyExc_StopIteration exception for old Pythons */
836 #if PY_VERSION_HEX < 0x02020000
837 # ifndef PyExc_StopIteration
838 # define PyExc_StopIteration PyExc_RuntimeError
839 # endif
840 # ifndef PyObject_GenericGetAttr
841 # define PyObject_GenericGetAttr 0
842 # endif
843 #endif
844 
845 /* Py_NotImplemented is defined in 2.1 and up. */
846 #if PY_VERSION_HEX < 0x02010000
847 # ifndef Py_NotImplemented
848 # define Py_NotImplemented PyExc_RuntimeError
849 # endif
850 #endif
851 
852 /* A crude PyString_AsStringAndSize implementation for old Pythons */
853 #if PY_VERSION_HEX < 0x02010000
854 # ifndef PyString_AsStringAndSize
855 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
856 # endif
857 #endif
858 
859 /* PySequence_Size for old Pythons */
860 #if PY_VERSION_HEX < 0x02000000
861 # ifndef PySequence_Size
862 # define PySequence_Size PySequence_Length
863 # endif
864 #endif
865 
866 /* PyBool_FromLong for old Pythons */
867 #if PY_VERSION_HEX < 0x02030000
868 static
869 PyObject *PyBool_FromLong(long ok)
870 {
871  PyObject *result = ok ? Py_True : Py_False;
872  Py_INCREF(result);
873  return result;
874 }
875 #endif
876 
877 /* Py_ssize_t for old Pythons */
878 /* This code is as recommended by: */
879 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
880 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
881 typedef int Py_ssize_t;
882 # define PY_SSIZE_T_MAX INT_MAX
883 # define PY_SSIZE_T_MIN INT_MIN
884 typedef inquiry lenfunc;
885 typedef intargfunc ssizeargfunc;
886 typedef intintargfunc ssizessizeargfunc;
887 typedef intobjargproc ssizeobjargproc;
888 typedef intintobjargproc ssizessizeobjargproc;
889 typedef getreadbufferproc readbufferproc;
890 typedef getwritebufferproc writebufferproc;
891 typedef getsegcountproc segcountproc;
892 typedef getcharbufferproc charbufferproc;
893 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
894 {
895  long result = 0;
896  PyObject *i = PyNumber_Int(x);
897  if (i) {
898  result = PyInt_AsLong(i);
899  Py_DECREF(i);
900  }
901  return result;
902 }
903 #endif
904 
905 #if PY_VERSION_HEX < 0x02040000
906 #define Py_VISIT(op) \
907  do { \
908  if (op) { \
909  int vret = visit((op), arg); \
910  if (vret) \
911  return vret; \
912  } \
913  } while (0)
914 #endif
915 
916 #if PY_VERSION_HEX < 0x02030000
917 typedef struct {
918  PyTypeObject type;
919  PyNumberMethods as_number;
920  PyMappingMethods as_mapping;
921  PySequenceMethods as_sequence;
922  PyBufferProcs as_buffer;
923  PyObject *name, *slots;
925 #endif
926 
927 #if PY_VERSION_HEX < 0x02030000
928 typedef destructor freefunc;
929 #endif
930 
931 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
932  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
933  (PY_MAJOR_VERSION > 3))
934 # define SWIGPY_USE_CAPSULE
935 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
936 #endif
937 
938 #if PY_VERSION_HEX < 0x03020000
939 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
940 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
941 #endif
942 
943 /* -----------------------------------------------------------------------------
944  * error manipulation
945  * ----------------------------------------------------------------------------- */
946 
947 SWIGRUNTIME PyObject*
949  PyObject* type = 0;
950  switch(code) {
951  case SWIG_MemoryError:
952  type = PyExc_MemoryError;
953  break;
954  case SWIG_IOError:
955  type = PyExc_IOError;
956  break;
957  case SWIG_RuntimeError:
958  type = PyExc_RuntimeError;
959  break;
960  case SWIG_IndexError:
961  type = PyExc_IndexError;
962  break;
963  case SWIG_TypeError:
964  type = PyExc_TypeError;
965  break;
966  case SWIG_DivisionByZero:
967  type = PyExc_ZeroDivisionError;
968  break;
969  case SWIG_OverflowError:
970  type = PyExc_OverflowError;
971  break;
972  case SWIG_SyntaxError:
973  type = PyExc_SyntaxError;
974  break;
975  case SWIG_ValueError:
976  type = PyExc_ValueError;
977  break;
978  case SWIG_SystemError:
979  type = PyExc_SystemError;
980  break;
981  case SWIG_AttributeError:
982  type = PyExc_AttributeError;
983  break;
984  default:
985  type = PyExc_RuntimeError;
986  }
987  return type;
988 }
989 
990 
991 SWIGRUNTIME void
992 SWIG_Python_AddErrorMsg(const char* mesg)
993 {
994  PyObject *type = 0;
995  PyObject *value = 0;
996  PyObject *traceback = 0;
997 
998  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
999  if (value) {
1000  char *tmp;
1001  PyObject *old_str = PyObject_Str(value);
1002  PyErr_Clear();
1003  Py_XINCREF(type);
1004 
1005  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1007  Py_DECREF(old_str);
1008  Py_DECREF(value);
1009  } else {
1010  PyErr_SetString(PyExc_RuntimeError, mesg);
1011  }
1012 }
1013 
1014 #if defined(SWIG_PYTHON_NO_THREADS)
1015 # if defined(SWIG_PYTHON_THREADS)
1016 # undef SWIG_PYTHON_THREADS
1017 # endif
1018 #endif
1019 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1020 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1021 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1022 # define SWIG_PYTHON_USE_GIL
1023 # endif
1024 # endif
1025 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1026 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1027 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1028 # endif
1029 # ifdef __cplusplus /* C++ code */
1030  class SWIG_Python_Thread_Block {
1031  bool status;
1032  PyGILState_STATE state;
1033  public:
1034  void end() { if (status) { PyGILState_Release(state); status = false;} }
1035  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1036  ~SWIG_Python_Thread_Block() { end(); }
1037  };
1038  class SWIG_Python_Thread_Allow {
1039  bool status;
1040  PyThreadState *save;
1041  public:
1042  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1043  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1044  ~SWIG_Python_Thread_Allow() { end(); }
1045  };
1046 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1047 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1048 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1049 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1050 # else /* C code */
1051 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1052 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1053 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1054 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1055 # endif
1056 # else /* Old thread way, not implemented, user must provide it */
1057 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1058 # define SWIG_PYTHON_INITIALIZE_THREADS
1059 # endif
1060 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1061 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1062 # endif
1063 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1064 # define SWIG_PYTHON_THREAD_END_BLOCK
1065 # endif
1066 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1067 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1068 # endif
1069 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1070 # define SWIG_PYTHON_THREAD_END_ALLOW
1071 # endif
1072 # endif
1073 #else /* No thread support */
1074 # define SWIG_PYTHON_INITIALIZE_THREADS
1075 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1076 # define SWIG_PYTHON_THREAD_END_BLOCK
1077 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1078 # define SWIG_PYTHON_THREAD_END_ALLOW
1079 #endif
1080 
1081 /* -----------------------------------------------------------------------------
1082  * Python API portion that goes into the runtime
1083  * ----------------------------------------------------------------------------- */
1084 
1085 #ifdef __cplusplus
1086 extern "C" {
1087 #endif
1088 
1089 /* -----------------------------------------------------------------------------
1090  * Constant declarations
1091  * ----------------------------------------------------------------------------- */
1092 
1093 /* Constant Types */
1094 #define SWIG_PY_POINTER 4
1095 #define SWIG_PY_BINARY 5
1096 
1097 /* Constant information structure */
1098 typedef struct swig_const_info {
1099  int type;
1100  char *name;
1101  long lvalue;
1102  double dvalue;
1103  void *pvalue;
1105 } swig_const_info;
1106 
1107 
1108 /* -----------------------------------------------------------------------------
1109  * Wrapper of PyInstanceMethod_New() used in Python 3
1110  * It is exported to the generated module, used for -fastproxy
1111  * ----------------------------------------------------------------------------- */
1112 #if PY_VERSION_HEX >= 0x03000000
1113 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1114 {
1115  return PyInstanceMethod_New(func);
1116 }
1117 #else
1118 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1119 {
1120  return NULL;
1121 }
1122 #endif
1123 
1124 #ifdef __cplusplus
1125 }
1126 #endif
1127 
1128 
1129 /* -----------------------------------------------------------------------------
1130  * pyrun.swg
1131  *
1132  * This file contains the runtime support for Python modules
1133  * and includes code for managing global variables and pointer
1134  * type checking.
1135  *
1136  * ----------------------------------------------------------------------------- */
1137 
1138 /* Common SWIG API */
1139 
1140 /* for raw pointers */
1141 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1142 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1143 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1144 
1145 #ifdef SWIGPYTHON_BUILTIN
1146 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1147 #else
1148 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1149 #endif
1150 
1151 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1152 
1153 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1154 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1155 #define swig_owntype int
1156 
1157 /* for raw packed data */
1158 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1159 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1160 
1161 /* for class or struct pointers */
1162 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1163 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1164 
1165 /* for C or C++ function pointers */
1166 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1167 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1168 
1169 /* for C++ member pointers, ie, member methods */
1170 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1171 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1172 
1173 
1174 /* Runtime API */
1175 
1176 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1177 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1178 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1179 
1180 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1181 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1182 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1183 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1184 #define SWIG_fail goto fail
1185 
1186 
1187 /* Runtime API implementation */
1188 
1189 /* Error manipulation */
1190 
1191 SWIGINTERN void
1192 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1194  PyErr_SetObject(errtype, obj);
1195  Py_DECREF(obj);
1197 }
1198 
1199 SWIGINTERN void
1200 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1202  PyErr_SetString(errtype, msg);
1204 }
1205 
1206 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1207 
1208 /* Set a constant value */
1209 
1210 #if defined(SWIGPYTHON_BUILTIN)
1211 
1212 SWIGINTERN void
1213 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1214  PyObject *s = PyString_InternFromString(key);
1215  PyList_Append(seq, s);
1216  Py_DECREF(s);
1217 }
1218 
1219 SWIGINTERN void
1220 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1221 #if PY_VERSION_HEX < 0x02030000
1222  PyDict_SetItemString(d, (char *)name, obj);
1223 #else
1224  PyDict_SetItemString(d, name, obj);
1225 #endif
1226  Py_DECREF(obj);
1227  if (public_interface)
1228  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1229 }
1230 
1231 #else
1232 
1233 SWIGINTERN void
1234 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1235 #if PY_VERSION_HEX < 0x02030000
1236  PyDict_SetItemString(d, (char *)name, obj);
1237 #else
1238  PyDict_SetItemString(d, name, obj);
1239 #endif
1240  Py_DECREF(obj);
1241 }
1242 
1243 #endif
1244 
1245 /* Append a value to the result obj */
1246 
1247 SWIGINTERN PyObject*
1248 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1249 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1250  if (!result) {
1251  result = obj;
1252  } else if (result == Py_None) {
1253  Py_DECREF(result);
1254  result = obj;
1255  } else {
1256  if (!PyList_Check(result)) {
1257  PyObject *o2 = result;
1258  result = PyList_New(1);
1259  PyList_SetItem(result, 0, o2);
1260  }
1261  PyList_Append(result,obj);
1262  Py_DECREF(obj);
1263  }
1264  return result;
1265 #else
1266  PyObject* o2;
1267  PyObject* o3;
1268  if (!result) {
1269  result = obj;
1270  } else if (result == Py_None) {
1271  Py_DECREF(result);
1272  result = obj;
1273  } else {
1274  if (!PyTuple_Check(result)) {
1275  o2 = result;
1276  result = PyTuple_New(1);
1277  PyTuple_SET_ITEM(result, 0, o2);
1278  }
1279  o3 = PyTuple_New(1);
1280  PyTuple_SET_ITEM(o3, 0, obj);
1281  o2 = result;
1282  result = PySequence_Concat(o2, o3);
1283  Py_DECREF(o2);
1284  Py_DECREF(o3);
1285  }
1286  return result;
1287 #endif
1288 }
1289 
1290 /* Unpack the argument tuple */
1291 
1292 SWIGINTERN int
1293 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1294 {
1295  if (!args) {
1296  if (!min && !max) {
1297  return 1;
1298  } else {
1299  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1300  name, (min == max ? "" : "at least "), (int)min);
1301  return 0;
1302  }
1303  }
1304  if (!PyTuple_Check(args)) {
1305  if (min <= 1 && max >= 1) {
1306  register int i;
1307  objs[0] = args;
1308  for (i = 1; i < max; ++i) {
1309  objs[i] = 0;
1310  }
1311  return 2;
1312  }
1313  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1314  return 0;
1315  } else {
1316  register Py_ssize_t l = PyTuple_GET_SIZE(args);
1317  if (l < min) {
1318  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1319  name, (min == max ? "" : "at least "), (int)min, (int)l);
1320  return 0;
1321  } else if (l > max) {
1322  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1323  name, (min == max ? "" : "at most "), (int)max, (int)l);
1324  return 0;
1325  } else {
1326  register int i;
1327  for (i = 0; i < l; ++i) {
1328  objs[i] = PyTuple_GET_ITEM(args, i);
1329  }
1330  for (; l < max; ++l) {
1331  objs[l] = 0;
1332  }
1333  return i + 1;
1334  }
1335  }
1336 }
1337 
1338 /* A functor is a function object with one single object argument */
1339 #if PY_VERSION_HEX >= 0x02020000
1340 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1341 #else
1342 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1343 #endif
1344 
1345 /*
1346  Helper for static pointer initialization for both C and C++ code, for example
1347  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1348 */
1349 #ifdef __cplusplus
1350 #define SWIG_STATIC_POINTER(var) var
1351 #else
1352 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1353 #endif
1354 
1355 /* -----------------------------------------------------------------------------
1356  * Pointer declarations
1357  * ----------------------------------------------------------------------------- */
1358 
1359 /* Flags for new pointer objects */
1360 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1361 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1362 
1363 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1364 
1365 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1366 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1367 
1368 #ifdef __cplusplus
1369 extern "C" {
1370 #endif
1371 
1372 /* How to access Py_None */
1373 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1374 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1375 # ifndef SWIG_PYTHON_BUILD_NONE
1376 # define SWIG_PYTHON_BUILD_NONE
1377 # endif
1378 # endif
1379 #endif
1380 
1381 #ifdef SWIG_PYTHON_BUILD_NONE
1382 # ifdef Py_None
1383 # undef Py_None
1384 # define Py_None SWIG_Py_None()
1385 # endif
1386 SWIGRUNTIMEINLINE PyObject *
1387 _SWIG_Py_None(void)
1388 {
1389  PyObject *none = Py_BuildValue((char*)"");
1390  Py_DECREF(none);
1391  return none;
1392 }
1393 SWIGRUNTIME PyObject *
1394 SWIG_Py_None(void)
1395 {
1396  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1397  return none;
1398 }
1399 #endif
1400 
1401 /* The python void return value */
1402 
1403 SWIGRUNTIMEINLINE PyObject *
1405 {
1406  PyObject *none = Py_None;
1407  Py_INCREF(none);
1408  return none;
1409 }
1410 
1411 /* SwigPyClientData */
1412 
1413 typedef struct {
1414  PyObject *klass;
1415  PyObject *newraw;
1416  PyObject *newargs;
1417  PyObject *destroy;
1418  int delargs;
1420  PyTypeObject *pytype;
1422 
1423 SWIGRUNTIMEINLINE int
1425 {
1427  return data ? data->implicitconv : 0;
1428 }
1429 
1430 SWIGRUNTIMEINLINE PyObject *
1432  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1433  PyObject *klass = data ? data->klass : 0;
1434  return (klass ? klass : PyExc_RuntimeError);
1435 }
1436 
1437 
1439 SwigPyClientData_New(PyObject* obj)
1440 {
1441  if (!obj) {
1442  return 0;
1443  } else {
1444  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1445  /* the klass element */
1446  data->klass = obj;
1447  Py_INCREF(data->klass);
1448  /* the newraw method and newargs arguments used to create a new raw instance */
1449  if (PyClass_Check(obj)) {
1450  data->newraw = 0;
1451  data->newargs = obj;
1452  Py_INCREF(obj);
1453  } else {
1454 #if (PY_VERSION_HEX < 0x02020000)
1455  data->newraw = 0;
1456 #else
1457  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1458 #endif
1459  if (data->newraw) {
1460  Py_INCREF(data->newraw);
1461  data->newargs = PyTuple_New(1);
1462  PyTuple_SetItem(data->newargs, 0, obj);
1463  } else {
1464  data->newargs = obj;
1465  }
1466  Py_INCREF(data->newargs);
1467  }
1468  /* the destroy method, aka as the C++ delete method */
1469  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1470  if (PyErr_Occurred()) {
1471  PyErr_Clear();
1472  data->destroy = 0;
1473  }
1474  if (data->destroy) {
1475  int flags;
1476  Py_INCREF(data->destroy);
1477  flags = PyCFunction_GET_FLAGS(data->destroy);
1478 #ifdef METH_O
1479  data->delargs = !(flags & (METH_O));
1480 #else
1481  data->delargs = 0;
1482 #endif
1483  } else {
1484  data->delargs = 0;
1485  }
1486  data->implicitconv = 0;
1487  data->pytype = 0;
1488  return data;
1489  }
1490 }
1491 
1492 SWIGRUNTIME void
1494  Py_XDECREF(data->newraw);
1495  Py_XDECREF(data->newargs);
1496  Py_XDECREF(data->destroy);
1497 }
1498 
1499 /* =============== SwigPyObject =====================*/
1500 
1501 typedef struct {
1502  PyObject_HEAD
1503  void *ptr;
1505  int own;
1506  PyObject *next;
1507 #ifdef SWIGPYTHON_BUILTIN
1508  PyObject *dict;
1509 #endif
1510 } SwigPyObject;
1511 
1512 SWIGRUNTIME PyObject *
1514 {
1515  return PyLong_FromVoidPtr(v->ptr);
1516 }
1517 
1518 SWIGRUNTIME PyObject *
1519 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1520 {
1521  PyObject *res = NULL;
1522  PyObject *args = PyTuple_New(1);
1523  if (args) {
1524  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1525  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1526  if (ofmt) {
1527 #if PY_VERSION_HEX >= 0x03000000
1528  res = PyUnicode_Format(ofmt,args);
1529 #else
1530  res = PyString_Format(ofmt,args);
1531 #endif
1532  Py_DECREF(ofmt);
1533  }
1534  Py_DECREF(args);
1535  }
1536  }
1537  return res;
1538 }
1539 
1540 SWIGRUNTIME PyObject *
1542 {
1543  return SwigPyObject_format("%o",v);
1544 }
1545 
1546 SWIGRUNTIME PyObject *
1548 {
1549  return SwigPyObject_format("%x",v);
1550 }
1551 
1552 SWIGRUNTIME PyObject *
1553 #ifdef METH_NOARGS
1555 #else
1556 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1557 #endif
1558 {
1559  const char *name = SWIG_TypePrettyName(v->ty);
1560  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1561  if (v->next) {
1562 # ifdef METH_NOARGS
1563  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1564 # else
1565  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1566 # endif
1567 # if PY_VERSION_HEX >= 0x03000000
1568  PyObject *joined = PyUnicode_Concat(repr, nrep);
1569  Py_DecRef(repr);
1570  Py_DecRef(nrep);
1571  repr = joined;
1572 # else
1573  PyString_ConcatAndDel(&repr,nrep);
1574 # endif
1575  }
1576  return repr;
1577 }
1578 
1579 SWIGRUNTIME int
1581 {
1582  char *str;
1583 #ifdef METH_NOARGS
1584  PyObject *repr = SwigPyObject_repr(v);
1585 #else
1586  PyObject *repr = SwigPyObject_repr(v, NULL);
1587 #endif
1588  if (repr) {
1589  str = SWIG_Python_str_AsChar(repr);
1590  fputs(str, fp);
1592  Py_DECREF(repr);
1593  return 0;
1594  } else {
1595  return 1;
1596  }
1597 }
1598 
1599 SWIGRUNTIME PyObject *
1601 {
1602  char result[SWIG_BUFFER_SIZE];
1603  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1604  SWIG_Python_str_FromChar(result) : 0;
1605 }
1606 
1607 SWIGRUNTIME int
1609 {
1610  void *i = v->ptr;
1611  void *j = w->ptr;
1612  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1613 }
1614 
1615 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1616 SWIGRUNTIME PyObject*
1618 {
1619  PyObject* res;
1620  if( op != Py_EQ && op != Py_NE ) {
1621  Py_INCREF(Py_NotImplemented);
1622  return Py_NotImplemented;
1623  }
1624  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1625  return res;
1626 }
1627 
1628 
1629 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1630 
1631 #ifdef SWIGPYTHON_BUILTIN
1632 static swig_type_info *SwigPyObject_stype = 0;
1633 SWIGRUNTIME PyTypeObject*
1634 SwigPyObject_type(void) {
1635  SwigPyClientData *cd;
1636  assert(SwigPyObject_stype);
1637  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1638  assert(cd);
1639  assert(cd->pytype);
1640  return cd->pytype;
1641 }
1642 #else
1643 SWIGRUNTIME PyTypeObject*
1645  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1646  return type;
1647 }
1648 #endif
1649 
1651 SwigPyObject_Check(PyObject *op) {
1652 #ifdef SWIGPYTHON_BUILTIN
1653  PyTypeObject *target_tp = SwigPyObject_type();
1654  if (PyType_IsSubtype(op->ob_type, target_tp))
1655  return 1;
1656  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1657 #else
1658  return (Py_TYPE(op) == SwigPyObject_type())
1659  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1660 #endif
1661 }
1662 
1663 SWIGRUNTIME PyObject *
1664 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1665 
1666 SWIGRUNTIME void
1668 {
1669  SwigPyObject *sobj = (SwigPyObject *) v;
1670  PyObject *next = sobj->next;
1671  if (sobj->own == SWIG_POINTER_OWN) {
1672  swig_type_info *ty = sobj->ty;
1673  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1674  PyObject *destroy = data ? data->destroy : 0;
1675  if (destroy) {
1676  /* destroy is always a VARARGS method */
1677  PyObject *res;
1678  if (data->delargs) {
1679  /* we need to create a temporary object to carry the destroy operation */
1680  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1681  res = SWIG_Python_CallFunctor(destroy, tmp);
1682  Py_DECREF(tmp);
1683  } else {
1684  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1685  PyObject *mself = PyCFunction_GET_SELF(destroy);
1686  res = ((*meth)(mself, v));
1687  }
1688  Py_XDECREF(res);
1689  }
1690 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1691  else {
1692  const char *name = SWIG_TypePrettyName(ty);
1693  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1694  }
1695 #endif
1696  }
1697  Py_XDECREF(next);
1698  PyObject_DEL(v);
1699 }
1700 
1701 SWIGRUNTIME PyObject*
1702 SwigPyObject_append(PyObject* v, PyObject* next)
1703 {
1704  SwigPyObject *sobj = (SwigPyObject *) v;
1705 #ifndef METH_O
1706  PyObject *tmp = 0;
1707  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1708  next = tmp;
1709 #endif
1710  if (!SwigPyObject_Check(next)) {
1711  return NULL;
1712  }
1713  sobj->next = next;
1714  Py_INCREF(next);
1715  return SWIG_Py_Void();
1716 }
1717 
1718 SWIGRUNTIME PyObject*
1719 #ifdef METH_NOARGS
1720 SwigPyObject_next(PyObject* v)
1721 #else
1722 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1723 #endif
1724 {
1725  SwigPyObject *sobj = (SwigPyObject *) v;
1726  if (sobj->next) {
1727  Py_INCREF(sobj->next);
1728  return sobj->next;
1729  } else {
1730  return SWIG_Py_Void();
1731  }
1732 }
1733 
1734 SWIGINTERN PyObject*
1735 #ifdef METH_NOARGS
1736 SwigPyObject_disown(PyObject *v)
1737 #else
1738 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1739 #endif
1740 {
1741  SwigPyObject *sobj = (SwigPyObject *)v;
1742  sobj->own = 0;
1743  return SWIG_Py_Void();
1744 }
1745 
1746 SWIGINTERN PyObject*
1747 #ifdef METH_NOARGS
1748 SwigPyObject_acquire(PyObject *v)
1749 #else
1750 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1751 #endif
1752 {
1753  SwigPyObject *sobj = (SwigPyObject *)v;
1754  sobj->own = SWIG_POINTER_OWN;
1755  return SWIG_Py_Void();
1756 }
1757 
1758 SWIGINTERN PyObject*
1759 SwigPyObject_own(PyObject *v, PyObject *args)
1760 {
1761  PyObject *val = 0;
1762 #if (PY_VERSION_HEX < 0x02020000)
1763  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1764 #elif (PY_VERSION_HEX < 0x02050000)
1765  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1766 #else
1767  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1768 #endif
1769  {
1770  return NULL;
1771  }
1772  else
1773  {
1774  SwigPyObject *sobj = (SwigPyObject *)v;
1775  PyObject *obj = PyBool_FromLong(sobj->own);
1776  if (val) {
1777 #ifdef METH_NOARGS
1778  if (PyObject_IsTrue(val)) {
1780  } else {
1782  }
1783 #else
1784  if (PyObject_IsTrue(val)) {
1785  SwigPyObject_acquire(v,args);
1786  } else {
1787  SwigPyObject_disown(v,args);
1788  }
1789 #endif
1790  }
1791  return obj;
1792  }
1793 }
1794 
1795 #ifdef METH_O
1796 static PyMethodDef
1797 swigobject_methods[] = {
1798  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1799  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1800  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1801  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1802  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1803  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1804  {0, 0, 0, 0}
1805 };
1806 #else
1807 static PyMethodDef
1808 swigobject_methods[] = {
1809  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1810  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1811  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1812  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1813  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1814  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1815  {0, 0, 0, 0}
1816 };
1817 #endif
1818 
1819 #if PY_VERSION_HEX < 0x02020000
1820 SWIGINTERN PyObject *
1822 {
1823  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1824 }
1825 #endif
1826 
1827 SWIGRUNTIME PyTypeObject*
1829  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1830 
1831  static PyNumberMethods SwigPyObject_as_number = {
1832  (binaryfunc)0, /*nb_add*/
1833  (binaryfunc)0, /*nb_subtract*/
1834  (binaryfunc)0, /*nb_multiply*/
1835  /* nb_divide removed in Python 3 */
1836 #if PY_VERSION_HEX < 0x03000000
1837  (binaryfunc)0, /*nb_divide*/
1838 #endif
1839  (binaryfunc)0, /*nb_remainder*/
1840  (binaryfunc)0, /*nb_divmod*/
1841  (ternaryfunc)0,/*nb_power*/
1842  (unaryfunc)0, /*nb_negative*/
1843  (unaryfunc)0, /*nb_positive*/
1844  (unaryfunc)0, /*nb_absolute*/
1845  (inquiry)0, /*nb_nonzero*/
1846  0, /*nb_invert*/
1847  0, /*nb_lshift*/
1848  0, /*nb_rshift*/
1849  0, /*nb_and*/
1850  0, /*nb_xor*/
1851  0, /*nb_or*/
1852 #if PY_VERSION_HEX < 0x03000000
1853  0, /*nb_coerce*/
1854 #endif
1855  (unaryfunc)SwigPyObject_long, /*nb_int*/
1856 #if PY_VERSION_HEX < 0x03000000
1857  (unaryfunc)SwigPyObject_long, /*nb_long*/
1858 #else
1859  0, /*nb_reserved*/
1860 #endif
1861  (unaryfunc)0, /*nb_float*/
1862 #if PY_VERSION_HEX < 0x03000000
1863  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1864  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1865 #endif
1866 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1867  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1868 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1869  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1870 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1871  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1872 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1873  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1874 #endif
1875  };
1876 
1877  static PyTypeObject swigpyobject_type;
1878  static int type_init = 0;
1879  if (!type_init) {
1880  const PyTypeObject tmp = {
1881  /* PyObject header changed in Python 3 */
1882 #if PY_VERSION_HEX >= 0x03000000
1883  PyVarObject_HEAD_INIT(NULL, 0)
1884 #else
1885  PyObject_HEAD_INIT(NULL)
1886  0, /* ob_size */
1887 #endif
1888  (char *)"SwigPyObject", /* tp_name */
1889  sizeof(SwigPyObject), /* tp_basicsize */
1890  0, /* tp_itemsize */
1891  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1892  (printfunc)SwigPyObject_print, /* tp_print */
1893 #if PY_VERSION_HEX < 0x02020000
1894  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1895 #else
1896  (getattrfunc)0, /* tp_getattr */
1897 #endif
1898  (setattrfunc)0, /* tp_setattr */
1899 #if PY_VERSION_HEX >= 0x03000000
1900  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1901 #else
1902  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1903 #endif
1904  (reprfunc)SwigPyObject_repr, /* tp_repr */
1905  &SwigPyObject_as_number, /* tp_as_number */
1906  0, /* tp_as_sequence */
1907  0, /* tp_as_mapping */
1908  (hashfunc)0, /* tp_hash */
1909  (ternaryfunc)0, /* tp_call */
1910  (reprfunc)SwigPyObject_str, /* tp_str */
1911  PyObject_GenericGetAttr, /* tp_getattro */
1912  0, /* tp_setattro */
1913  0, /* tp_as_buffer */
1914  Py_TPFLAGS_DEFAULT, /* tp_flags */
1915  swigobject_doc, /* tp_doc */
1916  0, /* tp_traverse */
1917  0, /* tp_clear */
1918  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1919  0, /* tp_weaklistoffset */
1920 #if PY_VERSION_HEX >= 0x02020000
1921  0, /* tp_iter */
1922  0, /* tp_iternext */
1923  swigobject_methods, /* tp_methods */
1924  0, /* tp_members */
1925  0, /* tp_getset */
1926  0, /* tp_base */
1927  0, /* tp_dict */
1928  0, /* tp_descr_get */
1929  0, /* tp_descr_set */
1930  0, /* tp_dictoffset */
1931  0, /* tp_init */
1932  0, /* tp_alloc */
1933  0, /* tp_new */
1934  0, /* tp_free */
1935  0, /* tp_is_gc */
1936  0, /* tp_bases */
1937  0, /* tp_mro */
1938  0, /* tp_cache */
1939  0, /* tp_subclasses */
1940  0, /* tp_weaklist */
1941 #endif
1942 #if PY_VERSION_HEX >= 0x02030000
1943  0, /* tp_del */
1944 #endif
1945 #if PY_VERSION_HEX >= 0x02060000
1946  0, /* tp_version */
1947 #endif
1948 #ifdef COUNT_ALLOCS
1949  0,0,0,0 /* tp_alloc -> tp_next */
1950 #endif
1951  };
1952  swigpyobject_type = tmp;
1953  type_init = 1;
1954 #if PY_VERSION_HEX < 0x02020000
1955  swigpyobject_type.ob_type = &PyType_Type;
1956 #else
1957  if (PyType_Ready(&swigpyobject_type) < 0)
1958  return NULL;
1959 #endif
1960  }
1961  return &swigpyobject_type;
1962 }
1963 
1964 SWIGRUNTIME PyObject *
1965 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1966 {
1967  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1968  if (sobj) {
1969  sobj->ptr = ptr;
1970  sobj->ty = ty;
1971  sobj->own = own;
1972  sobj->next = 0;
1973  }
1974  return (PyObject *)sobj;
1975 }
1976 
1977 /* -----------------------------------------------------------------------------
1978  * Implements a simple Swig Packed type, and use it instead of string
1979  * ----------------------------------------------------------------------------- */
1980 
1981 typedef struct {
1982  PyObject_HEAD
1983  void *pack;
1985  size_t size;
1986 } SwigPyPacked;
1987 
1988 SWIGRUNTIME int
1990 {
1991  char result[SWIG_BUFFER_SIZE];
1992  fputs("<Swig Packed ", fp);
1993  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1994  fputs("at ", fp);
1995  fputs(result, fp);
1996  }
1997  fputs(v->ty->name,fp);
1998  fputs(">", fp);
1999  return 0;
2000 }
2001 
2002 SWIGRUNTIME PyObject *
2004 {
2005  char result[SWIG_BUFFER_SIZE];
2006  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2007  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2008  } else {
2009  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2010  }
2011 }
2012 
2013 SWIGRUNTIME PyObject *
2015 {
2016  char result[SWIG_BUFFER_SIZE];
2017  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2018  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2019  } else {
2020  return SWIG_Python_str_FromChar(v->ty->name);
2021  }
2022 }
2023 
2024 SWIGRUNTIME int
2026 {
2027  size_t i = v->size;
2028  size_t j = w->size;
2029  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2030  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2031 }
2032 
2033 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2034 
2035 SWIGRUNTIME PyTypeObject*
2037  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2038  return type;
2039 }
2040 
2042 SwigPyPacked_Check(PyObject *op) {
2043  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2044  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2045 }
2046 
2047 SWIGRUNTIME void
2049 {
2050  if (SwigPyPacked_Check(v)) {
2051  SwigPyPacked *sobj = (SwigPyPacked *) v;
2052  free(sobj->pack);
2053  }
2054  PyObject_DEL(v);
2055 }
2056 
2057 SWIGRUNTIME PyTypeObject*
2059  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2060  static PyTypeObject swigpypacked_type;
2061  static int type_init = 0;
2062  if (!type_init) {
2063  const PyTypeObject tmp = {
2064  /* PyObject header changed in Python 3 */
2065 #if PY_VERSION_HEX>=0x03000000
2066  PyVarObject_HEAD_INIT(NULL, 0)
2067 #else
2068  PyObject_HEAD_INIT(NULL)
2069  0, /* ob_size */
2070 #endif
2071  (char *)"SwigPyPacked", /* tp_name */
2072  sizeof(SwigPyPacked), /* tp_basicsize */
2073  0, /* tp_itemsize */
2074  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2075  (printfunc)SwigPyPacked_print, /* tp_print */
2076  (getattrfunc)0, /* tp_getattr */
2077  (setattrfunc)0, /* tp_setattr */
2078 #if PY_VERSION_HEX>=0x03000000
2079  0, /* tp_reserved in 3.0.1 */
2080 #else
2081  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2082 #endif
2083  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2084  0, /* tp_as_number */
2085  0, /* tp_as_sequence */
2086  0, /* tp_as_mapping */
2087  (hashfunc)0, /* tp_hash */
2088  (ternaryfunc)0, /* tp_call */
2089  (reprfunc)SwigPyPacked_str, /* tp_str */
2090  PyObject_GenericGetAttr, /* tp_getattro */
2091  0, /* tp_setattro */
2092  0, /* tp_as_buffer */
2093  Py_TPFLAGS_DEFAULT, /* tp_flags */
2094  swigpacked_doc, /* tp_doc */
2095  0, /* tp_traverse */
2096  0, /* tp_clear */
2097  0, /* tp_richcompare */
2098  0, /* tp_weaklistoffset */
2099 #if PY_VERSION_HEX >= 0x02020000
2100  0, /* tp_iter */
2101  0, /* tp_iternext */
2102  0, /* tp_methods */
2103  0, /* tp_members */
2104  0, /* tp_getset */
2105  0, /* tp_base */
2106  0, /* tp_dict */
2107  0, /* tp_descr_get */
2108  0, /* tp_descr_set */
2109  0, /* tp_dictoffset */
2110  0, /* tp_init */
2111  0, /* tp_alloc */
2112  0, /* tp_new */
2113  0, /* tp_free */
2114  0, /* tp_is_gc */
2115  0, /* tp_bases */
2116  0, /* tp_mro */
2117  0, /* tp_cache */
2118  0, /* tp_subclasses */
2119  0, /* tp_weaklist */
2120 #endif
2121 #if PY_VERSION_HEX >= 0x02030000
2122  0, /* tp_del */
2123 #endif
2124 #if PY_VERSION_HEX >= 0x02060000
2125  0, /* tp_version */
2126 #endif
2127 #ifdef COUNT_ALLOCS
2128  0,0,0,0 /* tp_alloc -> tp_next */
2129 #endif
2130  };
2131  swigpypacked_type = tmp;
2132  type_init = 1;
2133 #if PY_VERSION_HEX < 0x02020000
2134  swigpypacked_type.ob_type = &PyType_Type;
2135 #else
2136  if (PyType_Ready(&swigpypacked_type) < 0)
2137  return NULL;
2138 #endif
2139  }
2140  return &swigpypacked_type;
2141 }
2142 
2143 SWIGRUNTIME PyObject *
2144 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2145 {
2146  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2147  if (sobj) {
2148  void *pack = malloc(size);
2149  if (pack) {
2150  memcpy(pack, ptr, size);
2151  sobj->pack = pack;
2152  sobj->ty = ty;
2153  sobj->size = size;
2154  } else {
2155  PyObject_DEL((PyObject *) sobj);
2156  sobj = 0;
2157  }
2158  }
2159  return (PyObject *) sobj;
2160 }
2161 
2163 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2164 {
2165  if (SwigPyPacked_Check(obj)) {
2166  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2167  if (sobj->size != size) return 0;
2168  memcpy(ptr, sobj->pack, size);
2169  return sobj->ty;
2170  } else {
2171  return 0;
2172  }
2173 }
2174 
2175 /* -----------------------------------------------------------------------------
2176  * pointers/data manipulation
2177  * ----------------------------------------------------------------------------- */
2178 
2179 SWIGRUNTIMEINLINE PyObject *
2181 {
2182  return SWIG_Python_str_FromChar("this");
2183 }
2184 
2185 static PyObject *swig_this = NULL;
2186 
2187 SWIGRUNTIME PyObject *
2189 {
2190  if (swig_this == NULL)
2191  swig_this = _SWIG_This();
2192  return swig_this;
2193 }
2194 
2195 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2196 
2197 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2198 #if PY_VERSION_HEX>=0x03000000
2199 #define SWIG_PYTHON_SLOW_GETSET_THIS
2200 #endif
2201 
2203 SWIG_Python_GetSwigThis(PyObject *pyobj)
2204 {
2205  PyObject *obj;
2206 
2207  if (SwigPyObject_Check(pyobj))
2208  return (SwigPyObject *) pyobj;
2209 
2210 #ifdef SWIGPYTHON_BUILTIN
2211  (void)obj;
2212 # ifdef PyWeakref_CheckProxy
2213  if (PyWeakref_CheckProxy(pyobj)) {
2214  pyobj = PyWeakref_GET_OBJECT(pyobj);
2215  if (pyobj && SwigPyObject_Check(pyobj))
2216  return (SwigPyObject*) pyobj;
2217  }
2218 # endif
2219  return NULL;
2220 #else
2221 
2222  obj = 0;
2223 
2224 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2225  if (PyInstance_Check(pyobj)) {
2226  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2227  } else {
2228  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2229  if (dictptr != NULL) {
2230  PyObject *dict = *dictptr;
2231  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2232  } else {
2233 #ifdef PyWeakref_CheckProxy
2234  if (PyWeakref_CheckProxy(pyobj)) {
2235  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2236  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2237  }
2238 #endif
2239  obj = PyObject_GetAttr(pyobj,SWIG_This());
2240  if (obj) {
2241  Py_DECREF(obj);
2242  } else {
2243  if (PyErr_Occurred()) PyErr_Clear();
2244  return 0;
2245  }
2246  }
2247  }
2248 #else
2249  obj = PyObject_GetAttr(pyobj,SWIG_This());
2250  if (obj) {
2251  Py_DECREF(obj);
2252  } else {
2253  if (PyErr_Occurred()) PyErr_Clear();
2254  return 0;
2255  }
2256 #endif
2257  if (obj && !SwigPyObject_Check(obj)) {
2258  /* a PyObject is called 'this', try to get the 'real this'
2259  SwigPyObject from it */
2260  return SWIG_Python_GetSwigThis(obj);
2261  }
2262  return (SwigPyObject *)obj;
2263 #endif
2264 }
2265 
2266 /* Acquire a pointer value */
2267 
2268 SWIGRUNTIME int
2269 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2270  if (own == SWIG_POINTER_OWN) {
2272  if (sobj) {
2273  int oldown = sobj->own;
2274  sobj->own = own;
2275  return oldown;
2276  }
2277  }
2278  return 0;
2279 }
2280 
2281 /* Convert a pointer value */
2282 
2283 SWIGRUNTIME int
2284 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2285  int res;
2286  SwigPyObject *sobj;
2287 
2288  if (!obj)
2289  return SWIG_ERROR;
2290  if (obj == Py_None) {
2291  if (ptr)
2292  *ptr = 0;
2293  return SWIG_OK;
2294  }
2295 
2296  res = SWIG_ERROR;
2297 
2298  sobj = SWIG_Python_GetSwigThis(obj);
2299  if (own)
2300  *own = 0;
2301  while (sobj) {
2302  void *vptr = sobj->ptr;
2303  if (ty) {
2304  swig_type_info *to = sobj->ty;
2305  if (to == ty) {
2306  /* no type cast needed */
2307  if (ptr) *ptr = vptr;
2308  break;
2309  } else {
2310  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2311  if (!tc) {
2312  sobj = (SwigPyObject *)sobj->next;
2313  } else {
2314  if (ptr) {
2315  int newmemory = 0;
2316  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2317  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2318  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2319  if (own)
2320  *own = *own | SWIG_CAST_NEW_MEMORY;
2321  }
2322  }
2323  break;
2324  }
2325  }
2326  } else {
2327  if (ptr) *ptr = vptr;
2328  break;
2329  }
2330  }
2331  if (sobj) {
2332  if (own)
2333  *own = *own | sobj->own;
2334  if (flags & SWIG_POINTER_DISOWN) {
2335  sobj->own = 0;
2336  }
2337  res = SWIG_OK;
2338  } else {
2339  if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2340  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2341  if (data && !data->implicitconv) {
2342  PyObject *klass = data->klass;
2343  if (klass) {
2344  PyObject *impconv;
2345  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2346  impconv = SWIG_Python_CallFunctor(klass, obj);
2347  data->implicitconv = 0;
2348  if (PyErr_Occurred()) {
2349  PyErr_Clear();
2350  impconv = 0;
2351  }
2352  if (impconv) {
2353  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2354  if (iobj) {
2355  void *vptr;
2356  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2357  if (SWIG_IsOK(res)) {
2358  if (ptr) {
2359  *ptr = vptr;
2360  /* transfer the ownership to 'ptr' */
2361  iobj->own = 0;
2362  res = SWIG_AddCast(res);
2363  res = SWIG_AddNewMask(res);
2364  } else {
2365  res = SWIG_AddCast(res);
2366  }
2367  }
2368  }
2369  Py_DECREF(impconv);
2370  }
2371  }
2372  }
2373  }
2374  }
2375  return res;
2376 }
2377 
2378 /* Convert a function ptr value */
2379 
2380 SWIGRUNTIME int
2381 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2382  if (!PyCFunction_Check(obj)) {
2383  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2384  } else {
2385  void *vptr = 0;
2386 
2387  /* here we get the method pointer for callbacks */
2388  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2389  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2390  if (desc)
2391  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2392  if (!desc)
2393  return SWIG_ERROR;
2394  if (ty) {
2395  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2396  if (tc) {
2397  int newmemory = 0;
2398  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2399  assert(!newmemory); /* newmemory handling not yet implemented */
2400  } else {
2401  return SWIG_ERROR;
2402  }
2403  } else {
2404  *ptr = vptr;
2405  }
2406  return SWIG_OK;
2407  }
2408 }
2409 
2410 /* Convert a packed value value */
2411 
2412 SWIGRUNTIME int
2413 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2414  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2415  if (!to) return SWIG_ERROR;
2416  if (ty) {
2417  if (to != ty) {
2418  /* check type cast? */
2419  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2420  if (!tc) return SWIG_ERROR;
2421  }
2422  }
2423  return SWIG_OK;
2424 }
2425 
2426 /* -----------------------------------------------------------------------------
2427  * Create a new pointer object
2428  * ----------------------------------------------------------------------------- */
2429 
2430 /*
2431  Create a new instance object, without calling __init__, and set the
2432  'this' attribute.
2433 */
2434 
2435 SWIGRUNTIME PyObject*
2437 {
2438 #if (PY_VERSION_HEX >= 0x02020000)
2439  PyObject *inst = 0;
2440  PyObject *newraw = data->newraw;
2441  if (newraw) {
2442  inst = PyObject_Call(newraw, data->newargs, NULL);
2443  if (inst) {
2444 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2445  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2446  if (dictptr != NULL) {
2447  PyObject *dict = *dictptr;
2448  if (dict == NULL) {
2449  dict = PyDict_New();
2450  *dictptr = dict;
2451  PyDict_SetItem(dict, SWIG_This(), swig_this);
2452  }
2453  }
2454 #else
2455  PyObject *key = SWIG_This();
2456  PyObject_SetAttr(inst, key, swig_this);
2457 #endif
2458  }
2459  } else {
2460 #if PY_VERSION_HEX >= 0x03000000
2461  inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2462  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2463  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2464 #else
2465  PyObject *dict = PyDict_New();
2466  PyDict_SetItem(dict, SWIG_This(), swig_this);
2467  inst = PyInstance_NewRaw(data->newargs, dict);
2468  Py_DECREF(dict);
2469 #endif
2470  }
2471  return inst;
2472 #else
2473 #if (PY_VERSION_HEX >= 0x02010000)
2474  PyObject *inst;
2475  PyObject *dict = PyDict_New();
2476  PyDict_SetItem(dict, SWIG_This(), swig_this);
2477  inst = PyInstance_NewRaw(data->newargs, dict);
2478  Py_DECREF(dict);
2479  return (PyObject *) inst;
2480 #else
2481  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2482  if (inst == NULL) {
2483  return NULL;
2484  }
2485  inst->in_class = (PyClassObject *)data->newargs;
2486  Py_INCREF(inst->in_class);
2487  inst->in_dict = PyDict_New();
2488  if (inst->in_dict == NULL) {
2489  Py_DECREF(inst);
2490  return NULL;
2491  }
2492 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2493  inst->in_weakreflist = NULL;
2494 #endif
2495 #ifdef Py_TPFLAGS_GC
2496  PyObject_GC_Init(inst);
2497 #endif
2498  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2499  return (PyObject *) inst;
2500 #endif
2501 #endif
2502 }
2503 
2504 SWIGRUNTIME void
2505 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2506 {
2507  PyObject *dict;
2508 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2509  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2510  if (dictptr != NULL) {
2511  dict = *dictptr;
2512  if (dict == NULL) {
2513  dict = PyDict_New();
2514  *dictptr = dict;
2515  }
2516  PyDict_SetItem(dict, SWIG_This(), swig_this);
2517  return;
2518  }
2519 #endif
2520  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2521  PyDict_SetItem(dict, SWIG_This(), swig_this);
2522  Py_DECREF(dict);
2523 }
2524 
2525 
2526 SWIGINTERN PyObject *
2528  PyObject *obj[2];
2529  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2530  return NULL;
2531  } else {
2532  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2533  if (sthis) {
2534  SwigPyObject_append((PyObject*) sthis, obj[1]);
2535  } else {
2536  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2537  }
2538  return SWIG_Py_Void();
2539  }
2540 }
2541 
2542 /* Create a new pointer object */
2543 
2544 SWIGRUNTIME PyObject *
2545 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2546  SwigPyClientData *clientdata;
2547  PyObject * robj;
2548  int own;
2549 
2550  if (!ptr)
2551  return SWIG_Py_Void();
2552 
2553  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2554  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2555  if (clientdata && clientdata->pytype) {
2556  SwigPyObject *newobj;
2557  if (flags & SWIG_BUILTIN_TP_INIT) {
2558  newobj = (SwigPyObject*) self;
2559  if (newobj->ptr) {
2560  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2561  while (newobj->next)
2562  newobj = (SwigPyObject *) newobj->next;
2563  newobj->next = next_self;
2564  newobj = (SwigPyObject *)next_self;
2565  }
2566  } else {
2567  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2568  }
2569  if (newobj) {
2570  newobj->ptr = ptr;
2571  newobj->ty = type;
2572  newobj->own = own;
2573  newobj->next = 0;
2574 #ifdef SWIGPYTHON_BUILTIN
2575  newobj->dict = 0;
2576 #endif
2577  return (PyObject*) newobj;
2578  }
2579  return SWIG_Py_Void();
2580  }
2581 
2582  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2583 
2584  robj = SwigPyObject_New(ptr, type, own);
2585  if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2586  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2587  if (inst) {
2588  Py_DECREF(robj);
2589  robj = inst;
2590  }
2591  }
2592  return robj;
2593 }
2594 
2595 /* Create a new packed object */
2596 
2597 SWIGRUNTIMEINLINE PyObject *
2598 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2599  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2600 }
2601 
2602 /* -----------------------------------------------------------------------------*
2603  * Get type list
2604  * -----------------------------------------------------------------------------*/
2605 
2606 #ifdef SWIG_LINK_RUNTIME
2607 void *SWIG_ReturnGlobalTypeList(void *);
2608 #endif
2609 
2612  static void *type_pointer = (void *)0;
2613  /* first check if module already created */
2614  if (!type_pointer) {
2615 #ifdef SWIG_LINK_RUNTIME
2616  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2617 #else
2618 # ifdef SWIGPY_USE_CAPSULE
2619  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2620 # else
2621  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2622  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2623 # endif
2624  if (PyErr_Occurred()) {
2625  PyErr_Clear();
2626  type_pointer = (void *)0;
2627  }
2628 #endif
2629  }
2630  return (swig_module_info *) type_pointer;
2631 }
2632 
2633 #if PY_MAJOR_VERSION < 2
2634 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2635  is copied out of Python/modsupport.c in python version 2.3.4 */
2636 SWIGINTERN int
2637 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2638 {
2639  PyObject *dict;
2640  if (!PyModule_Check(m)) {
2641  PyErr_SetString(PyExc_TypeError,
2642  "PyModule_AddObject() needs module as first arg");
2643  return SWIG_ERROR;
2644  }
2645  if (!o) {
2646  PyErr_SetString(PyExc_TypeError,
2647  "PyModule_AddObject() needs non-NULL value");
2648  return SWIG_ERROR;
2649  }
2650 
2651  dict = PyModule_GetDict(m);
2652  if (dict == NULL) {
2653  /* Internal error -- modules must have a dict! */
2654  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2655  PyModule_GetName(m));
2656  return SWIG_ERROR;
2657  }
2658  if (PyDict_SetItemString(dict, name, o))
2659  return SWIG_ERROR;
2660  Py_DECREF(o);
2661  return SWIG_OK;
2662 }
2663 #endif
2664 
2665 SWIGRUNTIME void
2666 #ifdef SWIGPY_USE_CAPSULE
2667 SWIG_Python_DestroyModule(PyObject *obj)
2668 #else
2670 #endif
2671 {
2672 #ifdef SWIGPY_USE_CAPSULE
2673  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2674 #else
2675  swig_module_info *swig_module = (swig_module_info *) vptr;
2676 #endif
2677  swig_type_info **types = swig_module->types;
2678  size_t i;
2679  for (i =0; i < swig_module->size; ++i) {
2680  swig_type_info *ty = types[i];
2681  if (ty->owndata) {
2683  if (data) SwigPyClientData_Del(data);
2684  }
2685  }
2686  Py_DECREF(SWIG_This());
2687  swig_this = NULL;
2688 }
2689 
2690 SWIGRUNTIME void
2692 #if PY_VERSION_HEX >= 0x03000000
2693  /* Add a dummy module object into sys.modules */
2694  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2695 #else
2696  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2697  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2698 #endif
2699 #ifdef SWIGPY_USE_CAPSULE
2700  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2701  if (pointer && module) {
2702  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2703  } else {
2704  Py_XDECREF(pointer);
2705  }
2706 #else
2707  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2708  if (pointer && module) {
2709  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2710  } else {
2711  Py_XDECREF(pointer);
2712  }
2713 #endif
2714 }
2715 
2716 /* The python cached type query */
2717 SWIGRUNTIME PyObject *
2719  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2720  return cache;
2721 }
2722 
2724 SWIG_Python_TypeQuery(const char *type)
2725 {
2726  PyObject *cache = SWIG_Python_TypeCache();
2727  PyObject *key = SWIG_Python_str_FromChar(type);
2728  PyObject *obj = PyDict_GetItem(cache, key);
2729  swig_type_info *descriptor;
2730  if (obj) {
2731 #ifdef SWIGPY_USE_CAPSULE
2732  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2733 #else
2734  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2735 #endif
2736  } else {
2738  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2739  if (descriptor) {
2740 #ifdef SWIGPY_USE_CAPSULE
2741  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2742 #else
2743  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2744 #endif
2745  PyDict_SetItem(cache, key, obj);
2746  Py_DECREF(obj);
2747  }
2748  }
2749  Py_DECREF(key);
2750  return descriptor;
2751 }
2752 
2753 /*
2754  For backward compatibility only
2755 */
2756 #define SWIG_POINTER_EXCEPTION 0
2757 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2758 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2759 
2760 SWIGRUNTIME int
2761 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2762 {
2763  if (PyErr_Occurred()) {
2764  PyObject *type = 0;
2765  PyObject *value = 0;
2766  PyObject *traceback = 0;
2767  PyErr_Fetch(&type, &value, &traceback);
2768  if (value) {
2769  char *tmp;
2770  PyObject *old_str = PyObject_Str(value);
2771  Py_XINCREF(type);
2772  PyErr_Clear();
2773  if (infront) {
2774  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2775  } else {
2776  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2777  }
2779  Py_DECREF(old_str);
2780  }
2781  return 1;
2782  } else {
2783  return 0;
2784  }
2785 }
2786 
2787 SWIGRUNTIME int
2789 {
2790  if (PyErr_Occurred()) {
2791  /* add information about failing argument */
2792  char mesg[256];
2793  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2794  return SWIG_Python_AddErrMesg(mesg, 1);
2795  } else {
2796  return 0;
2797  }
2798 }
2799 
2800 SWIGRUNTIMEINLINE const char *
2801 SwigPyObject_GetDesc(PyObject *self)
2802 {
2803  SwigPyObject *v = (SwigPyObject *)self;
2804  swig_type_info *ty = v ? v->ty : 0;
2805  return ty ? ty->str : "";
2806 }
2807 
2808 SWIGRUNTIME void
2809 SWIG_Python_TypeError(const char *type, PyObject *obj)
2810 {
2811  if (type) {
2812 #if defined(SWIG_COBJECT_TYPES)
2813  if (obj && SwigPyObject_Check(obj)) {
2814  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2815  if (otype) {
2816  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2817  type, otype);
2818  return;
2819  }
2820  } else
2821 #endif
2822  {
2823  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2824  if (otype) {
2825  PyObject *str = PyObject_Str(obj);
2826  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2827  if (cstr) {
2828  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2829  type, otype, cstr);
2831  } else {
2832  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2833  type, otype);
2834  }
2835  Py_XDECREF(str);
2836  return;
2837  }
2838  }
2839  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2840  } else {
2841  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2842  }
2843 }
2844 
2845 
2846 /* Convert a pointer value, signal an exception on a type mismatch */
2847 SWIGRUNTIME void *
2848 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2849  void *result;
2850  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2851  PyErr_Clear();
2852 #if SWIG_POINTER_EXCEPTION
2853  if (flags) {
2855  SWIG_Python_ArgFail(argnum);
2856  }
2857 #endif
2858  }
2859  return result;
2860 }
2861 
2862 #ifdef SWIGPYTHON_BUILTIN
2863 SWIGRUNTIME int
2864 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2865  PyTypeObject *tp = obj->ob_type;
2866  PyObject *descr;
2867  PyObject *encoded_name;
2868  descrsetfunc f;
2869  int res;
2870 
2871 # ifdef Py_USING_UNICODE
2872  if (PyString_Check(name)) {
2873  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2874  if (!name)
2875  return -1;
2876  } else if (!PyUnicode_Check(name))
2877 # else
2878  if (!PyString_Check(name))
2879 # endif
2880  {
2881  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2882  return -1;
2883  } else {
2884  Py_INCREF(name);
2885  }
2886 
2887  if (!tp->tp_dict) {
2888  if (PyType_Ready(tp) < 0)
2889  goto done;
2890  }
2891 
2892  res = -1;
2893  descr = _PyType_Lookup(tp, name);
2894  f = NULL;
2895  if (descr != NULL)
2896  f = descr->ob_type->tp_descr_set;
2897  if (!f) {
2898  if (PyString_Check(name)) {
2899  encoded_name = name;
2900  Py_INCREF(name);
2901  } else {
2902  encoded_name = PyUnicode_AsUTF8String(name);
2903  }
2904  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2905  Py_DECREF(encoded_name);
2906  } else {
2907  res = f(descr, obj, value);
2908  }
2909 
2910  done:
2911  Py_DECREF(name);
2912  return res;
2913 }
2914 #endif
2915 
2916 
2917 #ifdef __cplusplus
2918 }
2919 #endif
2920 
2921 
2922 
2923 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2924 
2925 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2926 
2927 
2928 
2929 /* -------- TYPES TABLE (BEGIN) -------- */
2930 
2931 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2932 #define SWIGTYPE_p_PLcGrid swig_types[1]
2933 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2934 #define SWIGTYPE_p_char swig_types[3]
2935 #define SWIGTYPE_p_double swig_types[4]
2936 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2937 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2938 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2939 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2940 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2941 #define SWIGTYPE_p_int swig_types[10]
2942 #define SWIGTYPE_p_p_char swig_types[11]
2943 #define SWIGTYPE_p_p_double swig_types[12]
2944 #define SWIGTYPE_p_unsigned_int swig_types[13]
2946 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2947 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2948 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2949 
2950 /* -------- TYPES TABLE (END) -------- */
2951 
2952 #if (PY_VERSION_HEX <= 0x02000000)
2953 # if !defined(SWIG_PYTHON_CLASSIC)
2954 # error "This python version requires swig to be run with the '-classic' option"
2955 # endif
2956 #endif
2957 
2958 /*-----------------------------------------------
2959  @(target):= _plplotc.so
2960  ------------------------------------------------*/
2961 #if PY_VERSION_HEX >= 0x03000000
2962 # define SWIG_init PyInit__plplotc
2963 
2964 #else
2965 # define SWIG_init init_plplotc
2966 
2967 #endif
2968 #define SWIG_name "_plplotc"
2969 
2970 #define SWIGVERSION 0x020007
2971 #define SWIG_VERSION SWIGVERSION
2972 
2973 
2974 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2975 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2976 
2977 
2978 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2979 #include <arrayobject.h>
2980 #include "plplot.h"
2981 #include "plplotP.h"
2982 
2983 #define NPY_PLINT NPY_INT32
2984 
2985 #ifdef PL_DOUBLE
2986 #define NPY_PLFLT NPY_FLOAT64
2987 #else
2988 #define NPY_PLFLT NPY_FLOAT32
2989 #endif
2990 
2991 // python-1.5 compatibility mode?
2992 #if !defined ( PySequence_Fast_GET_ITEM )
2993  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2994 #endif
2995 #define PySequence_Size PySequence_Length
2996 
2997 
2998  static PLINT Alen = 0;
2999  static PLINT Xlen = 0, Ylen = 0;
3000 
3001 
3002 SWIGINTERN int
3003 SWIG_AsVal_double (PyObject *obj, double *val)
3004 {
3005  int res = SWIG_TypeError;
3006  if (PyFloat_Check(obj)) {
3007  if (val) *val = PyFloat_AsDouble(obj);
3008  return SWIG_OK;
3009  } else if (PyInt_Check(obj)) {
3010  if (val) *val = PyInt_AsLong(obj);
3011  return SWIG_OK;
3012  } else if (PyLong_Check(obj)) {
3013  double v = PyLong_AsDouble(obj);
3014  if (!PyErr_Occurred()) {
3015  if (val) *val = v;
3016  return SWIG_OK;
3017  } else {
3018  PyErr_Clear();
3019  }
3020  }
3021 #ifdef SWIG_PYTHON_CAST_MODE
3022  {
3023  int dispatch = 0;
3024  double d = PyFloat_AsDouble(obj);
3025  if (!PyErr_Occurred()) {
3026  if (val) *val = d;
3027  return SWIG_AddCast(SWIG_OK);
3028  } else {
3029  PyErr_Clear();
3030  }
3031  if (!dispatch) {
3032  long v = PyLong_AsLong(obj);
3033  if (!PyErr_Occurred()) {
3034  if (val) *val = v;
3036  } else {
3037  PyErr_Clear();
3038  }
3039  }
3040  }
3041 #endif
3042  return res;
3043 }
3044 
3045 
3046  #define SWIG_From_double PyFloat_FromDouble
3047 
3048 
3049  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3050  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3051  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3052  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3053  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3055  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3056 
3057 
3058 SWIGINTERNINLINE PyObject*
3059  SWIG_From_int (int value)
3060 {
3061  return PyInt_FromLong((long) value);
3062 }
3063 
3064 
3065 #include <limits.h>
3066 #if !defined(SWIG_NO_LLONG_MAX)
3067 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3068 # define LLONG_MAX __LONG_LONG_MAX__
3069 # define LLONG_MIN (-LLONG_MAX - 1LL)
3070 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3071 # endif
3072 #endif
3073 
3074 
3075 #include <float.h>
3076 
3077 
3078 #include <math.h>
3079 
3080 
3081 SWIGINTERNINLINE int
3082 SWIG_CanCastAsInteger(double *d, double min, double max) {
3083  double x = *d;
3084  if ((min <= x && x <= max)) {
3085  double fx = floor(x);
3086  double cx = ceil(x);
3087  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3088  if ((errno == EDOM) || (errno == ERANGE)) {
3089  errno = 0;
3090  } else {
3091  double summ, reps, diff;
3092  if (rd < x) {
3093  diff = x - rd;
3094  } else if (rd > x) {
3095  diff = rd - x;
3096  } else {
3097  return 1;
3098  }
3099  summ = rd + x;
3100  reps = diff/summ;
3101  if (reps < 8*DBL_EPSILON) {
3102  *d = rd;
3103  return 1;
3104  }
3105  }
3106  }
3107  return 0;
3108 }
3109 
3110 
3111 SWIGINTERN int
3112 SWIG_AsVal_long (PyObject *obj, long* val)
3113 {
3114  if (PyInt_Check(obj)) {
3115  if (val) *val = PyInt_AsLong(obj);
3116  return SWIG_OK;
3117  } else if (PyLong_Check(obj)) {
3118  long v = PyLong_AsLong(obj);
3119  if (!PyErr_Occurred()) {
3120  if (val) *val = v;
3121  return SWIG_OK;
3122  } else {
3123  PyErr_Clear();
3124  }
3125  }
3126 #ifdef SWIG_PYTHON_CAST_MODE
3127  {
3128  int dispatch = 0;
3129  long v = PyInt_AsLong(obj);
3130  if (!PyErr_Occurred()) {
3131  if (val) *val = v;
3132  return SWIG_AddCast(SWIG_OK);
3133  } else {
3134  PyErr_Clear();
3135  }
3136  if (!dispatch) {
3137  double d;
3138  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3139  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3140  if (val) *val = (long)(d);
3141  return res;
3142  }
3143  }
3144  }
3145 #endif
3146  return SWIG_TypeError;
3147 }
3148 
3149 
3150 SWIGINTERN int
3151 SWIG_AsVal_int (PyObject * obj, int *val)
3152 {
3153  long v;
3154  int res = SWIG_AsVal_long (obj, &v);
3155  if (SWIG_IsOK(res)) {
3156  if ((v < INT_MIN || v > INT_MAX)) {
3157  return SWIG_OverflowError;
3158  } else {
3159  if (val) *val = (int)(v);
3160  }
3161  }
3162  return res;
3163 }
3164 
3165 
3166 SWIGINTERN int
3167 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3168 {
3169  if (PyInt_Check(obj)) {
3170  long v = PyInt_AsLong(obj);
3171  if (v >= 0) {
3172  if (val) *val = v;
3173  return SWIG_OK;
3174  } else {
3175  return SWIG_OverflowError;
3176  }
3177  } else if (PyLong_Check(obj)) {
3178  unsigned long v = PyLong_AsUnsignedLong(obj);
3179  if (!PyErr_Occurred()) {
3180  if (val) *val = v;
3181  return SWIG_OK;
3182  } else {
3183  PyErr_Clear();
3184  }
3185  }
3186 #ifdef SWIG_PYTHON_CAST_MODE
3187  {
3188  int dispatch = 0;
3189  unsigned long v = PyLong_AsUnsignedLong(obj);
3190  if (!PyErr_Occurred()) {
3191  if (val) *val = v;
3192  return SWIG_AddCast(SWIG_OK);
3193  } else {
3194  PyErr_Clear();
3195  }
3196  if (!dispatch) {
3197  double d;
3198  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3199  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3200  if (val) *val = (unsigned long)(d);
3201  return res;
3202  }
3203  }
3204  }
3205 #endif
3206  return SWIG_TypeError;
3207 }
3208 
3209 
3210 SWIGINTERN int
3211 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3212 {
3213  unsigned long v;
3214  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3215  if (SWIG_IsOK(res)) {
3216  if ((v > UINT_MAX)) {
3217  return SWIG_OverflowError;
3218  } else {
3219  if (val) *val = (unsigned int)(v);
3220  }
3221  }
3222  return res;
3223 }
3224 
3225 
3226 SWIGINTERNINLINE PyObject*
3227  SWIG_From_unsigned_SS_int (unsigned int value)
3228 {
3229  return PyInt_FromSize_t((size_t) value);
3230 }
3231 
3232 
3235 {
3236  static int init = 0;
3237  static swig_type_info* info = 0;
3238  if (!init) {
3239  info = SWIG_TypeQuery("_p_char");
3240  init = 1;
3241  }
3242  return info;
3243 }
3244 
3245 
3246 SWIGINTERN int
3247 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3248 {
3249 #if PY_VERSION_HEX>=0x03000000
3250  if (PyUnicode_Check(obj))
3251 #else
3252  if (PyString_Check(obj))
3253 #endif
3254  {
3255  char *cstr; Py_ssize_t len;
3256 #if PY_VERSION_HEX>=0x03000000
3257  if (!alloc && cptr) {
3258  /* We can't allow converting without allocation, since the internal
3259  representation of string in Python 3 is UCS-2/UCS-4 but we require
3260  a UTF-8 representation.
3261  TODO(bhy) More detailed explanation */
3262  return SWIG_RuntimeError;
3263  }
3264  obj = PyUnicode_AsUTF8String(obj);
3265  PyBytes_AsStringAndSize(obj, &cstr, &len);
3266  if(alloc) *alloc = SWIG_NEWOBJ;
3267 #else
3268  PyString_AsStringAndSize(obj, &cstr, &len);
3269 #endif
3270  if (cptr) {
3271  if (alloc) {
3272  /*
3273  In python the user should not be able to modify the inner
3274  string representation. To warranty that, if you define
3275  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3276  buffer is always returned.
3277 
3278  The default behavior is just to return the pointer value,
3279  so, be careful.
3280  */
3281 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3282  if (*alloc != SWIG_OLDOBJ)
3283 #else
3284  if (*alloc == SWIG_NEWOBJ)
3285 #endif
3286  {
3287  *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3288  *alloc = SWIG_NEWOBJ;
3289  }
3290  else {
3291  *cptr = cstr;
3292  *alloc = SWIG_OLDOBJ;
3293  }
3294  } else {
3295  #if PY_VERSION_HEX>=0x03000000
3296  assert(0); /* Should never reach here in Python 3 */
3297  #endif
3298  *cptr = SWIG_Python_str_AsChar(obj);
3299  }
3300  }
3301  if (psize) *psize = len + 1;
3302 #if PY_VERSION_HEX>=0x03000000
3303  Py_XDECREF(obj);
3304 #endif
3305  return SWIG_OK;
3306  } else {
3307  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3308  if (pchar_descriptor) {
3309  void* vptr = 0;
3310  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3311  if (cptr) *cptr = (char *) vptr;
3312  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3313  if (alloc) *alloc = SWIG_OLDOBJ;
3314  return SWIG_OK;
3315  }
3316  }
3317  }
3318  return SWIG_TypeError;
3319 }
3320 
3321 
3322 SWIGINTERN int
3323 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3324 {
3325  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3326  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3327  if (SWIG_IsOK(res)) {
3328  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3329  if (csize <= size) {
3330  if (val) {
3331  if (csize) memcpy(val, cptr, csize*sizeof(char));
3332  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3333  }
3334  if (alloc == SWIG_NEWOBJ) {
3335  free((char*)cptr);
3336  res = SWIG_DelNewMask(res);
3337  }
3338  return res;
3339  }
3340  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3341  }
3342  return SWIG_TypeError;
3343 }
3344 
3345 
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3348 {
3349  if (carray) {
3350  if (size > INT_MAX) {
3351  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3352  return pchar_descriptor ?
3353  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3354  } else {
3355 #if PY_VERSION_HEX >= 0x03000000
3356  return PyUnicode_FromStringAndSize(carray, (int)(size));
3357 #else
3358  return PyString_FromStringAndSize(carray, (int)(size));
3359 #endif
3360  }
3361  } else {
3362  return SWIG_Py_Void();
3363  }
3364 }
3365 
3366 
3367 
3368 
3369 
3370 #define t_output_helper SWIG_Python_AppendOutput
3371 
3372 
3373 SWIGINTERN int
3374 SWIG_AsVal_char (PyObject * obj, char *val)
3375 {
3376  int res = SWIG_AsCharArray(obj, val, 1);
3377  if (!SWIG_IsOK(res)) {
3378  long v;
3379  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3380  if (SWIG_IsOK(res)) {
3381  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3382  if (val) *val = (char)(v);
3383  } else {
3384  res = SWIG_OverflowError;
3385  }
3386  }
3387  }
3388  return res;
3389 }
3390 
3391 #ifdef __cplusplus
3392 extern "C" {
3393 #endif
3394 
3395  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3396 
3397 // some really twisted stuff to allow calling a single precision library from python
3398  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3399  {
3400  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3401  mindims, maxdims );
3402  if ( !tmp )
3403  {
3404  // could be an incoming long array which can't be "safely" converted, do it anyway
3405  if ( PyArray_Check( in ) )
3406  {
3407  PyErr_Clear();
3408  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3409  }
3410  }
3411  return tmp;
3412  }
3413 
3414 
3415 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3416 
3417 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3418  PyObject *resultobj = 0;
3419  PLFLT arg1 ;
3420  PLFLT arg2 ;
3421  PLFLT *arg3 = (PLFLT *) 0 ;
3422  PLFLT *arg4 = (PLFLT *) 0 ;
3423  PLPointer arg5 = (PLPointer) 0 ;
3424  double val1 ;
3425  int ecode1 = 0 ;
3426  double val2 ;
3427  int ecode2 = 0 ;
3428  PLFLT temp3 ;
3429  int res3 = SWIG_TMPOBJ ;
3430  PLFLT temp4 ;
3431  int res4 = SWIG_TMPOBJ ;
3432  PyObject * obj0 = 0 ;
3433  PyObject * obj1 = 0 ;
3434 
3435  arg3 = &temp3;
3436  arg4 = &temp4;
3437  {
3438  arg5 = NULL;
3439  }
3440  if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
3441  ecode1 = SWIG_AsVal_double(obj0, &val1);
3442  if (!SWIG_IsOK(ecode1)) {
3443  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3444  }
3445  arg1 = (PLFLT)(val1);
3446  ecode2 = SWIG_AsVal_double(obj1, &val2);
3447  if (!SWIG_IsOK(ecode2)) {
3448  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3449  }
3450  arg2 = (PLFLT)(val2);
3451  pltr0(arg1,arg2,arg3,arg4,arg5);
3452  resultobj = SWIG_Py_Void();
3453  if (SWIG_IsTmpObj(res3)) {
3454  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3455  } else {
3456  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3457  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3458  }
3459  if (SWIG_IsTmpObj(res4)) {
3460  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3461  } else {
3462  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3463  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3464  }
3465  return resultobj;
3466 fail:
3467  return NULL;
3468 }
3469 
3470 
3471 
3472  PyArrayObject *pltr_xg, *pltr_yg;
3475 
3476  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3477  void cleanup_PLcGrid1( void );
3478  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3479  void cleanup_PLcGrid2( void );
3480 
3481  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3482  {
3483  // fprintf(stderr, "marshal PLcGrid1\n");
3484  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3485  {
3486  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3487  return NULL;
3488  }
3489  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3490  NPY_PLFLT, 1, 1 );
3491  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3492  NPY_PLFLT, 1, 1 );
3493  if ( pltr_xg == 0 || pltr_yg == 0 )
3494  {
3495  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3496  return NULL;
3497  }
3498  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3499  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3500  if ( isimg == 0 )
3501  {
3502  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3503  {
3504  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3505  return NULL;
3506  }
3507  }
3508  else
3509  {
3510  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3511  {
3512  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3513  return NULL;
3514  }
3515  }
3516  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3517  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3518  return &tmpGrid1;
3519  }
3520 
3521  void cleanup_PLcGrid1( void )
3522  {
3523  // fprintf(stderr, "cleanup PLcGrid1\n");
3524  Py_CLEAR( pltr_xg );
3525  Py_CLEAR( pltr_yg );
3526  }
3527 
3528  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3529  {
3530  int i, size;
3531  // fprintf(stderr, "marshal PLcGrid2\n");
3532  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3533  {
3534  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3535  return NULL;
3536  }
3537  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3538  NPY_PLFLT, 2, 2 );
3539  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3540  NPY_PLFLT, 2, 2 );
3541  if ( pltr_xg == 0 || pltr_yg == 0 )
3542  {
3543  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3544  return NULL;
3545  }
3546  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3547  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3548  {
3549  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3550  return NULL;
3551  }
3552  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3553  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3554  if ( isimg == 0 )
3555  {
3556  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3557  {
3558  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3559  return NULL;
3560  }
3561  }
3562  else
3563  {
3564  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3565  {
3566  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3567  return NULL;
3568  }
3569  }
3570  size = tmpGrid2.ny;
3571  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3572  for ( i = 0; i < tmpGrid2.nx; i++ )
3573  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3574  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3575  for ( i = 0; i < tmpGrid2.nx; i++ )
3576  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3577  return &tmpGrid2;
3578  }
3579 
3580  void cleanup_PLcGrid2( void )
3581  {
3582  // fprintf(stderr, "cleanup PLcGrid2\n");
3583  free( tmpGrid2.xg );
3584  free( tmpGrid2.yg );
3585  Py_CLEAR( pltr_xg );
3586  Py_CLEAR( pltr_yg );
3587  }
3588 
3589 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3590  PyObject *resultobj = 0;
3591  PLFLT arg1 ;
3592  PLFLT arg2 ;
3593  PLFLT *arg3 = (PLFLT *) 0 ;
3594  PLFLT *arg4 = (PLFLT *) 0 ;
3595  PLcGrid *arg5 = (PLcGrid *) 0 ;
3596  double val1 ;
3597  int ecode1 = 0 ;
3598  double val2 ;
3599  int ecode2 = 0 ;
3600  PLFLT temp3 ;
3601  int res3 = SWIG_TMPOBJ ;
3602  PLFLT temp4 ;
3603  int res4 = SWIG_TMPOBJ ;
3604  PyObject * obj0 = 0 ;
3605  PyObject * obj1 = 0 ;
3606  PyObject * obj2 = 0 ;
3607 
3608  arg3 = &temp3;
3609  arg4 = &temp4;
3610  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
3611  ecode1 = SWIG_AsVal_double(obj0, &val1);
3612  if (!SWIG_IsOK(ecode1)) {
3613  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3614  }
3615  arg1 = (PLFLT)(val1);
3616  ecode2 = SWIG_AsVal_double(obj1, &val2);
3617  if (!SWIG_IsOK(ecode2)) {
3618  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3619  }
3620  arg2 = (PLFLT)(val2);
3621  {
3622  arg5 = marshal_PLcGrid1( obj2, 0 );
3623  if ( !arg5 )
3624  return NULL;
3625  }
3626  pltr1(arg1,arg2,arg3,arg4,arg5);
3627  resultobj = SWIG_Py_Void();
3628  if (SWIG_IsTmpObj(res3)) {
3629  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3630  } else {
3631  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3632  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3633  }
3634  if (SWIG_IsTmpObj(res4)) {
3635  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3636  } else {
3637  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3638  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3639  }
3640  {
3641  cleanup_PLcGrid1();
3642  }
3643  return resultobj;
3644 fail:
3645  {
3646  cleanup_PLcGrid1();
3647  }
3648  return NULL;
3649 }
3650 
3651 
3652 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3653  PyObject *resultobj = 0;
3654  PLFLT arg1 ;
3655  PLFLT arg2 ;
3656  PLFLT *arg3 = (PLFLT *) 0 ;
3657  PLFLT *arg4 = (PLFLT *) 0 ;
3658  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3659  double val1 ;
3660  int ecode1 = 0 ;
3661  double val2 ;
3662  int ecode2 = 0 ;
3663  PLFLT temp3 ;
3664  int res3 = SWIG_TMPOBJ ;
3665  PLFLT temp4 ;
3666  int res4 = SWIG_TMPOBJ ;
3667  PyObject * obj0 = 0 ;
3668  PyObject * obj1 = 0 ;
3669  PyObject * obj2 = 0 ;
3670 
3671  arg3 = &temp3;
3672  arg4 = &temp4;
3673  if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
3674  ecode1 = SWIG_AsVal_double(obj0, &val1);
3675  if (!SWIG_IsOK(ecode1)) {
3676  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3677  }
3678  arg1 = (PLFLT)(val1);
3679  ecode2 = SWIG_AsVal_double(obj1, &val2);
3680  if (!SWIG_IsOK(ecode2)) {
3681  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3682  }
3683  arg2 = (PLFLT)(val2);
3684  {
3685  arg5 = marshal_PLcGrid2( obj2, 0 );
3686  if ( !arg5 )
3687  return NULL;
3688  }
3689  pltr2(arg1,arg2,arg3,arg4,arg5);
3690  resultobj = SWIG_Py_Void();
3691  if (SWIG_IsTmpObj(res3)) {
3692  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3693  } else {
3694  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3695  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3696  }
3697  if (SWIG_IsTmpObj(res4)) {
3698  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3699  } else {
3700  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3701  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3702  }
3703  {
3704  cleanup_PLcGrid2();
3705  }
3706  return resultobj;
3707 fail:
3708  {
3709  cleanup_PLcGrid2();
3710  }
3711  return NULL;
3712 }
3713 
3714 
3715 
3716  // helper code for handling the callback
3717 #if 0
3718  static PyInterpreterState *save_interp = NULL;
3719 #endif
3721  PyObject* python_pltr = NULL;
3722  PyObject* python_f2eval = NULL;
3723  PyObject* python_ct = NULL;
3724  PyObject* python_mapform = NULL;
3725  PyObject* python_label = NULL;
3726 
3727 #if 0
3728 #define MY_BLOCK_THREADS { \
3729  PyThreadState *prev_state, *new_state; \
3730  /* need to have started a thread at some stage */ \
3731  /* for the following to work */ \
3732  PyEval_AcquireLock(); \
3733  new_state = PyThreadState_New( save_interp ); \
3734  prev_state = PyThreadState_Swap( new_state );
3735 #define MY_UNBLOCK_THREADS \
3736  new_state = PyThreadState_Swap( prev_state ); \
3737  PyThreadState_Clear( new_state ); \
3738  PyEval_ReleaseLock(); \
3739  PyThreadState_Delete( new_state ); \
3740  }
3741 #else
3742 #define MY_BLOCK_THREADS
3743 #define MY_UNBLOCK_THREADS
3744 #endif
3745 
3746 // Function prototypes
3747  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3748  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data );
3749  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3750  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3751  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3752  pltr_func marshal_pltr( PyObject* input );
3753  void cleanup_pltr( void );
3754  ct_func marshal_ct( PyObject* input );
3755  void cleanup_ct( void );
3756  mapform_func marshal_mapform( PyObject* input );
3757  void cleanup_mapform( void );
3758  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3759  void cleanup_PLPointer( void );
3760 
3761 
3762 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3763 
3764  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3765  {
3766  PyObject *pdata, *arglist, *result;
3767  PyArrayObject *tmp;
3768 
3769  // the data argument is acutally a pointer to a python object
3770  pdata = (PyObject *) data;
3771  if ( data == NULL )
3772  {
3773  pdata = Py_None;
3774  }
3775  if ( python_pltr ) // if not something is terribly wrong
3776  { // hold a reference to the data object
3777  Py_XINCREF( pdata );
3778  // grab the Global Interpreter Lock to be sure threads don't mess us up
3780  // build the argument list
3781 #ifdef PL_DOUBLE
3782  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3783 #else
3784  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3785 #endif
3786  if ( arglist == NULL )
3787  {
3788  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3789  *tx = *ty = 0;
3790  return;
3791  }
3792  // call the python function
3793  result = PyEval_CallObject( python_pltr, arglist );
3794  // release the argument list
3795  Py_CLEAR( arglist );
3796  // check and unpack the result
3797  if ( result == NULL )
3798  {
3799  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3800  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
3801  *tx = *ty = 0;
3802  }
3803  else
3804  {
3805  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3806  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3807  {
3808  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3809  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3810  *tx = *ty = 0;
3811  }
3812  else
3813  {
3814  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3815  *tx = t[0];
3816  *ty = t[1];
3817  Py_CLEAR( tmp );
3818  }
3819  }
3820  // release the result
3821  Py_CLEAR( result );
3822  // release the global interpreter lock
3824  }
3825  }
3826 
3827  PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
3828  {
3829  PyObject *pdata, *arglist, *result;
3830  PLFLT fresult = 0.0;
3831 
3832  // the data argument is acutally a pointer to a python object
3833  pdata = (PyObject *) data;
3834  if ( python_f2eval ) // if not something is terribly wrong
3835  { // hold a reference to the data object
3836  Py_XINCREF( pdata );
3837  // grab the Global Interpreter Lock to be sure threads don't mess us up
3839  // build the argument list
3840  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3841  // call the python function
3842  result = PyEval_CallObject( python_f2eval, arglist );
3843  // release the argument list
3844  Py_CLEAR( arglist );
3845  // check and unpack the result
3846  if ( !PyFloat_Check( result ) )
3847  {
3848  fprintf( stderr, "f2eval callback must return a float\n" );
3849  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3850  }
3851  else
3852  {
3853  // should I test the type here?
3854  fresult = (PLFLT) PyFloat_AsDouble( result );
3855  }
3856  // release the result
3857  Py_CLEAR( result );
3858  // release the global interpreter lock
3860  }
3861  return fresult;
3862  }
3863 
3864  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3865  {
3866  PyObject *pdata, *arglist, *result;
3867  char *pystring;
3868 
3869  // the data argument is acutally a pointer to a python object
3870  if ( data )
3871  pdata = (PyObject *) data;
3872  else
3873  pdata = Py_None;
3874  if ( python_label ) // if not something is terribly wrong
3875  { // hold a reference to the data object
3876  Py_XINCREF( pdata );
3877  // grab the Global Interpreter Lock to be sure threads don't mess us up
3879  // build the argument list
3880 #ifdef PL_DOUBLE
3881  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3882 #else
3883  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3884 #endif
3885  // call the python function
3886  result = PyEval_CallObject( python_label, arglist );
3887  // release the argument list
3888  //Py_CLEAR(arglist);
3889  // check and unpack the result
3890  if ( result == NULL )
3891  {
3892  fprintf( stderr, "label callback failed with 3 arguments\n" );
3893  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3894  }
3895  else if ( !PyString_Check( result ) )
3896  {
3897  fprintf( stderr, "label callback must return a string\n" );
3898  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3899  }
3900  else
3901  {
3902  // should I test the type here?
3903  pystring = PyString_AsString( result );
3904  strncpy( string, pystring, len );
3905  }
3906  // release the result
3907  Py_CLEAR( result );
3908  // release the global interpreter lock
3910  }
3911  }
3912 
3913  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3914  {
3915  PyObject *px, *py, *pdata, *arglist, *result;
3916  npy_intp n;
3917  n = 1;
3918 
3919  // the data argument is acutally a pointer to a python object
3920  pdata = (PyObject *) data;
3921  if ( data == NULL )
3922  {
3923  pdata = Py_None;
3924  }
3925  if ( python_ct ) // if not something is terribly wrong
3926  { // hold a reference to the data object
3927  Py_XINCREF( pdata );
3928  // grab the Global Interpreter Lock to be sure threads don't mess us up
3930  // build the argument list
3931  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3932  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3933  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3934  // call the python function
3935  result = PyEval_CallObject( python_ct, arglist );
3936  // release the argument list
3937  Py_CLEAR( arglist );
3938  Py_CLEAR( px );
3939  Py_CLEAR( py );
3940  Py_CLEAR( pdata );
3941  // check and unpack the result
3942  if ( result == NULL )
3943  {
3944  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3945  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3946  }
3947  // release the result
3948  Py_CLEAR( result );
3949  // release the global interpreter lock
3951  }
3952  }
3953 
3954  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
3955  {
3956  PyObject *px, *py, *arglist, *result;
3957  // PyArrayObject *tmpx, *tmpy;
3958 // PLFLT *xx, *yy;
3959 // PLINT i;
3960  npy_intp nn;
3961  nn = n;
3962 
3963  if ( python_mapform ) // if not something is terribly wrong
3964  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3966  // build the argument list
3967 #ifdef PL_HAVE_PTHREAD
3968  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3969  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3970 #else
3971  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3972  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3973 #endif
3974  arglist = Py_BuildValue( "(iOO)", n, px, py );
3975  // call the python function
3976  result = PyEval_CallObject( python_mapform, arglist );
3977  // release the argument list
3978  Py_CLEAR( arglist );
3979  Py_CLEAR( px );
3980  Py_CLEAR( py );
3981  // check and unpack the result
3982  if ( result == NULL )
3983  {
3984  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3985  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3986  }
3987  // release the result
3988  Py_CLEAR( result );
3989  // release the global interpreter lock
3991  }
3992  }
3993 
3994 // marshal the pltr function pointer argument
3995  pltr_func marshal_pltr( PyObject* input )
3996  {
3997  pltr_func result = do_pltr_callback;
3998  PyObject * rep = PyObject_Repr( input );
3999  if ( rep )
4000  {
4001  char* str = PyString_AsString( rep );
4002  if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
4003  {
4004  result = pltr0;
4005  pltr_type = CB_0;
4006  python_pltr = NULL;
4007  }
4008  else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
4009  {
4010  result = pltr1;
4011  pltr_type = CB_1;
4012  python_pltr = NULL;
4013  }
4014  else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
4015  {
4016  result = pltr2;
4017  pltr_type = CB_2;
4018  python_pltr = NULL;
4019  }
4020  else
4021  {
4022  python_pltr = input;
4023  pltr_type = CB_Python;
4024  Py_XINCREF( input );
4025  }
4026  Py_CLEAR( rep );
4027  }
4028  else
4029  {
4030  python_pltr = input;
4031  pltr_type = CB_Python;
4032  Py_XINCREF( input );
4033  }
4034  return result;
4035  }
4036 
4037  void cleanup_pltr( void )
4038  {
4039  Py_CLEAR( python_pltr );
4040  python_pltr = 0;
4041  }
4042 
4043 // marshal the ct function pointer argument
4044  ct_func marshal_ct( PyObject* input )
4045  {
4046  ct_func result = do_ct_callback;
4047  python_ct = input;
4048  Py_XINCREF( input );
4049  return result;
4050  }
4051 
4052  void cleanup_ct( void )
4053  {
4054  Py_CLEAR( python_ct );
4055  python_ct = 0;
4056  }
4057 
4058 // marshal the mapform function pointer argument
4059  mapform_func marshal_mapform( PyObject* input )
4060  {
4062  python_mapform = input;
4063  Py_XINCREF( input );
4064  return result;
4065  }
4066 
4067  void cleanup_mapform( void )
4068  {
4069  Py_CLEAR( python_mapform );
4070  python_mapform = 0;
4071  }
4072 
4073  PLPointer marshal_PLPointer( PyObject* input, int isimg )
4074  {
4075  PLPointer result = NULL;
4076  switch ( pltr_type )
4077  {
4078  case CB_0:
4079  break;
4080  case CB_1:
4081  if ( input != Py_None )
4082  result = marshal_PLcGrid1( input, isimg );
4083  break;
4084  case CB_2:
4085  if ( input != Py_None )
4086  result = marshal_PLcGrid2( input, isimg );
4087  break;
4088  case CB_Python:
4089  Py_XINCREF( input );
4090  result = (PLPointer *) input;
4091  break;
4092  default:
4093  fprintf( stderr, "pltr_type is invalid\n" );
4094  }
4095  return result;
4096  }
4097 
4098  void cleanup_PLPointer( void )
4099  {
4100  switch ( pltr_type )
4101  {
4102  case CB_0:
4103  break;
4104  case CB_1:
4105  cleanup_PLcGrid1();
4106  break;
4107  case CB_2:
4108  cleanup_PLcGrid2();
4109  break;
4110  case CB_Python:
4111  Py_CLEAR( python_pltr );
4112  break;
4113  default:
4114  fprintf( stderr, "pltr_type is invalid\n" );
4115  }
4116  python_pltr = 0;
4117  pltr_type = CB_0;
4118  }
4119 
4120 
4121 
4122 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4123  PyObject *resultobj = 0;
4124  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4125  int arg2 ;
4126  void *argp1 = 0 ;
4127  int res1 = 0 ;
4128  int val2 ;
4129  int ecode2 = 0 ;
4130  PyObject * obj0 = 0 ;
4131  PyObject * obj1 = 0 ;
4132 
4133  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
4134  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4135  if (!SWIG_IsOK(res1)) {
4136  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4137  }
4138  arg1 = (PLGraphicsIn *)(argp1);
4139  ecode2 = SWIG_AsVal_int(obj1, &val2);
4140  if (!SWIG_IsOK(ecode2)) {
4141  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4142  }
4143  arg2 = (int)(val2);
4144  if (arg1) (arg1)->type = arg2;
4145  resultobj = SWIG_Py_Void();
4146  return resultobj;
4147 fail:
4148  return NULL;
4149 }
4150 
4151 
4152 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4153  PyObject *resultobj = 0;
4154  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4155  void *argp1 = 0 ;
4156  int res1 = 0 ;
4157  PyObject * obj0 = 0 ;
4158  int result;
4159 
4160  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
4161  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4162  if (!SWIG_IsOK(res1)) {
4163  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4164  }
4165  arg1 = (PLGraphicsIn *)(argp1);
4166  result = (int) ((arg1)->type);
4167  resultobj = SWIG_From_int((int)(result));
4168  return resultobj;
4169 fail:
4170  return NULL;
4171 }
4172 
4173 
4174 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4175  PyObject *resultobj = 0;
4176  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4177  unsigned int arg2 ;
4178  void *argp1 = 0 ;
4179  int res1 = 0 ;
4180  unsigned int val2 ;
4181  int ecode2 = 0 ;
4182  PyObject * obj0 = 0 ;
4183  PyObject * obj1 = 0 ;
4184 
4185  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
4186  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4187  if (!SWIG_IsOK(res1)) {
4188  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4189  }
4190  arg1 = (PLGraphicsIn *)(argp1);
4191  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4192  if (!SWIG_IsOK(ecode2)) {
4193  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4194  }
4195  arg2 = (unsigned int)(val2);
4196  if (arg1) (arg1)->state = arg2;
4197  resultobj = SWIG_Py_Void();
4198  return resultobj;
4199 fail:
4200  return NULL;
4201 }
4202 
4203 
4204 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4205  PyObject *resultobj = 0;
4206  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4207  void *argp1 = 0 ;
4208  int res1 = 0 ;
4209  PyObject * obj0 = 0 ;
4210  unsigned int result;
4211 
4212  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
4213  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4214  if (!SWIG_IsOK(res1)) {
4215  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4216  }
4217  arg1 = (PLGraphicsIn *)(argp1);
4218  result = (unsigned int) ((arg1)->state);
4219  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4220  return resultobj;
4221 fail:
4222  return NULL;
4223 }
4224 
4225 
4226 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4227  PyObject *resultobj = 0;
4228  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4229  unsigned int arg2 ;
4230  void *argp1 = 0 ;
4231  int res1 = 0 ;
4232  unsigned int val2 ;
4233  int ecode2 = 0 ;
4234  PyObject * obj0 = 0 ;
4235  PyObject * obj1 = 0 ;
4236 
4237  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
4238  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4239  if (!SWIG_IsOK(res1)) {
4240  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4241  }
4242  arg1 = (PLGraphicsIn *)(argp1);
4243  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4244  if (!SWIG_IsOK(ecode2)) {
4245  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4246  }
4247  arg2 = (unsigned int)(val2);
4248  if (arg1) (arg1)->keysym = arg2;
4249  resultobj = SWIG_Py_Void();
4250  return resultobj;
4251 fail:
4252  return NULL;
4253 }
4254 
4255 
4256 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4257  PyObject *resultobj = 0;
4258  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4259  void *argp1 = 0 ;
4260  int res1 = 0 ;
4261  PyObject * obj0 = 0 ;
4262  unsigned int result;
4263 
4264  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
4265  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4266  if (!SWIG_IsOK(res1)) {
4267  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4268  }
4269  arg1 = (PLGraphicsIn *)(argp1);
4270  result = (unsigned int) ((arg1)->keysym);
4271  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4272  return resultobj;
4273 fail:
4274  return NULL;
4275 }
4276 
4277 
4278 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4279  PyObject *resultobj = 0;
4280  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4281  unsigned int arg2 ;
4282  void *argp1 = 0 ;
4283  int res1 = 0 ;
4284  unsigned int val2 ;
4285  int ecode2 = 0 ;
4286  PyObject * obj0 = 0 ;
4287  PyObject * obj1 = 0 ;
4288 
4289  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
4290  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4291  if (!SWIG_IsOK(res1)) {
4292  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4293  }
4294  arg1 = (PLGraphicsIn *)(argp1);
4295  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4296  if (!SWIG_IsOK(ecode2)) {
4297  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4298  }
4299  arg2 = (unsigned int)(val2);
4300  if (arg1) (arg1)->button = arg2;
4301  resultobj = SWIG_Py_Void();
4302  return resultobj;
4303 fail:
4304  return NULL;
4305 }
4306 
4307 
4308 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309  PyObject *resultobj = 0;
4310  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4311  void *argp1 = 0 ;
4312  int res1 = 0 ;
4313  PyObject * obj0 = 0 ;
4314  unsigned int result;
4315 
4316  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
4317  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4318  if (!SWIG_IsOK(res1)) {
4319  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4320  }
4321  arg1 = (PLGraphicsIn *)(argp1);
4322  result = (unsigned int) ((arg1)->button);
4323  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4324  return resultobj;
4325 fail:
4326  return NULL;
4327 }
4328 
4329 
4330 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331  PyObject *resultobj = 0;
4332  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4333  PLINT arg2 ;
4334  void *argp1 = 0 ;
4335  int res1 = 0 ;
4336  int val2 ;
4337  int ecode2 = 0 ;
4338  PyObject * obj0 = 0 ;
4339  PyObject * obj1 = 0 ;
4340 
4341  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
4342  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4343  if (!SWIG_IsOK(res1)) {
4344  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4345  }
4346  arg1 = (PLGraphicsIn *)(argp1);
4347  ecode2 = SWIG_AsVal_int(obj1, &val2);
4348  if (!SWIG_IsOK(ecode2)) {
4349  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4350  }
4351  arg2 = (PLINT)(val2);
4352  if (arg1) (arg1)->subwindow = arg2;
4353  resultobj = SWIG_Py_Void();
4354  return resultobj;
4355 fail:
4356  return NULL;
4357 }
4358 
4359 
4360 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4361  PyObject *resultobj = 0;
4362  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4363  void *argp1 = 0 ;
4364  int res1 = 0 ;
4365  PyObject * obj0 = 0 ;
4366  PLINT result;
4367 
4368  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
4369  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4370  if (!SWIG_IsOK(res1)) {
4371  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4372  }
4373  arg1 = (PLGraphicsIn *)(argp1);
4374  result = (PLINT) ((arg1)->subwindow);
4375  resultobj = SWIG_From_int((int)(result));
4376  return resultobj;
4377 fail:
4378  return NULL;
4379 }
4380 
4381 
4382 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4383  PyObject *resultobj = 0;
4384  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4385  char *arg2 ;
4386  void *argp1 = 0 ;
4387  int res1 = 0 ;
4388  char temp2[16] ;
4389  int res2 ;
4390  PyObject * obj0 = 0 ;
4391  PyObject * obj1 = 0 ;
4392 
4393  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
4394  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4395  if (!SWIG_IsOK(res1)) {
4396  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4397  }
4398  arg1 = (PLGraphicsIn *)(argp1);
4399  res2 = SWIG_AsCharArray(obj1, temp2, 16);
4400  if (!SWIG_IsOK(res2)) {
4401  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4402  }
4403  arg2 = (char *)(temp2);
4404  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4405  else memset(arg1->string,0,16*sizeof(char));
4406  resultobj = SWIG_Py_Void();
4407  return resultobj;
4408 fail:
4409  return NULL;
4410 }
4411 
4412 
4413 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414  PyObject *resultobj = 0;
4415  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4416  void *argp1 = 0 ;
4417  int res1 = 0 ;
4418  PyObject * obj0 = 0 ;
4419  char *result = 0 ;
4420 
4421  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
4422  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4423  if (!SWIG_IsOK(res1)) {
4424  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4425  }
4426  arg1 = (PLGraphicsIn *)(argp1);
4427  result = (char *)(char *) ((arg1)->string);
4428  {
4429  size_t size = 16;
4430 
4431  while (size && (result[size - 1] == '\0')) --size;
4432 
4433  resultobj = SWIG_FromCharPtrAndSize(result, size);
4434  }
4435  return resultobj;
4436 fail:
4437  return NULL;
4438 }
4439 
4440 
4441 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442  PyObject *resultobj = 0;
4443  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4444  int arg2 ;
4445  void *argp1 = 0 ;
4446  int res1 = 0 ;
4447  int val2 ;
4448  int ecode2 = 0 ;
4449  PyObject * obj0 = 0 ;
4450  PyObject * obj1 = 0 ;
4451 
4452  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
4453  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4454  if (!SWIG_IsOK(res1)) {
4455  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4456  }
4457  arg1 = (PLGraphicsIn *)(argp1);
4458  ecode2 = SWIG_AsVal_int(obj1, &val2);
4459  if (!SWIG_IsOK(ecode2)) {
4460  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4461  }
4462  arg2 = (int)(val2);
4463  if (arg1) (arg1)->pX = arg2;
4464  resultobj = SWIG_Py_Void();
4465  return resultobj;
4466 fail:
4467  return NULL;
4468 }
4469 
4470 
4471 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472  PyObject *resultobj = 0;
4473  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4474  void *argp1 = 0 ;
4475  int res1 = 0 ;
4476  PyObject * obj0 = 0 ;
4477  int result;
4478 
4479  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
4480  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4481  if (!SWIG_IsOK(res1)) {
4482  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4483  }
4484  arg1 = (PLGraphicsIn *)(argp1);
4485  result = (int) ((arg1)->pX);
4486  resultobj = SWIG_From_int((int)(result));
4487  return resultobj;
4488 fail:
4489  return NULL;
4490 }
4491 
4492 
4493 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4494  PyObject *resultobj = 0;
4495  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4496  int arg2 ;
4497  void *argp1 = 0 ;
4498  int res1 = 0 ;
4499  int val2 ;
4500  int ecode2 = 0 ;
4501  PyObject * obj0 = 0 ;
4502  PyObject * obj1 = 0 ;
4503 
4504  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
4505  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4506  if (!SWIG_IsOK(res1)) {
4507  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4508  }
4509  arg1 = (PLGraphicsIn *)(argp1);
4510  ecode2 = SWIG_AsVal_int(obj1, &val2);
4511  if (!SWIG_IsOK(ecode2)) {
4512  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4513  }
4514  arg2 = (int)(val2);
4515  if (arg1) (arg1)->pY = arg2;
4516  resultobj = SWIG_Py_Void();
4517  return resultobj;
4518 fail:
4519  return NULL;
4520 }
4521 
4522 
4523 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4524  PyObject *resultobj = 0;
4525  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4526  void *argp1 = 0 ;
4527  int res1 = 0 ;
4528  PyObject * obj0 = 0 ;
4529  int result;
4530 
4531  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
4532  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4533  if (!SWIG_IsOK(res1)) {
4534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4535  }
4536  arg1 = (PLGraphicsIn *)(argp1);
4537  result = (int) ((arg1)->pY);
4538  resultobj = SWIG_From_int((int)(result));
4539  return resultobj;
4540 fail:
4541  return NULL;
4542 }
4543 
4544 
4545 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546  PyObject *resultobj = 0;
4547  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4548  PLFLT arg2 ;
4549  void *argp1 = 0 ;
4550  int res1 = 0 ;
4551  double val2 ;
4552  int ecode2 = 0 ;
4553  PyObject * obj0 = 0 ;
4554  PyObject * obj1 = 0 ;
4555 
4556  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
4557  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4558  if (!SWIG_IsOK(res1)) {
4559  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4560  }
4561  arg1 = (PLGraphicsIn *)(argp1);
4562  ecode2 = SWIG_AsVal_double(obj1, &val2);
4563  if (!SWIG_IsOK(ecode2)) {
4564  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4565  }
4566  arg2 = (PLFLT)(val2);
4567  if (arg1) (arg1)->dX = arg2;
4568  resultobj = SWIG_Py_Void();
4569  return resultobj;
4570 fail:
4571  return NULL;
4572 }
4573 
4574 
4575 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4576  PyObject *resultobj = 0;
4577  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4578  void *argp1 = 0 ;
4579  int res1 = 0 ;
4580  PyObject * obj0 = 0 ;
4581  PLFLT result;
4582 
4583  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
4584  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4585  if (!SWIG_IsOK(res1)) {
4586  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4587  }
4588  arg1 = (PLGraphicsIn *)(argp1);
4589  result = (PLFLT) ((arg1)->dX);
4590  resultobj = SWIG_From_double((double)(result));
4591  return resultobj;
4592 fail:
4593  return NULL;
4594 }
4595 
4596 
4597 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4598  PyObject *resultobj = 0;
4599  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4600  PLFLT arg2 ;
4601  void *argp1 = 0 ;
4602  int res1 = 0 ;
4603  double val2 ;
4604  int ecode2 = 0 ;
4605  PyObject * obj0 = 0 ;
4606  PyObject * obj1 = 0 ;
4607 
4608  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
4609  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4610  if (!SWIG_IsOK(res1)) {
4611  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4612  }
4613  arg1 = (PLGraphicsIn *)(argp1);
4614  ecode2 = SWIG_AsVal_double(obj1, &val2);
4615  if (!SWIG_IsOK(ecode2)) {
4616  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4617  }
4618  arg2 = (PLFLT)(val2);
4619  if (arg1) (arg1)->dY = arg2;
4620  resultobj = SWIG_Py_Void();
4621  return resultobj;
4622 fail:
4623  return NULL;
4624 }
4625 
4626 
4627 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628  PyObject *resultobj = 0;
4629  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4630  void *argp1 = 0 ;
4631  int res1 = 0 ;
4632  PyObject * obj0 = 0 ;
4633  PLFLT result;
4634 
4635  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
4636  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4637  if (!SWIG_IsOK(res1)) {
4638  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4639  }
4640  arg1 = (PLGraphicsIn *)(argp1);
4641  result = (PLFLT) ((arg1)->dY);
4642  resultobj = SWIG_From_double((double)(result));
4643  return resultobj;
4644 fail:
4645  return NULL;
4646 }
4647 
4648 
4649 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4650  PyObject *resultobj = 0;
4651  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4652  PLFLT arg2 ;
4653  void *argp1 = 0 ;
4654  int res1 = 0 ;
4655  double val2 ;
4656  int ecode2 = 0 ;
4657  PyObject * obj0 = 0 ;
4658  PyObject * obj1 = 0 ;
4659 
4660  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
4661  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4662  if (!SWIG_IsOK(res1)) {
4663  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4664  }
4665  arg1 = (PLGraphicsIn *)(argp1);
4666  ecode2 = SWIG_AsVal_double(obj1, &val2);
4667  if (!SWIG_IsOK(ecode2)) {
4668  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4669  }
4670  arg2 = (PLFLT)(val2);
4671  if (arg1) (arg1)->wX = arg2;
4672  resultobj = SWIG_Py_Void();
4673  return resultobj;
4674 fail:
4675  return NULL;
4676 }
4677 
4678 
4679 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4680  PyObject *resultobj = 0;
4681  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4682  void *argp1 = 0 ;
4683  int res1 = 0 ;
4684  PyObject * obj0 = 0 ;
4685  PLFLT result;
4686 
4687  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
4688  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4689  if (!SWIG_IsOK(res1)) {
4690  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4691  }
4692  arg1 = (PLGraphicsIn *)(argp1);
4693  result = (PLFLT) ((arg1)->wX);
4694  resultobj = SWIG_From_double((double)(result));
4695  return resultobj;
4696 fail:
4697  return NULL;
4698 }
4699 
4700 
4701 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702  PyObject *resultobj = 0;
4703  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4704  PLFLT arg2 ;
4705  void *argp1 = 0 ;
4706  int res1 = 0 ;
4707  double val2 ;
4708  int ecode2 = 0 ;
4709  PyObject * obj0 = 0 ;
4710  PyObject * obj1 = 0 ;
4711 
4712  if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
4713  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4714  if (!SWIG_IsOK(res1)) {
4715  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4716  }
4717  arg1 = (PLGraphicsIn *)(argp1);
4718  ecode2 = SWIG_AsVal_double(obj1, &val2);
4719  if (!SWIG_IsOK(ecode2)) {
4720  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4721  }
4722  arg2 = (PLFLT)(val2);
4723  if (arg1) (arg1)->wY = arg2;
4724  resultobj = SWIG_Py_Void();
4725  return resultobj;
4726 fail:
4727  return NULL;
4728 }
4729 
4730 
4731 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4732  PyObject *resultobj = 0;
4733  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4734  void *argp1 = 0 ;
4735  int res1 = 0 ;
4736  PyObject * obj0 = 0 ;
4737  PLFLT result;
4738 
4739  if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
4740  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4741  if (!SWIG_IsOK(res1)) {
4742  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4743  }
4744  arg1 = (PLGraphicsIn *)(argp1);
4745  result = (PLFLT) ((arg1)->wY);
4746  resultobj = SWIG_From_double((double)(result));
4747  return resultobj;
4748 fail:
4749  return NULL;
4750 }
4751 
4752 
4753 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4754  PyObject *resultobj = 0;
4755  PLGraphicsIn *result = 0 ;
4756 
4757  if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
4758  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4760  return resultobj;
4761 fail:
4762  return NULL;
4763 }
4764 
4765 
4766 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4767  PyObject *resultobj = 0;
4768  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4769  void *argp1 = 0 ;
4770  int res1 = 0 ;
4771  PyObject * obj0 = 0 ;
4772 
4773  if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
4774  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4775  if (!SWIG_IsOK(res1)) {
4776  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4777  }
4778  arg1 = (PLGraphicsIn *)(argp1);
4779  free((char *) arg1);
4780  resultobj = SWIG_Py_Void();
4781  return resultobj;
4782 fail:
4783  return NULL;
4784 }
4785 
4786 
4787 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4788  PyObject *obj;
4789  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4791  return SWIG_Py_Void();
4792 }
4793 
4794 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4795  PyObject *resultobj = 0;
4796  PLINT arg1 ;
4797  int val1 ;
4798  int ecode1 = 0 ;
4799  PyObject * obj0 = 0 ;
4800 
4801  if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
4802  ecode1 = SWIG_AsVal_int(obj0, &val1);
4803  if (!SWIG_IsOK(ecode1)) {
4804  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4805  }
4806  arg1 = (PLINT)(val1);
4807  plsxwin(arg1);
4808  resultobj = SWIG_Py_Void();
4809  return resultobj;
4810 fail:
4811  return NULL;
4812 }
4813 
4814 
4815 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4816  PyObject *resultobj = 0;
4817  PLINT arg1 ;
4818  PLINT arg2 ;
4819  int val1 ;
4820  int ecode1 = 0 ;
4821  int val2 ;
4822  int ecode2 = 0 ;
4823  PyObject * obj0 = 0 ;
4824  PyObject * obj1 = 0 ;
4825 
4826  if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
4827  ecode1 = SWIG_AsVal_int(obj0, &val1);
4828  if (!SWIG_IsOK(ecode1)) {
4829  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4830  }
4831  arg1 = (PLINT)(val1);
4832  ecode2 = SWIG_AsVal_int(obj1, &val2);
4833  if (!SWIG_IsOK(ecode2)) {
4834  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4835  }
4836  arg2 = (PLINT)(val2);
4837  pl_setcontlabelformat(arg1,arg2);
4838  resultobj = SWIG_Py_Void();
4839  return resultobj;
4840 fail:
4841  return NULL;
4842 }
4843 
4844 
4845 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846  PyObject *resultobj = 0;
4847  PLFLT arg1 ;
4848  PLFLT arg2 ;
4849  PLFLT arg3 ;
4850  PLINT arg4 ;
4851  double val1 ;
4852  int ecode1 = 0 ;
4853  double val2 ;
4854  int ecode2 = 0 ;
4855  double val3 ;
4856  int ecode3 = 0 ;
4857  int val4 ;
4858  int ecode4 = 0 ;
4859  PyObject * obj0 = 0 ;
4860  PyObject * obj1 = 0 ;
4861  PyObject * obj2 = 0 ;
4862  PyObject * obj3 = 0 ;
4863 
4864  if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4865  ecode1 = SWIG_AsVal_double(obj0, &val1);
4866  if (!SWIG_IsOK(ecode1)) {
4867  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4868  }
4869  arg1 = (PLFLT)(val1);
4870  ecode2 = SWIG_AsVal_double(obj1, &val2);
4871  if (!SWIG_IsOK(ecode2)) {
4872  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4873  }
4874  arg2 = (PLFLT)(val2);
4875  ecode3 = SWIG_AsVal_double(obj2, &val3);
4876  if (!SWIG_IsOK(ecode3)) {
4877  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4878  }
4879  arg3 = (PLFLT)(val3);
4880  ecode4 = SWIG_AsVal_int(obj3, &val4);
4881  if (!SWIG_IsOK(ecode4)) {
4882  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4883  }
4884  arg4 = (PLINT)(val4);
4885  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4886  resultobj = SWIG_Py_Void();
4887  return resultobj;
4888 fail:
4889  return NULL;
4890 }
4891 
4892 
4893 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4894  PyObject *resultobj = 0;
4895  PLINT arg1 ;
4896  int val1 ;
4897  int ecode1 = 0 ;
4898  PyObject * obj0 = 0 ;
4899 
4900  if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
4901  ecode1 = SWIG_AsVal_int(obj0, &val1);
4902  if (!SWIG_IsOK(ecode1)) {
4903  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4904  }
4905  arg1 = (PLINT)(val1);
4906  pladv(arg1);
4907  resultobj = SWIG_Py_Void();
4908  return resultobj;
4909 fail:
4910  return NULL;
4911 }
4912 
4913 
4914 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915  PyObject *resultobj = 0;
4916  PLFLT arg1 ;
4917  PLFLT arg2 ;
4918  PLFLT arg3 ;
4919  PLFLT arg4 ;
4920  PLFLT arg5 ;
4921  PLFLT arg6 ;
4922  PLFLT arg7 ;
4923  PLBOOL arg8 ;
4924  double val1 ;
4925  int ecode1 = 0 ;
4926  double val2 ;
4927  int ecode2 = 0 ;
4928  double val3 ;
4929  int ecode3 = 0 ;
4930  double val4 ;
4931  int ecode4 = 0 ;
4932  double val5 ;
4933  int ecode5 = 0 ;
4934  double val6 ;
4935  int ecode6 = 0 ;
4936  double val7 ;
4937  int ecode7 = 0 ;
4938  int val8 ;
4939  int ecode8 = 0 ;
4940  PyObject * obj0 = 0 ;
4941  PyObject * obj1 = 0 ;
4942  PyObject * obj2 = 0 ;
4943  PyObject * obj3 = 0 ;
4944  PyObject * obj4 = 0 ;
4945  PyObject * obj5 = 0 ;
4946  PyObject * obj6 = 0 ;
4947  PyObject * obj7 = 0 ;
4948 
4949  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4950  ecode1 = SWIG_AsVal_double(obj0, &val1);
4951  if (!SWIG_IsOK(ecode1)) {
4952  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4953  }
4954  arg1 = (PLFLT)(val1);
4955  ecode2 = SWIG_AsVal_double(obj1, &val2);
4956  if (!SWIG_IsOK(ecode2)) {
4957  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4958  }
4959  arg2 = (PLFLT)(val2);
4960  ecode3 = SWIG_AsVal_double(obj2, &val3);
4961  if (!SWIG_IsOK(ecode3)) {
4962  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4963  }
4964  arg3 = (PLFLT)(val3);
4965  ecode4 = SWIG_AsVal_double(obj3, &val4);
4966  if (!SWIG_IsOK(ecode4)) {
4967  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4968  }
4969  arg4 = (PLFLT)(val4);
4970  ecode5 = SWIG_AsVal_double(obj4, &val5);
4971  if (!SWIG_IsOK(ecode5)) {
4972  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4973  }
4974  arg5 = (PLFLT)(val5);
4975  ecode6 = SWIG_AsVal_double(obj5, &val6);
4976  if (!SWIG_IsOK(ecode6)) {
4977  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4978  }
4979  arg6 = (PLFLT)(val6);
4980  ecode7 = SWIG_AsVal_double(obj6, &val7);
4981  if (!SWIG_IsOK(ecode7)) {
4982  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4983  }
4984  arg7 = (PLFLT)(val7);
4985  ecode8 = SWIG_AsVal_int(obj7, &val8);
4986  if (!SWIG_IsOK(ecode8)) {
4987  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4988  }
4989  arg8 = (PLBOOL)(val8);
4990  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4991  resultobj = SWIG_Py_Void();
4992  return resultobj;
4993 fail:
4994  return NULL;
4995 }
4996 
4997 
4998 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999  PyObject *resultobj = 0;
5000  PLFLT arg1 ;
5001  PLFLT arg2 ;
5002  char *arg3 = (char *) 0 ;
5003  PLFLT arg4 ;
5004  PLINT arg5 ;
5005  char *arg6 = (char *) 0 ;
5006  PLFLT arg7 ;
5007  PLINT arg8 ;
5008  double val1 ;
5009  int ecode1 = 0 ;
5010  double val2 ;
5011  int ecode2 = 0 ;
5012  int res3 ;
5013  char *buf3 = 0 ;
5014  int alloc3 = 0 ;
5015  double val4 ;
5016  int ecode4 = 0 ;
5017  int val5 ;
5018  int ecode5 = 0 ;
5019  int res6 ;
5020  char *buf6 = 0 ;
5021  int alloc6 = 0 ;
5022  double val7 ;
5023  int ecode7 = 0 ;
5024  int val8 ;
5025  int ecode8 = 0 ;
5026  PyObject * obj0 = 0 ;
5027  PyObject * obj1 = 0 ;
5028  PyObject * obj2 = 0 ;
5029  PyObject * obj3 = 0 ;
5030  PyObject * obj4 = 0 ;
5031  PyObject * obj5 = 0 ;
5032  PyObject * obj6 = 0 ;
5033  PyObject * obj7 = 0 ;
5034 
5035  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5036  ecode1 = SWIG_AsVal_double(obj0, &val1);
5037  if (!SWIG_IsOK(ecode1)) {
5038  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5039  }
5040  arg1 = (PLFLT)(val1);
5041  ecode2 = SWIG_AsVal_double(obj1, &val2);
5042  if (!SWIG_IsOK(ecode2)) {
5043  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5044  }
5045  arg2 = (PLFLT)(val2);
5046  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
5047  if (!SWIG_IsOK(res3)) {
5048  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5049  }
5050  arg3 = (char *)(buf3);
5051  ecode4 = SWIG_AsVal_double(obj3, &val4);
5052  if (!SWIG_IsOK(ecode4)) {
5053  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5054  }
5055  arg4 = (PLFLT)(val4);
5056  ecode5 = SWIG_AsVal_int(obj4, &val5);
5057  if (!SWIG_IsOK(ecode5)) {
5058  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5059  }
5060  arg5 = (PLINT)(val5);
5061  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5062  if (!SWIG_IsOK(res6)) {
5063  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5064  }
5065  arg6 = (char *)(buf6);
5066  ecode7 = SWIG_AsVal_double(obj6, &val7);
5067  if (!SWIG_IsOK(ecode7)) {
5068  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5069  }
5070  arg7 = (PLFLT)(val7);
5071  ecode8 = SWIG_AsVal_int(obj7, &val8);
5072  if (!SWIG_IsOK(ecode8)) {
5073  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5074  }
5075  arg8 = (PLINT)(val8);
5076  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5077  resultobj = SWIG_Py_Void();
5078  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5079  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5080  return resultobj;
5081 fail:
5082  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5083  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5084  return NULL;
5085 }
5086 
5087 
5088 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5089  PyObject *resultobj = 0;
5090  PLINT arg1 ;
5091  PLFLT *arg2 = (PLFLT *) 0 ;
5092  PLFLT *arg3 = (PLFLT *) 0 ;
5093  PLINT arg4 ;
5094  PyArrayObject *tmp1 = NULL ;
5095  PyArrayObject *tmp3 = NULL ;
5096  int val4 ;
5097  int ecode4 = 0 ;
5098  PyObject * obj0 = 0 ;
5099  PyObject * obj1 = 0 ;
5100  PyObject * obj2 = 0 ;
5101 
5102  if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
5103  {
5104  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
5105  if ( tmp1 == NULL )
5106  return NULL;
5107  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5108  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5109  }
5110  {
5111  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
5112  if ( tmp3 == NULL )
5113  return NULL;
5114  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5115  {
5116  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5117  return NULL;
5118  }
5119  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5120  }
5121  ecode4 = SWIG_AsVal_int(obj2, &val4);
5122  if (!SWIG_IsOK(ecode4)) {
5123  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5124  }
5125  arg4 = (PLINT)(val4);
5126  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5127  resultobj = SWIG_Py_Void();
5128  {
5129  Py_CLEAR( tmp1 );
5130  }
5131  {
5132  Py_CLEAR( tmp3 );
5133  }
5134  return resultobj;
5135 fail:
5136  {
5137  Py_CLEAR( tmp1 );
5138  }
5139  {
5140  Py_CLEAR( tmp3 );
5141  }
5142  return NULL;
5143 }
5144 
5145 
5146 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147  PyObject *resultobj = 0;
5148  PLINT *arg1 = (PLINT *) 0 ;
5149  PLINT *arg2 = (PLINT *) 0 ;
5150  PLINT *arg3 = (PLINT *) 0 ;
5151  PLINT *arg4 = (PLINT *) 0 ;
5152  PLINT *arg5 = (PLINT *) 0 ;
5153  PLFLT *arg6 = (PLFLT *) 0 ;
5154  PLFLT arg7 ;
5155  PLINT temp1 ;
5156  int res1 = SWIG_TMPOBJ ;
5157  PLINT temp2 ;
5158  int res2 = SWIG_TMPOBJ ;
5159  PLINT temp3 ;
5160  int res3 = SWIG_TMPOBJ ;
5161  PLINT temp4 ;
5162  int res4 = SWIG_TMPOBJ ;
5163  PLINT temp5 ;
5164  int res5 = SWIG_TMPOBJ ;
5165  PLFLT temp6 ;
5166  int res6 = SWIG_TMPOBJ ;
5167  double val7 ;
5168  int ecode7 = 0 ;
5169  PyObject * obj0 = 0 ;
5170 
5171  arg1 = &temp1;
5172  arg2 = &temp2;
5173  arg3 = &temp3;
5174  arg4 = &temp4;
5175  arg5 = &temp5;
5176  arg6 = &temp6;
5177  if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
5178  ecode7 = SWIG_AsVal_double(obj0, &val7);
5179  if (!SWIG_IsOK(ecode7)) {
5180  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5181  }
5182  arg7 = (PLFLT)(val7);
5183  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5184  resultobj = SWIG_Py_Void();
5185  if (SWIG_IsTmpObj(res1)) {
5186  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5187  } else {
5188  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5189  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5190  }
5191  if (SWIG_IsTmpObj(res2)) {
5192  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5193  } else {
5194  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5195  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5196  }
5197  if (SWIG_IsTmpObj(res3)) {
5198  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5199  } else {
5200  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5201  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5202  }
5203  if (SWIG_IsTmpObj(res4)) {
5204  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5205  } else {
5206  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5207  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5208  }
5209  if (SWIG_IsTmpObj(res5)) {
5210  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5211  } else {
5212  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5213  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5214  }
5215  if (SWIG_IsTmpObj(res6)) {
5216  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5217  } else {
5218  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5219  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5220  }
5221  return resultobj;
5222 fail:
5223  return NULL;
5224 }
5225 
5226 
5227 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5228  PyObject *resultobj = 0;
5229 
5230  if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
5231  plbop();
5232  resultobj = SWIG_Py_Void();
5233  return resultobj;
5234 fail:
5235  return NULL;
5236 }
5237 
5238 
5239 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5240  PyObject *resultobj = 0;
5241  char *arg1 = (char *) 0 ;
5242  PLFLT arg2 ;
5243  PLINT arg3 ;
5244  char *arg4 = (char *) 0 ;
5245  PLFLT arg5 ;
5246  PLINT arg6 ;
5247  int res1 ;
5248  char *buf1 = 0 ;
5249  int alloc1 = 0 ;
5250  double val2 ;
5251  int ecode2 = 0 ;
5252  int val3 ;
5253  int ecode3 = 0 ;
5254  int res4 ;
5255  char *buf4 = 0 ;
5256  int alloc4 = 0 ;
5257  double val5 ;
5258  int ecode5 = 0 ;
5259  int val6 ;
5260  int ecode6 = 0 ;
5261  PyObject * obj0 = 0 ;
5262  PyObject * obj1 = 0 ;
5263  PyObject * obj2 = 0 ;
5264  PyObject * obj3 = 0 ;
5265  PyObject * obj4 = 0 ;
5266  PyObject * obj5 = 0 ;
5267 
5268  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5269  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5270  if (!SWIG_IsOK(res1)) {
5271  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5272  }
5273  arg1 = (char *)(buf1);
5274  ecode2 = SWIG_AsVal_double(obj1, &val2);
5275  if (!SWIG_IsOK(ecode2)) {
5276  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5277  }
5278  arg2 = (PLFLT)(val2);
5279  ecode3 = SWIG_AsVal_int(obj2, &val3);
5280  if (!SWIG_IsOK(ecode3)) {
5281  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5282  }
5283  arg3 = (PLINT)(val3);
5284  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5285  if (!SWIG_IsOK(res4)) {
5286  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5287  }
5288  arg4 = (char *)(buf4);
5289  ecode5 = SWIG_AsVal_double(obj4, &val5);
5290  if (!SWIG_IsOK(ecode5)) {
5291  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5292  }
5293  arg5 = (PLFLT)(val5);
5294  ecode6 = SWIG_AsVal_int(obj5, &val6);
5295  if (!SWIG_IsOK(ecode6)) {
5296  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5297  }
5298  arg6 = (PLINT)(val6);
5299  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5300  resultobj = SWIG_Py_Void();
5301  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5302  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5303  return resultobj;
5304 fail:
5305  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5306  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5307  return NULL;
5308 }
5309 
5310 
5311 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312  PyObject *resultobj = 0;
5313  char *arg1 = (char *) 0 ;
5314  char *arg2 = (char *) 0 ;
5315  PLFLT arg3 ;
5316  PLINT arg4 ;
5317  char *arg5 = (char *) 0 ;
5318  char *arg6 = (char *) 0 ;
5319  PLFLT arg7 ;
5320  PLINT arg8 ;
5321  char *arg9 = (char *) 0 ;
5322  char *arg10 = (char *) 0 ;
5323  PLFLT arg11 ;
5324  PLINT arg12 ;
5325  int res1 ;
5326  char *buf1 = 0 ;
5327  int alloc1 = 0 ;
5328  int res2 ;
5329  char *buf2 = 0 ;
5330  int alloc2 = 0 ;
5331  double val3 ;
5332  int ecode3 = 0 ;
5333  int val4 ;
5334  int ecode4 = 0 ;
5335  int res5 ;
5336  char *buf5 = 0 ;
5337  int alloc5 = 0 ;
5338  int res6 ;
5339  char *buf6 = 0 ;
5340  int alloc6 = 0 ;
5341  double val7 ;
5342  int ecode7 = 0 ;
5343  int val8 ;
5344  int ecode8 = 0 ;
5345  int res9 ;
5346  char *buf9 = 0 ;
5347  int alloc9 = 0 ;
5348  int res10 ;
5349  char *buf10 = 0 ;
5350  int alloc10 = 0 ;
5351  double val11 ;
5352  int ecode11 = 0 ;
5353  int val12 ;
5354  int ecode12 = 0 ;
5355  PyObject * obj0 = 0 ;
5356  PyObject * obj1 = 0 ;
5357  PyObject * obj2 = 0 ;
5358  PyObject * obj3 = 0 ;
5359  PyObject * obj4 = 0 ;
5360  PyObject * obj5 = 0 ;
5361  PyObject * obj6 = 0 ;
5362  PyObject * obj7 = 0 ;
5363  PyObject * obj8 = 0 ;
5364  PyObject * obj9 = 0 ;
5365  PyObject * obj10 = 0 ;
5366  PyObject * obj11 = 0 ;
5367 
5368  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
5369  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5370  if (!SWIG_IsOK(res1)) {
5371  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5372  }
5373  arg1 = (char *)(buf1);
5374  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5375  if (!SWIG_IsOK(res2)) {
5376  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5377  }
5378  arg2 = (char *)(buf2);
5379  ecode3 = SWIG_AsVal_double(obj2, &val3);
5380  if (!SWIG_IsOK(ecode3)) {
5381  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5382  }
5383  arg3 = (PLFLT)(val3);
5384  ecode4 = SWIG_AsVal_int(obj3, &val4);
5385  if (!SWIG_IsOK(ecode4)) {
5386  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5387  }
5388  arg4 = (PLINT)(val4);
5389  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
5390  if (!SWIG_IsOK(res5)) {
5391  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5392  }
5393  arg5 = (char *)(buf5);
5394  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
5395  if (!SWIG_IsOK(res6)) {
5396  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5397  }
5398  arg6 = (char *)(buf6);
5399  ecode7 = SWIG_AsVal_double(obj6, &val7);
5400  if (!SWIG_IsOK(ecode7)) {
5401  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5402  }
5403  arg7 = (PLFLT)(val7);
5404  ecode8 = SWIG_AsVal_int(obj7, &val8);
5405  if (!SWIG_IsOK(ecode8)) {
5406  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5407  }
5408  arg8 = (PLINT)(val8);
5409  res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
5410  if (!SWIG_IsOK(res9)) {
5411  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5412  }
5413  arg9 = (char *)(buf9);
5414  res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
5415  if (!SWIG_IsOK(res10)) {
5416  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5417  }
5418  arg10 = (char *)(buf10);
5419  ecode11 = SWIG_AsVal_double(obj10, &val11);
5420  if (!SWIG_IsOK(ecode11)) {
5421  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5422  }
5423  arg11 = (PLFLT)(val11);
5424  ecode12 = SWIG_AsVal_int(obj11, &val12);
5425  if (!SWIG_IsOK(ecode12)) {
5426  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5427  }
5428  arg12 = (PLINT)(val12);
5429  plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
5430  resultobj = SWIG_Py_Void();
5431  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5432  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5433  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5434  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5435  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5436  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5437  return resultobj;
5438 fail:
5439  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5440  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5441  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5442  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5443  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5444  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5445  return NULL;
5446 }
5447 
5448 
5449 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5450  PyObject *resultobj = 0;
5451  PLFLT arg1 ;
5452  PLFLT arg2 ;
5453  PLFLT *arg3 = (PLFLT *) 0 ;
5454  PLFLT *arg4 = (PLFLT *) 0 ;
5455  PLINT *arg5 = (PLINT *) 0 ;
5456  double val1 ;
5457  int ecode1 = 0 ;
5458  double val2 ;
5459  int ecode2 = 0 ;
5460  PLFLT temp3 ;
5461  int res3 = SWIG_TMPOBJ ;
5462  PLFLT temp4 ;
5463  int res4 = SWIG_TMPOBJ ;
5464  PLINT temp5 ;
5465  int res5 = SWIG_TMPOBJ ;
5466  PyObject * obj0 = 0 ;
5467  PyObject * obj1 = 0 ;
5468 
5469  arg3 = &temp3;
5470  arg4 = &temp4;
5471  arg5 = &temp5;
5472  if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
5473  ecode1 = SWIG_AsVal_double(obj0, &val1);
5474  if (!SWIG_IsOK(ecode1)) {
5475  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5476  }
5477  arg1 = (PLFLT)(val1);
5478  ecode2 = SWIG_AsVal_double(obj1, &val2);
5479  if (!SWIG_IsOK(ecode2)) {
5480  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5481  }
5482  arg2 = (PLFLT)(val2);
5483  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5484  resultobj = SWIG_Py_Void();
5485  if (SWIG_IsTmpObj(res3)) {
5486  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5487  } else {
5488  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5489  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5490  }
5491  if (SWIG_IsTmpObj(res4)) {
5492  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5493  } else {
5494  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5495  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5496  }
5497  if (SWIG_IsTmpObj(res5)) {
5498  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5499  } else {
5500  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5501  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5502  }
5503  return resultobj;
5504 fail:
5505  return NULL;
5506 }
5507 
5508 
5509 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5510  PyObject *resultobj = 0;
5511 
5512  if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
5513  plclear();
5514  resultobj = SWIG_Py_Void();
5515  return resultobj;
5516 fail:
5517  return NULL;
5518 }
5519 
5520 
5521 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522  PyObject *resultobj = 0;
5523  PLINT arg1 ;
5524  int val1 ;
5525  int ecode1 = 0 ;
5526  PyObject * obj0 = 0 ;
5527 
5528  if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
5529  ecode1 = SWIG_AsVal_int(obj0, &val1);
5530  if (!SWIG_IsOK(ecode1)) {
5531  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5532  }
5533  arg1 = (PLINT)(val1);
5534  plcol0(arg1);
5535  resultobj = SWIG_Py_Void();
5536  return resultobj;
5537 fail:
5538  return NULL;
5539 }
5540 
5541 
5542 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5543  PyObject *resultobj = 0;
5544  PLFLT arg1 ;
5545  double val1 ;
5546  int ecode1 = 0 ;
5547  PyObject * obj0 = 0 ;
5548 
5549  if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
5550  ecode1 = SWIG_AsVal_double(obj0, &val1);
5551  if (!SWIG_IsOK(ecode1)) {
5552  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5553  }
5554  arg1 = (PLFLT)(val1);
5555  plcol1(arg1);
5556  resultobj = SWIG_Py_Void();
5557  return resultobj;
5558 fail:
5559  return NULL;
5560 }
5561 
5562 
5563 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5564  PyObject *resultobj = 0;
5565  PLFLT arg1 ;
5566  PLFLT arg2 ;
5567  PLFLT arg3 ;
5568  PLINT arg4 ;
5569  PLBOOL arg5 ;
5570  PLINT arg6 ;
5571  PLINT arg7 ;
5572  PLINT arg8 ;
5573  PLINT arg9 ;
5574  PLINT arg10 ;
5575  PLFLT arg11 ;
5576  double val1 ;
5577  int ecode1 = 0 ;
5578  double val2 ;
5579  int ecode2 = 0 ;
5580  double val3 ;
5581  int ecode3 = 0 ;
5582  int val4 ;
5583  int ecode4 = 0 ;
5584  int val5 ;
5585  int ecode5 = 0 ;
5586  int val6 ;
5587  int ecode6 = 0 ;
5588  int val7 ;
5589  int ecode7 = 0 ;
5590  int val8 ;
5591  int ecode8 = 0 ;
5592  int val9 ;
5593  int ecode9 = 0 ;
5594  int val10 ;
5595  int ecode10 = 0 ;
5596  double val11 ;
5597  int ecode11 = 0 ;
5598  PyObject * obj0 = 0 ;
5599  PyObject * obj1 = 0 ;
5600  PyObject * obj2 = 0 ;
5601  PyObject * obj3 = 0 ;
5602  PyObject * obj4 = 0 ;
5603  PyObject * obj5 = 0 ;
5604  PyObject * obj6 = 0 ;
5605  PyObject * obj7 = 0 ;
5606  PyObject * obj8 = 0 ;
5607  PyObject * obj9 = 0 ;
5608  PyObject * obj10 = 0 ;
5609 
5610  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
5611  ecode1 = SWIG_AsVal_double(obj0, &val1);
5612  if (!SWIG_IsOK(ecode1)) {
5613  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5614  }
5615  arg1 = (PLFLT)(val1);
5616  ecode2 = SWIG_AsVal_double(obj1, &val2);
5617  if (!SWIG_IsOK(ecode2)) {
5618  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5619  }
5620  arg2 = (PLFLT)(val2);
5621  ecode3 = SWIG_AsVal_double(obj2, &val3);
5622  if (!SWIG_IsOK(ecode3)) {
5623  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5624  }
5625  arg3 = (PLFLT)(val3);
5626  ecode4 = SWIG_AsVal_int(obj3, &val4);
5627  if (!SWIG_IsOK(ecode4)) {
5628  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5629  }
5630  arg4 = (PLINT)(val4);
5631  ecode5 = SWIG_AsVal_int(obj4, &val5);
5632  if (!SWIG_IsOK(ecode5)) {
5633  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5634  }
5635  arg5 = (PLBOOL)(val5);
5636  ecode6 = SWIG_AsVal_int(obj5, &val6);
5637  if (!SWIG_IsOK(ecode6)) {
5638  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5639  }
5640  arg6 = (PLINT)(val6);
5641  ecode7 = SWIG_AsVal_int(obj6, &val7);
5642  if (!SWIG_IsOK(ecode7)) {
5643  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5644  }
5645  arg7 = (PLINT)(val7);
5646  ecode8 = SWIG_AsVal_int(obj7, &val8);
5647  if (!SWIG_IsOK(ecode8)) {
5648  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5649  }
5650  arg8 = (PLINT)(val8);
5651  ecode9 = SWIG_AsVal_int(obj8, &val9);
5652  if (!SWIG_IsOK(ecode9)) {
5653  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5654  }
5655  arg9 = (PLINT)(val9);
5656  ecode10 = SWIG_AsVal_int(obj9, &val10);
5657  if (!SWIG_IsOK(ecode10)) {
5658  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5659  }
5660  arg10 = (PLINT)(val10);
5661  ecode11 = SWIG_AsVal_double(obj10, &val11);
5662  if (!SWIG_IsOK(ecode11)) {
5663  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5664  }
5665  arg11 = (PLFLT)(val11);
5666  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5667  resultobj = SWIG_Py_Void();
5668  return resultobj;
5669 fail:
5670  return NULL;
5671 }
5672 
5673 
5674 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5675  PyObject *resultobj = 0;
5676  PLFLT **arg1 = (PLFLT **) 0 ;
5677  PLINT arg2 ;
5678  PLINT arg3 ;
5679  PLINT arg4 ;
5680  PLINT arg5 ;
5681  PLINT arg6 ;
5682  PLINT arg7 ;
5683  PLFLT *arg8 = (PLFLT *) 0 ;
5684  PLINT arg9 ;
5685  pltr_func arg10 = (pltr_func) 0 ;
5686  PLPointer arg11 = (PLPointer) 0 ;
5687  PyArrayObject *tmp1 = NULL ;
5688  int val4 ;
5689  int ecode4 = 0 ;
5690  int val5 ;
5691  int ecode5 = 0 ;
5692  int val6 ;
5693  int ecode6 = 0 ;
5694  int val7 ;
5695  int ecode7 = 0 ;
5696  PyArrayObject *tmp8 = NULL ;
5697  PyObject * obj0 = 0 ;
5698  PyObject * obj1 = 0 ;
5699  PyObject * obj2 = 0 ;
5700  PyObject * obj3 = 0 ;
5701  PyObject * obj4 = 0 ;
5702  PyObject * obj5 = 0 ;
5703  PyObject * obj6 = 0 ;
5704  PyObject * obj7 = 0 ;
5705 
5706  {
5707  python_pltr = 0;
5708  arg10 = NULL;
5709  }
5710  {
5711  arg11 = NULL;
5712  }
5713  if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5714  {
5715  int i, size;
5716  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
5717  if ( tmp1 == NULL )
5718  return NULL;
5719  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5720  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5721  size = arg3;
5722  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5723  for ( i = 0; i < arg2; i++ )
5724  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5725  }
5726  ecode4 = SWIG_AsVal_int(obj1, &val4);
5727  if (!SWIG_IsOK(ecode4)) {
5728  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5729  }
5730  arg4 = (PLINT)(val4);
5731  ecode5 = SWIG_AsVal_int(obj2, &val5);
5732  if (!SWIG_IsOK(ecode5)) {
5733  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5734  }
5735  arg5 = (PLINT)(val5);
5736  ecode6 = SWIG_AsVal_int(obj3, &val6);
5737  if (!SWIG_IsOK(ecode6)) {
5738  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5739  }
5740  arg6 = (PLINT)(val6);
5741  ecode7 = SWIG_AsVal_int(obj4, &val7);
5742  if (!SWIG_IsOK(ecode7)) {
5743  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5744  }
5745  arg7 = (PLINT)(val7);
5746  {
5747  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
5748  if ( tmp8 == NULL )
5749  return NULL;
5750  arg9 = PyArray_DIMS( tmp8 )[0];
5751  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5752  }
5753  if (obj6) {
5754  {
5755  // it must be a callable or None
5756  if ( obj6 == Py_None )
5757  {
5758  arg10 = NULL;
5759  }
5760  else
5761  {
5762  if ( !PyCallable_Check( (PyObject *) obj6 ) )
5763  {
5764  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5765  return NULL;
5766  }
5767  arg10 = marshal_pltr( obj6 );
5768  }
5769  }
5770  }
5771  if (obj7) {
5772  {
5773  if ( obj7 == Py_None )
5774  arg11 = NULL;
5775  else
5776  {
5777  arg11 = marshal_PLPointer( obj7, 0 );
5778  }
5779  }
5780  }
5781  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5782  resultobj = SWIG_Py_Void();
5783  {
5784  Py_CLEAR( tmp1 );
5785  free( arg1 );
5786  }
5787  {
5788  Py_CLEAR( tmp8 );
5789  }
5790  {
5791  cleanup_pltr();
5792  }
5793  {
5795  }
5796  return resultobj;
5797 fail:
5798  {
5799  Py_CLEAR( tmp1 );
5800  free( arg1 );
5801  }
5802  {
5803  Py_CLEAR( tmp8 );
5804  }
5805  {
5806  cleanup_pltr();
5807  }
5808  {
5810  }
5811  return NULL;
5812 }
5813 
5814 
5815 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5816  PyObject *resultobj = 0;
5817  PLINT arg1 ;
5818  PLINT arg2 ;
5819  PLINT arg3 ;
5820  PLINT arg4 ;
5821  PLINT arg5 ;
5822  PLFLT arg6 ;
5823  PLFLT *arg7 = (PLFLT *) 0 ;
5824  int val1 ;
5825  int ecode1 = 0 ;
5826  int val2 ;
5827  int ecode2 = 0 ;
5828  int val3 ;
5829  int ecode3 = 0 ;
5830  int val4 ;
5831  int ecode4 = 0 ;
5832  int val5 ;
5833  int ecode5 = 0 ;
5834  double val6 ;
5835  int ecode6 = 0 ;
5836  PLFLT temp7 ;
5837  int res7 = SWIG_TMPOBJ ;
5838  PyObject * obj0 = 0 ;
5839  PyObject * obj1 = 0 ;
5840  PyObject * obj2 = 0 ;
5841  PyObject * obj3 = 0 ;
5842  PyObject * obj4 = 0 ;
5843  PyObject * obj5 = 0 ;
5844 
5845  arg7 = &temp7;
5846  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5847  ecode1 = SWIG_AsVal_int(obj0, &val1);
5848  if (!SWIG_IsOK(ecode1)) {
5849  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5850  }
5851  arg1 = (PLINT)(val1);
5852  ecode2 = SWIG_AsVal_int(obj1, &val2);
5853  if (!SWIG_IsOK(ecode2)) {
5854  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5855  }
5856  arg2 = (PLINT)(val2);
5857  ecode3 = SWIG_AsVal_int(obj2, &val3);
5858  if (!SWIG_IsOK(ecode3)) {
5859  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5860  }
5861  arg3 = (PLINT)(val3);
5862  ecode4 = SWIG_AsVal_int(obj3, &val4);
5863  if (!SWIG_IsOK(ecode4)) {
5864  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5865  }
5866  arg4 = (PLINT)(val4);
5867  ecode5 = SWIG_AsVal_int(obj4, &val5);
5868  if (!SWIG_IsOK(ecode5)) {
5869  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5870  }
5871  arg5 = (PLINT)(val5);
5872  ecode6 = SWIG_AsVal_double(obj5, &val6);
5873  if (!SWIG_IsOK(ecode6)) {
5874  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5875  }
5876  arg6 = (PLFLT)(val6);
5877  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5878  resultobj = SWIG_Py_Void();
5879  if (SWIG_IsTmpObj(res7)) {
5880  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5881  } else {
5882  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5883  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5884  }
5885  return resultobj;
5886 fail:
5887  return NULL;
5888 }
5889 
5890 
5891 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5892  PyObject *resultobj = 0;
5893  PLINT arg1 ;
5894  PLBOOL arg2 ;
5895  int val1 ;
5896  int ecode1 = 0 ;
5897  int val2 ;
5898  int ecode2 = 0 ;
5899  PyObject * obj0 = 0 ;
5900  PyObject * obj1 = 0 ;
5901 
5902  if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
5903  ecode1 = SWIG_AsVal_int(obj0, &val1);
5904  if (!SWIG_IsOK(ecode1)) {
5905  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5906  }
5907  arg1 = (PLINT)(val1);
5908  ecode2 = SWIG_AsVal_int(obj1, &val2);
5909  if (!SWIG_IsOK(ecode2)) {
5910  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5911  }
5912  arg2 = (PLBOOL)(val2);
5913  plcpstrm(arg1,arg2);
5914  resultobj = SWIG_Py_Void();
5915  return resultobj;
5916 fail:
5917  return NULL;
5918 }
5919 
5920 
5921 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5922  PyObject *resultobj = 0;
5923 
5924  if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
5925  plend();
5926  resultobj = SWIG_Py_Void();
5927  return resultobj;
5928 fail:
5929  return NULL;
5930 }
5931 
5932 
5933 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5934  PyObject *resultobj = 0;
5935 
5936  if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
5937  plend1();
5938  resultobj = SWIG_Py_Void();
5939  return resultobj;
5940 fail:
5941  return NULL;
5942 }
5943 
5944 
5945 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5946  PyObject *resultobj = 0;
5947  PLFLT arg1 ;
5948  PLFLT arg2 ;
5949  PLFLT arg3 ;
5950  PLFLT arg4 ;
5951  PLINT arg5 ;
5952  PLINT arg6 ;
5953  double val1 ;
5954  int ecode1 = 0 ;
5955  double val2 ;
5956  int ecode2 = 0 ;
5957  double val3 ;
5958  int ecode3 = 0 ;
5959  double val4 ;
5960  int ecode4 = 0 ;
5961  int val5 ;
5962  int ecode5 = 0 ;
5963  int val6 ;
5964  int ecode6 = 0 ;
5965  PyObject * obj0 = 0 ;
5966  PyObject * obj1 = 0 ;
5967  PyObject * obj2 = 0 ;
5968  PyObject * obj3 = 0 ;
5969  PyObject * obj4 = 0 ;
5970  PyObject * obj5 = 0 ;
5971 
5972  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5973  ecode1 = SWIG_AsVal_double(obj0, &val1);
5974  if (!SWIG_IsOK(ecode1)) {
5975  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5976  }
5977  arg1 = (PLFLT)(val1);
5978  ecode2 = SWIG_AsVal_double(obj1, &val2);
5979  if (!SWIG_IsOK(ecode2)) {
5980  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5981  }
5982  arg2 = (PLFLT)(val2);
5983  ecode3 = SWIG_AsVal_double(obj2, &val3);
5984  if (!SWIG_IsOK(ecode3)) {
5985  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5986  }
5987  arg3 = (PLFLT)(val3);
5988  ecode4 = SWIG_AsVal_double(obj3, &val4);
5989  if (!SWIG_IsOK(ecode4)) {
5990  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5991  }
5992  arg4 = (PLFLT)(val4);
5993  ecode5 = SWIG_AsVal_int(obj4, &val5);
5994  if (!SWIG_IsOK(ecode5)) {
5995  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5996  }
5997  arg5 = (PLINT)(val5);
5998  ecode6 = SWIG_AsVal_int(obj5, &val6);
5999  if (!SWIG_IsOK(ecode6)) {
6000  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6001  }
6002  arg6 = (PLINT)(val6);
6003  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6004  resultobj = SWIG_Py_Void();
6005  return resultobj;
6006 fail:
6007  return NULL;
6008 }
6009 
6010 
6011 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6012  PyObject *resultobj = 0;
6013  PLFLT arg1 ;
6014  PLFLT arg2 ;
6015  PLFLT arg3 ;
6016  PLFLT arg4 ;
6017  PLINT arg5 ;
6018  PLINT arg6 ;
6019  double val1 ;
6020  int ecode1 = 0 ;
6021  double val2 ;
6022  int ecode2 = 0 ;
6023  double val3 ;
6024  int ecode3 = 0 ;
6025  double val4 ;
6026  int ecode4 = 0 ;
6027  int val5 ;
6028  int ecode5 = 0 ;
6029  int val6 ;
6030  int ecode6 = 0 ;
6031  PyObject * obj0 = 0 ;
6032  PyObject * obj1 = 0 ;
6033  PyObject * obj2 = 0 ;
6034  PyObject * obj3 = 0 ;
6035  PyObject * obj4 = 0 ;
6036  PyObject * obj5 = 0 ;
6037 
6038  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6039  ecode1 = SWIG_AsVal_double(obj0, &val1);
6040  if (!SWIG_IsOK(ecode1)) {
6041  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6042  }
6043  arg1 = (PLFLT)(val1);
6044  ecode2 = SWIG_AsVal_double(obj1, &val2);
6045  if (!SWIG_IsOK(ecode2)) {
6046  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6047  }
6048  arg2 = (PLFLT)(val2);
6049  ecode3 = SWIG_AsVal_double(obj2, &val3);
6050  if (!SWIG_IsOK(ecode3)) {
6051  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6052  }
6053  arg3 = (PLFLT)(val3);
6054  ecode4 = SWIG_AsVal_double(obj3, &val4);
6055  if (!SWIG_IsOK(ecode4)) {
6056  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6057  }
6058  arg4 = (PLFLT)(val4);
6059  ecode5 = SWIG_AsVal_int(obj4, &val5);
6060  if (!SWIG_IsOK(ecode5)) {
6061  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6062  }
6063  arg5 = (PLINT)(val5);
6064  ecode6 = SWIG_AsVal_int(obj5, &val6);
6065  if (!SWIG_IsOK(ecode6)) {
6066  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6067  }
6068  arg6 = (PLINT)(val6);
6069  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6070  resultobj = SWIG_Py_Void();
6071  return resultobj;
6072 fail:
6073  return NULL;
6074 }
6075 
6076 
6077 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078  PyObject *resultobj = 0;
6079 
6080  if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
6081  pleop();
6082  resultobj = SWIG_Py_Void();
6083  return resultobj;
6084 fail:
6085  return NULL;
6086 }
6087 
6088 
6089 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6090  PyObject *resultobj = 0;
6091  PLINT arg1 ;
6092  PLFLT *arg2 = (PLFLT *) 0 ;
6093  PLFLT *arg3 = (PLFLT *) 0 ;
6094  PLFLT *arg4 = (PLFLT *) 0 ;
6095  PyArrayObject *tmp1 = NULL ;
6096  PyArrayObject *tmp3 = NULL ;
6097  PyArrayObject *tmp4 = NULL ;
6098  PyObject * obj0 = 0 ;
6099  PyObject * obj1 = 0 ;
6100  PyObject * obj2 = 0 ;
6101 
6102  if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
6103  {
6104  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6105  if ( tmp1 == NULL )
6106  return NULL;
6107  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6108  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6109  }
6110  {
6111  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6112  if ( tmp3 == NULL )
6113  return NULL;
6114  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6115  {
6116  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6117  return NULL;
6118  }
6119  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6120  }
6121  {
6122  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6123  if ( tmp4 == NULL )
6124  return NULL;
6125  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6126  {
6127  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6128  return NULL;
6129  }
6130  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6131  }
6132  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6133  resultobj = SWIG_Py_Void();
6134  {
6135  Py_CLEAR( tmp1 );
6136  }
6137  {
6138  Py_CLEAR( tmp3 );
6139  }
6140  {
6141  Py_CLEAR( tmp4 );
6142  }
6143  return resultobj;
6144 fail:
6145  {
6146  Py_CLEAR( tmp1 );
6147  }
6148  {
6149  Py_CLEAR( tmp3 );
6150  }
6151  {
6152  Py_CLEAR( tmp4 );
6153  }
6154  return NULL;
6155 }
6156 
6157 
6158 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159  PyObject *resultobj = 0;
6160  PLINT arg1 ;
6161  PLFLT *arg2 = (PLFLT *) 0 ;
6162  PLFLT *arg3 = (PLFLT *) 0 ;
6163  PLFLT *arg4 = (PLFLT *) 0 ;
6164  PyArrayObject *tmp1 = NULL ;
6165  PyArrayObject *tmp3 = NULL ;
6166  PyArrayObject *tmp4 = NULL ;
6167  PyObject * obj0 = 0 ;
6168  PyObject * obj1 = 0 ;
6169  PyObject * obj2 = 0 ;
6170 
6171  if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
6172  {
6173  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6174  if ( tmp1 == NULL )
6175  return NULL;
6176  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6177  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6178  }
6179  {
6180  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6181  if ( tmp3 == NULL )
6182  return NULL;
6183  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6184  {
6185  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6186  return NULL;
6187  }
6188  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6189  }
6190  {
6191  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6192  if ( tmp4 == NULL )
6193  return NULL;
6194  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6195  {
6196  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6197  return NULL;
6198  }
6199  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6200  }
6201  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6202  resultobj = SWIG_Py_Void();
6203  {
6204  Py_CLEAR( tmp1 );
6205  }
6206  {
6207  Py_CLEAR( tmp3 );
6208  }
6209  {
6210  Py_CLEAR( tmp4 );
6211  }
6212  return resultobj;
6213 fail:
6214  {
6215  Py_CLEAR( tmp1 );
6216  }
6217  {
6218  Py_CLEAR( tmp3 );
6219  }
6220  {
6221  Py_CLEAR( tmp4 );
6222  }
6223  return NULL;
6224 }
6225 
6226 
6227 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6228  PyObject *resultobj = 0;
6229 
6230  if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
6231  plfamadv();
6232  resultobj = SWIG_Py_Void();
6233  return resultobj;
6234 fail:
6235  return NULL;
6236 }
6237 
6238 
6239 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240  PyObject *resultobj = 0;
6241  PLINT arg1 ;
6242  PLFLT *arg2 = (PLFLT *) 0 ;
6243  PLFLT *arg3 = (PLFLT *) 0 ;
6244  PyArrayObject *tmp1 = NULL ;
6245  PyArrayObject *tmp3 = NULL ;
6246  PyObject * obj0 = 0 ;
6247  PyObject * obj1 = 0 ;
6248 
6249  if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
6250  {
6251  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6252  if ( tmp1 == NULL )
6253  return NULL;
6254  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6255  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6256  }
6257  {
6258  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6259  if ( tmp3 == NULL )
6260  return NULL;
6261  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6262  {
6263  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6264  return NULL;
6265  }
6266  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6267  }
6268  plfill(arg1,(double const *)arg2,(double const *)arg3);
6269  resultobj = SWIG_Py_Void();
6270  {
6271  Py_CLEAR( tmp1 );
6272  }
6273  {
6274  Py_CLEAR( tmp3 );
6275  }
6276  return resultobj;
6277 fail:
6278  {
6279  Py_CLEAR( tmp1 );
6280  }
6281  {
6282  Py_CLEAR( tmp3 );
6283  }
6284  return NULL;
6285 }
6286 
6287 
6288 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6289  PyObject *resultobj = 0;
6290  PLINT arg1 ;
6291  PLFLT *arg2 = (PLFLT *) 0 ;
6292  PLFLT *arg3 = (PLFLT *) 0 ;
6293  PLFLT *arg4 = (PLFLT *) 0 ;
6294  PyArrayObject *tmp1 = NULL ;
6295  PyArrayObject *tmp3 = NULL ;
6296  PyArrayObject *tmp4 = NULL ;
6297  PyObject * obj0 = 0 ;
6298  PyObject * obj1 = 0 ;
6299  PyObject * obj2 = 0 ;
6300 
6301  if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
6302  {
6303  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6304  if ( tmp1 == NULL )
6305  return NULL;
6306  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6307  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6308  }
6309  {
6310  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6311  if ( tmp3 == NULL )
6312  return NULL;
6313  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6314  {
6315  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6316  return NULL;
6317  }
6318  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6319  }
6320  {
6321  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
6322  if ( tmp4 == NULL )
6323  return NULL;
6324  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6325  {
6326  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6327  return NULL;
6328  }
6329  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6330  }
6331  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6332  resultobj = SWIG_Py_Void();
6333  {
6334  Py_CLEAR( tmp1 );
6335  }
6336  {
6337  Py_CLEAR( tmp3 );
6338  }
6339  {
6340  Py_CLEAR( tmp4 );
6341  }
6342  return resultobj;
6343 fail:
6344  {
6345  Py_CLEAR( tmp1 );
6346  }
6347  {
6348  Py_CLEAR( tmp3 );
6349  }
6350  {
6351  Py_CLEAR( tmp4 );
6352  }
6353  return NULL;
6354 }
6355 
6356 
6357 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6358  PyObject *resultobj = 0;
6359  PLINT arg1 ;
6360  PLFLT *arg2 = (PLFLT *) 0 ;
6361  PLFLT *arg3 = (PLFLT *) 0 ;
6362  PLFLT arg4 ;
6363  PyArrayObject *tmp1 = NULL ;
6364  PyArrayObject *tmp3 = NULL ;
6365  double val4 ;
6366  int ecode4 = 0 ;
6367  PyObject * obj0 = 0 ;
6368  PyObject * obj1 = 0 ;
6369  PyObject * obj2 = 0 ;
6370 
6371  if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
6372  {
6373  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
6374  if ( tmp1 == NULL )
6375  return NULL;
6376  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6377  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6378  }
6379  {
6380  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
6381  if ( tmp3 == NULL )
6382  return NULL;
6383  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6384  {
6385  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6386  return NULL;
6387  }
6388  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6389  }
6390  ecode4 = SWIG_AsVal_double(obj2, &val4);
6391  if (!SWIG_IsOK(ecode4)) {
6392  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6393  }
6394  arg4 = (PLFLT)(val4);
6395  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6396  resultobj = SWIG_Py_Void();
6397  {
6398  Py_CLEAR( tmp1 );
6399  }
6400  {
6401  Py_CLEAR( tmp3 );
6402  }
6403  return resultobj;
6404 fail:
6405  {
6406  Py_CLEAR( tmp1 );
6407  }
6408  {
6409  Py_CLEAR( tmp3 );
6410  }
6411  return NULL;
6412 }
6413 
6414 
6415 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6416  PyObject *resultobj = 0;
6417 
6418  if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
6419  plflush();
6420  resultobj = SWIG_Py_Void();
6421  return resultobj;
6422 fail:
6423  return NULL;
6424 }
6425 
6426 
6427 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6428  PyObject *resultobj = 0;
6429  PLINT arg1 ;
6430  int val1 ;
6431  int ecode1 = 0 ;
6432  PyObject * obj0 = 0 ;
6433 
6434  if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
6435  ecode1 = SWIG_AsVal_int(obj0, &val1);
6436  if (!SWIG_IsOK(ecode1)) {
6437  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6438  }
6439  arg1 = (PLINT)(val1);
6440  plfont(arg1);
6441  resultobj = SWIG_Py_Void();
6442  return resultobj;
6443 fail:
6444  return NULL;
6445 }
6446 
6447 
6448 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6449  PyObject *resultobj = 0;
6450  PLINT arg1 ;
6451  int val1 ;
6452  int ecode1 = 0 ;
6453  PyObject * obj0 = 0 ;
6454 
6455  if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
6456  ecode1 = SWIG_AsVal_int(obj0, &val1);
6457  if (!SWIG_IsOK(ecode1)) {
6458  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6459  }
6460  arg1 = (PLINT)(val1);
6461  plfontld(arg1);
6462  resultobj = SWIG_Py_Void();
6463  return resultobj;
6464 fail:
6465  return NULL;
6466 }
6467 
6468 
6469 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6470  PyObject *resultobj = 0;
6471  PLFLT *arg1 = (PLFLT *) 0 ;
6472  PLFLT *arg2 = (PLFLT *) 0 ;
6473  PLFLT temp1 ;
6474  int res1 = SWIG_TMPOBJ ;
6475  PLFLT temp2 ;
6476  int res2 = SWIG_TMPOBJ ;
6477 
6478  arg1 = &temp1;
6479  arg2 = &temp2;
6480  if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
6481  plgchr(arg1,arg2);
6482  resultobj = SWIG_Py_Void();
6483  if (SWIG_IsTmpObj(res1)) {
6484  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6485  } else {
6486  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6487  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6488  }
6489  if (SWIG_IsTmpObj(res2)) {
6490  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6491  } else {
6492  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6493  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6494  }
6495  return resultobj;
6496 fail:
6497  return NULL;
6498 }
6499 
6500 
6501 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6502  PyObject *resultobj = 0;
6503  PLINT arg1 ;
6504  PLINT *arg2 = (PLINT *) 0 ;
6505  PLINT *arg3 = (PLINT *) 0 ;
6506  PLINT *arg4 = (PLINT *) 0 ;
6507  int val1 ;
6508  int ecode1 = 0 ;
6509  PLINT temp2 ;
6510  int res2 = SWIG_TMPOBJ ;
6511  PLINT temp3 ;
6512  int res3 = SWIG_TMPOBJ ;
6513  PLINT temp4 ;
6514  int res4 = SWIG_TMPOBJ ;
6515  PyObject * obj0 = 0 ;
6516 
6517  arg2 = &temp2;
6518  arg3 = &temp3;
6519  arg4 = &temp4;
6520  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
6521  ecode1 = SWIG_AsVal_int(obj0, &val1);
6522  if (!SWIG_IsOK(ecode1)) {
6523  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6524  }
6525  arg1 = (PLINT)(val1);
6526  plgcol0(arg1,arg2,arg3,arg4);
6527  resultobj = SWIG_Py_Void();
6528  if (SWIG_IsTmpObj(res2)) {
6529  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6530  } else {
6531  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6532  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6533  }
6534  if (SWIG_IsTmpObj(res3)) {
6535  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6536  } else {
6537  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6538  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6539  }
6540  if (SWIG_IsTmpObj(res4)) {
6541  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6542  } else {
6543  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6544  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6545  }
6546  return resultobj;
6547 fail:
6548  return NULL;
6549 }
6550 
6551 
6552 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553  PyObject *resultobj = 0;
6554  PLINT arg1 ;
6555  PLINT *arg2 = (PLINT *) 0 ;
6556  PLINT *arg3 = (PLINT *) 0 ;
6557  PLINT *arg4 = (PLINT *) 0 ;
6558  PLFLT *arg5 = (PLFLT *) 0 ;
6559  int val1 ;
6560  int ecode1 = 0 ;
6561  PLINT temp2 ;
6562  int res2 = SWIG_TMPOBJ ;
6563  PLINT temp3 ;
6564  int res3 = SWIG_TMPOBJ ;
6565  PLINT temp4 ;
6566  int res4 = SWIG_TMPOBJ ;
6567  PLFLT temp5 ;
6568  int res5 = SWIG_TMPOBJ ;
6569  PyObject * obj0 = 0 ;
6570 
6571  arg2 = &temp2;
6572  arg3 = &temp3;
6573  arg4 = &temp4;
6574  arg5 = &temp5;
6575  if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
6576  ecode1 = SWIG_AsVal_int(obj0, &val1);
6577  if (!SWIG_IsOK(ecode1)) {
6578  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6579  }
6580  arg1 = (PLINT)(val1);
6581  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6582  resultobj = SWIG_Py_Void();
6583  if (SWIG_IsTmpObj(res2)) {
6584  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6585  } else {
6586  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6587  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6588  }
6589  if (SWIG_IsTmpObj(res3)) {
6590  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6591  } else {
6592  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6593  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6594  }
6595  if (SWIG_IsTmpObj(res4)) {
6596  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6597  } else {
6598  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6599  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6600  }
6601  if (SWIG_IsTmpObj(res5)) {
6602  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6603  } else {
6604  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6605  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6606  }
6607  return resultobj;
6608 fail:
6609  return NULL;
6610 }
6611 
6612 
6613 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6614  PyObject *resultobj = 0;
6615  PLINT *arg1 = (PLINT *) 0 ;
6616  PLINT *arg2 = (PLINT *) 0 ;
6617  PLINT *arg3 = (PLINT *) 0 ;
6618  PLINT temp1 ;
6619  int res1 = SWIG_TMPOBJ ;
6620  PLINT temp2 ;
6621  int res2 = SWIG_TMPOBJ ;
6622  PLINT temp3 ;
6623  int res3 = SWIG_TMPOBJ ;
6624 
6625  arg1 = &temp1;
6626  arg2 = &temp2;
6627  arg3 = &temp3;
6628  if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
6629  plgcolbg(arg1,arg2,arg3);
6630  resultobj = SWIG_Py_Void();
6631  if (SWIG_IsTmpObj(res1)) {
6632  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6633  } else {
6634  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6635  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6636  }
6637  if (SWIG_IsTmpObj(res2)) {
6638  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6639  } else {
6640  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6641  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6642  }
6643  if (SWIG_IsTmpObj(res3)) {
6644  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6645  } else {
6646  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6647  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6648  }
6649  return resultobj;
6650 fail:
6651  return NULL;
6652 }
6653 
6654 
6655 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656  PyObject *resultobj = 0;
6657  PLINT *arg1 = (PLINT *) 0 ;
6658  PLINT *arg2 = (PLINT *) 0 ;
6659  PLINT *arg3 = (PLINT *) 0 ;
6660  PLFLT *arg4 = (PLFLT *) 0 ;
6661  PLINT temp1 ;
6662  int res1 = SWIG_TMPOBJ ;
6663  PLINT temp2 ;
6664  int res2 = SWIG_TMPOBJ ;
6665  PLINT temp3 ;
6666  int res3 = SWIG_TMPOBJ ;
6667  PLFLT temp4 ;
6668  int res4 = SWIG_TMPOBJ ;
6669 
6670  arg1 = &temp1;
6671  arg2 = &temp2;
6672  arg3 = &temp3;
6673  arg4 = &temp4;
6674  if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
6675  plgcolbga(arg1,arg2,arg3,arg4);
6676  resultobj = SWIG_Py_Void();
6677  if (SWIG_IsTmpObj(res1)) {
6678  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6679  } else {
6680  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6681  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6682  }
6683  if (SWIG_IsTmpObj(res2)) {
6684  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6685  } else {
6686  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6687  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6688  }
6689  if (SWIG_IsTmpObj(res3)) {
6690  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6691  } else {
6692  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6693  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6694  }
6695  if (SWIG_IsTmpObj(res4)) {
6696  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6697  } else {
6698  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6699  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6700  }
6701  return resultobj;
6702 fail:
6703  return NULL;
6704 }
6705 
6706 
6707 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6708  PyObject *resultobj = 0;
6709  PLINT *arg1 = (PLINT *) 0 ;
6710  PLINT temp1 ;
6711  int res1 = SWIG_TMPOBJ ;
6712 
6713  arg1 = &temp1;
6714  if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
6715  plgcompression(arg1);
6716  resultobj = SWIG_Py_Void();
6717  if (SWIG_IsTmpObj(res1)) {
6718  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6719  } else {
6720  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6721  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6722  }
6723  return resultobj;
6724 fail:
6725  return NULL;
6726 }
6727 
6728 
6729 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730  PyObject *resultobj = 0;
6731  char *arg1 = (char *) 0 ;
6732  char buff1[1000] ;
6733 
6734  {
6735  arg1 = buff1;
6736  }
6737  if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
6738  plgdev(arg1);
6739  resultobj = SWIG_Py_Void();
6740  {
6741  PyObject *o = PyString_FromString( arg1 );
6742  resultobj = t_output_helper( resultobj, o );
6743  }
6744  return resultobj;
6745 fail:
6746  return NULL;
6747 }
6748 
6749 
6750 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751  PyObject *resultobj = 0;
6752  PLFLT *arg1 = (PLFLT *) 0 ;
6753  PLFLT *arg2 = (PLFLT *) 0 ;
6754  PLFLT *arg3 = (PLFLT *) 0 ;
6755  PLFLT *arg4 = (PLFLT *) 0 ;
6756  PLFLT temp1 ;
6757  int res1 = SWIG_TMPOBJ ;
6758  PLFLT temp2 ;
6759  int res2 = SWIG_TMPOBJ ;
6760  PLFLT temp3 ;
6761  int res3 = SWIG_TMPOBJ ;
6762  PLFLT temp4 ;
6763  int res4 = SWIG_TMPOBJ ;
6764 
6765  arg1 = &temp1;
6766  arg2 = &temp2;
6767  arg3 = &temp3;
6768  arg4 = &temp4;
6769  if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
6770  plgdidev(arg1,arg2,arg3,arg4);
6771  resultobj = SWIG_Py_Void();
6772  if (SWIG_IsTmpObj(res1)) {
6773  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6774  } else {
6775  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6776  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6777  }
6778  if (SWIG_IsTmpObj(res2)) {
6779  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6780  } else {
6781  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6782  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6783  }
6784  if (SWIG_IsTmpObj(res3)) {
6785  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6786  } else {
6787  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6788  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6789  }
6790  if (SWIG_IsTmpObj(res4)) {
6791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6792  } else {
6793  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6794  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6795  }
6796  return resultobj;
6797 fail:
6798  return NULL;
6799 }
6800 
6801 
6802 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6803  PyObject *resultobj = 0;
6804  PLFLT *arg1 = (PLFLT *) 0 ;
6805  PLFLT temp1 ;
6806  int res1 = SWIG_TMPOBJ ;
6807 
6808  arg1 = &temp1;
6809  if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
6810  plgdiori(arg1);
6811  resultobj = SWIG_Py_Void();
6812  if (SWIG_IsTmpObj(res1)) {
6813  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6814  } else {
6815  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6816  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6817  }
6818  return resultobj;
6819 fail:
6820  return NULL;
6821 }
6822 
6823 
6824 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6825  PyObject *resultobj = 0;
6826  PLFLT *arg1 = (PLFLT *) 0 ;
6827  PLFLT *arg2 = (PLFLT *) 0 ;
6828  PLFLT *arg3 = (PLFLT *) 0 ;
6829  PLFLT *arg4 = (PLFLT *) 0 ;
6830  PLFLT temp1 ;
6831  int res1 = SWIG_TMPOBJ ;
6832  PLFLT temp2 ;
6833  int res2 = SWIG_TMPOBJ ;
6834  PLFLT temp3 ;
6835  int res3 = SWIG_TMPOBJ ;
6836  PLFLT temp4 ;
6837  int res4 = SWIG_TMPOBJ ;
6838 
6839  arg1 = &temp1;
6840  arg2 = &temp2;
6841  arg3 = &temp3;
6842  arg4 = &temp4;
6843  if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
6844  plgdiplt(arg1,arg2,arg3,arg4);
6845  resultobj = SWIG_Py_Void();
6846  if (SWIG_IsTmpObj(res1)) {
6847  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6848  } else {
6849  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6850  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6851  }
6852  if (SWIG_IsTmpObj(res2)) {
6853  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6854  } else {
6855  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6856  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6857  }
6858  if (SWIG_IsTmpObj(res3)) {
6859  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6860  } else {
6861  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6862  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6863  }
6864  if (SWIG_IsTmpObj(res4)) {
6865  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6866  } else {
6867  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6868  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6869  }
6870  return resultobj;
6871 fail:
6872  return NULL;
6873 }
6874 
6875 
6876 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877  PyObject *resultobj = 0;
6878  PLINT *arg1 = (PLINT *) 0 ;
6879  PLINT *arg2 = (PLINT *) 0 ;
6880  PLINT *arg3 = (PLINT *) 0 ;
6881  PLINT temp1 ;
6882  int res1 = SWIG_TMPOBJ ;
6883  PLINT temp2 ;
6884  int res2 = SWIG_TMPOBJ ;
6885  PLINT temp3 ;
6886  int res3 = SWIG_TMPOBJ ;
6887 
6888  arg1 = &temp1;
6889  arg2 = &temp2;
6890  arg3 = &temp3;
6891  if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
6892  plgfam(arg1,arg2,arg3);
6893  resultobj = SWIG_Py_Void();
6894  if (SWIG_IsTmpObj(res1)) {
6895  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6896  } else {
6897  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6898  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6899  }
6900  if (SWIG_IsTmpObj(res2)) {
6901  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6902  } else {
6903  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6904  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6905  }
6906  if (SWIG_IsTmpObj(res3)) {
6907  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6908  } else {
6909  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6911  }
6912  return resultobj;
6913 fail:
6914  return NULL;
6915 }
6916 
6917 
6918 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919  PyObject *resultobj = 0;
6920  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6921  PLUNICODE temp1 ;
6922  int res1 = SWIG_TMPOBJ ;
6923 
6924  arg1 = &temp1;
6925  if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
6926  plgfci(arg1);
6927  resultobj = SWIG_Py_Void();
6928  if (SWIG_IsTmpObj(res1)) {
6929  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6930  } else {
6931  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6933  }
6934  return resultobj;
6935 fail:
6936  return NULL;
6937 }
6938 
6939 
6940 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941  PyObject *resultobj = 0;
6942  char *arg1 = (char *) 0 ;
6943  char buff1[1000] ;
6944 
6945  {
6946  arg1 = buff1;
6947  }
6948  if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
6949  plgfnam(arg1);
6950  resultobj = SWIG_Py_Void();
6951  {
6952  PyObject *o = PyString_FromString( arg1 );
6953  resultobj = t_output_helper( resultobj, o );
6954  }
6955  return resultobj;
6956 fail:
6957  return NULL;
6958 }
6959 
6960 
6961 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6962  PyObject *resultobj = 0;
6963  PLINT *arg1 = (PLINT *) 0 ;
6964  PLINT *arg2 = (PLINT *) 0 ;
6965  PLINT *arg3 = (PLINT *) 0 ;
6966  PLINT temp1 ;
6967  int res1 = SWIG_TMPOBJ ;
6968  PLINT temp2 ;
6969  int res2 = SWIG_TMPOBJ ;
6970  PLINT temp3 ;
6971  int res3 = SWIG_TMPOBJ ;
6972 
6973  arg1 = &temp1;
6974  arg2 = &temp2;
6975  arg3 = &temp3;
6976  if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
6977  plgfont(arg1,arg2,arg3);
6978  resultobj = SWIG_Py_Void();
6979  if (SWIG_IsTmpObj(res1)) {
6980  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6981  } else {
6982  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6984  }
6985  if (SWIG_IsTmpObj(res2)) {
6986  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6987  } else {
6988  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6990  }
6991  if (SWIG_IsTmpObj(res3)) {
6992  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6993  } else {
6994  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6996  }
6997  return resultobj;
6998 fail:
6999  return NULL;
7000 }
7001 
7002 
7003 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7004  PyObject *resultobj = 0;
7005  PLINT *arg1 = (PLINT *) 0 ;
7006  PLINT temp1 ;
7007  int res1 = SWIG_TMPOBJ ;
7008 
7009  arg1 = &temp1;
7010  if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
7011  plglevel(arg1);
7012  resultobj = SWIG_Py_Void();
7013  if (SWIG_IsTmpObj(res1)) {
7014  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7015  } else {
7016  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7017  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7018  }
7019  return resultobj;
7020 fail:
7021  return NULL;
7022 }
7023 
7024 
7025 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7026  PyObject *resultobj = 0;
7027  PLFLT *arg1 = (PLFLT *) 0 ;
7028  PLFLT *arg2 = (PLFLT *) 0 ;
7029  PLINT *arg3 = (PLINT *) 0 ;
7030  PLINT *arg4 = (PLINT *) 0 ;
7031  PLINT *arg5 = (PLINT *) 0 ;
7032  PLINT *arg6 = (PLINT *) 0 ;
7033  PLFLT temp1 ;
7034  int res1 = SWIG_TMPOBJ ;
7035  PLFLT temp2 ;
7036  int res2 = SWIG_TMPOBJ ;
7037  PLINT temp3 ;
7038  int res3 = SWIG_TMPOBJ ;
7039  PLINT temp4 ;
7040  int res4 = SWIG_TMPOBJ ;
7041  PLINT temp5 ;
7042  int res5 = SWIG_TMPOBJ ;
7043  PLINT temp6 ;
7044  int res6 = SWIG_TMPOBJ ;
7045 
7046  arg1 = &temp1;
7047  arg2 = &temp2;
7048  arg3 = &temp3;
7049  arg4 = &temp4;
7050  arg5 = &temp5;
7051  arg6 = &temp6;
7052  if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
7053  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7054  resultobj = SWIG_Py_Void();
7055  if (SWIG_IsTmpObj(res1)) {
7056  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7057  } else {
7058  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7059  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7060  }
7061  if (SWIG_IsTmpObj(res2)) {
7062  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7063  } else {
7064  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7065  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7066  }
7067  if (SWIG_IsTmpObj(res3)) {
7068  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7069  } else {
7070  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7071  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7072  }
7073  if (SWIG_IsTmpObj(res4)) {
7074  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7075  } else {
7076  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7077  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7078  }
7079  if (SWIG_IsTmpObj(res5)) {
7080  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7081  } else {
7082  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7083  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7084  }
7085  if (SWIG_IsTmpObj(res6)) {
7086  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7087  } else {
7088  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7089  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7090  }
7091  return resultobj;
7092 fail:
7093  return NULL;
7094 }
7095 
7096 
7097 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098  PyObject *resultobj = 0;
7099 
7100  if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
7101  plgra();
7102  resultobj = SWIG_Py_Void();
7103  return resultobj;
7104 fail:
7105  return NULL;
7106 }
7107 
7108 
7109 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7110  PyObject *resultobj = 0;
7111  PLFLT *arg1 = (PLFLT *) 0 ;
7112  PLFLT *arg2 = (PLFLT *) 0 ;
7113  PLFLT *arg3 = (PLFLT *) 0 ;
7114  PLINT arg4 ;
7115  PLFLT *arg5 = (PLFLT *) 0 ;
7116  PLINT arg6 ;
7117  PLFLT *arg7 = (PLFLT *) 0 ;
7118  PLINT arg8 ;
7119  PLFLT **arg9 = (PLFLT **) 0 ;
7120  PLINT arg10 ;
7121  PLFLT arg11 ;
7122  PyArrayObject *tmp1 = NULL ;
7123  PyArrayObject *tmp2 = NULL ;
7124  PyArrayObject *tmp3 = NULL ;
7125  PyArrayObject *tmp5 = NULL ;
7126  PyArrayObject *tmp7 = NULL ;
7127  PyObject *array7 = NULL ;
7128  int val10 ;
7129  int ecode10 = 0 ;
7130  double val11 ;
7131  int ecode11 = 0 ;
7132  PyObject * obj0 = 0 ;
7133  PyObject * obj1 = 0 ;
7134  PyObject * obj2 = 0 ;
7135  PyObject * obj3 = 0 ;
7136  PyObject * obj4 = 0 ;
7137  PyObject * obj5 = 0 ;
7138  PyObject * obj6 = 0 ;
7139 
7140  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
7141  {
7142  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7143  if ( tmp1 == NULL )
7144  return NULL;
7145  Alen = PyArray_DIMS( tmp1 )[0];
7146  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7147  }
7148  {
7149  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
7150  if ( tmp2 == NULL )
7151  return NULL;
7152  if ( PyArray_DIMS( tmp2 )[0] != Alen )
7153  {
7154  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7155  return NULL;
7156  }
7157  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7158  }
7159  {
7160  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
7161  if ( tmp3 == NULL )
7162  return NULL;
7163  if ( PyArray_DIMS( tmp3 )[0] != Alen )
7164  {
7165  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7166  return NULL;
7167  }
7168  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7169  arg4 = PyArray_DIMS( tmp3 )[0];
7170  }
7171  {
7172  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
7173  if ( tmp5 == NULL )
7174  return NULL;
7175  Xlen = PyArray_DIMS( tmp5 )[0];
7176  arg6 = Xlen;
7177  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7178  }
7179  {
7180  int i, size;
7181  npy_intp dims[2];
7182  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
7183  if ( tmp7 == NULL )
7184  return NULL;
7185  Ylen = PyArray_DIMS( tmp7 )[0];
7186  arg8 = Ylen;
7187  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7188  // Make created 2D array7 have dimensions from prior ArrayX in the argument
7189  // list and this ArrayY.
7190  dims[0] = Xlen;
7191  dims[1] = Ylen;
7192  array7 = PyArray_SimpleNew( 2, dims, NPY_FLOAT64 );
7193  if ( !array7 )
7194  return NULL;
7195  size = Ylen;
7196  arg9 = (double **) malloc( sizeof ( double * ) * (size_t) Xlen );
7197  for ( i = 0; i < Xlen; i++ )
7198  arg9[i] = ( (double *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7199  }
7200  ecode10 = SWIG_AsVal_int(obj5, &val10);
7201  if (!SWIG_IsOK(ecode10)) {
7202  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7203  }
7204  arg10 = (PLINT)(val10);
7205  ecode11 = SWIG_AsVal_double(obj6, &val11);
7206  if (!SWIG_IsOK(ecode11)) {
7207  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7208  }
7209  arg11 = (PLFLT)(val11);
7210  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7211  resultobj = SWIG_Py_Void();
7212  {
7213  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7214  }
7215  {
7216  Py_CLEAR( tmp1 );
7217  }
7218  {
7219  Py_CLEAR( tmp2 );
7220  }
7221  {
7222  Py_CLEAR( tmp3 );
7223  }
7224  {
7225  Py_CLEAR( tmp5 );
7226  }
7227  {
7228  Py_CLEAR( tmp7 );
7229  free( arg9 );
7230  }
7231  return resultobj;
7232 fail:
7233  {
7234  Py_CLEAR( tmp1 );
7235  }
7236  {
7237  Py_CLEAR( tmp2 );
7238  }
7239  {
7240  Py_CLEAR( tmp3 );
7241  }
7242  {
7243  Py_CLEAR( tmp5 );
7244  }
7245  {
7246  Py_CLEAR( tmp7 );
7247  free( arg9 );
7248  }
7249  return NULL;
7250 }
7251 
7252 
7253 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7254  PyObject *resultobj = 0;
7255  PLFLT *arg1 = (PLFLT *) 0 ;
7256  PLFLT *arg2 = (PLFLT *) 0 ;
7257  PLFLT *arg3 = (PLFLT *) 0 ;
7258  PLFLT *arg4 = (PLFLT *) 0 ;
7259  PLFLT temp1 ;
7260  int res1 = SWIG_TMPOBJ ;
7261  PLFLT temp2 ;
7262  int res2 = SWIG_TMPOBJ ;
7263  PLFLT temp3 ;
7264  int res3 = SWIG_TMPOBJ ;
7265  PLFLT temp4 ;
7266  int res4 = SWIG_TMPOBJ ;
7267 
7268  arg1 = &temp1;
7269  arg2 = &temp2;
7270  arg3 = &temp3;
7271  arg4 = &temp4;
7272  if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
7273  plgspa(arg1,arg2,arg3,arg4);
7274  resultobj = SWIG_Py_Void();
7275  if (SWIG_IsTmpObj(res1)) {
7276  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7277  } else {
7278  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7279  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7280  }
7281  if (SWIG_IsTmpObj(res2)) {
7282  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7283  } else {
7284  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7285  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7286  }
7287  if (SWIG_IsTmpObj(res3)) {
7288  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7289  } else {
7290  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7291  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7292  }
7293  if (SWIG_IsTmpObj(res4)) {
7294  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7295  } else {
7296  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7297  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7298  }
7299  return resultobj;
7300 fail:
7301  return NULL;
7302 }
7303 
7304 
7305 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7306  PyObject *resultobj = 0;
7307  PLINT *arg1 = (PLINT *) 0 ;
7308  PLINT temp1 ;
7309  int res1 = SWIG_TMPOBJ ;
7310 
7311  arg1 = &temp1;
7312  if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
7313  plgstrm(arg1);
7314  resultobj = SWIG_Py_Void();
7315  if (SWIG_IsTmpObj(res1)) {
7316  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7317  } else {
7318  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7319  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7320  }
7321  return resultobj;
7322 fail:
7323  return NULL;
7324 }
7325 
7326 
7327 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7328  PyObject *resultobj = 0;
7329  char *arg1 = (char *) 0 ;
7330  char buff1[1000] ;
7331 
7332  {
7333  arg1 = buff1;
7334  }
7335  if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
7336  plgver(arg1);
7337  resultobj = SWIG_Py_Void();
7338  {
7339  PyObject *o = PyString_FromString( arg1 );
7340  resultobj = t_output_helper( resultobj, o );
7341  }
7342  return resultobj;
7343 fail:
7344  return NULL;
7345 }
7346 
7347 
7348 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7349  PyObject *resultobj = 0;
7350  PLFLT *arg1 = (PLFLT *) 0 ;
7351  PLFLT *arg2 = (PLFLT *) 0 ;
7352  PLFLT *arg3 = (PLFLT *) 0 ;
7353  PLFLT *arg4 = (PLFLT *) 0 ;
7354  PLFLT temp1 ;
7355  int res1 = SWIG_TMPOBJ ;
7356  PLFLT temp2 ;
7357  int res2 = SWIG_TMPOBJ ;
7358  PLFLT temp3 ;
7359  int res3 = SWIG_TMPOBJ ;
7360  PLFLT temp4 ;
7361  int res4 = SWIG_TMPOBJ ;
7362 
7363  arg1 = &temp1;
7364  arg2 = &temp2;
7365  arg3 = &temp3;
7366  arg4 = &temp4;
7367  if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
7368  plgvpd(arg1,arg2,arg3,arg4);
7369  resultobj = SWIG_Py_Void();
7370  if (SWIG_IsTmpObj(res1)) {
7371  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7372  } else {
7373  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7374  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7375  }
7376  if (SWIG_IsTmpObj(res2)) {
7377  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7378  } else {
7379  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7380  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7381  }
7382  if (SWIG_IsTmpObj(res3)) {
7383  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7384  } else {
7385  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7386  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7387  }
7388  if (SWIG_IsTmpObj(res4)) {
7389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7390  } else {
7391  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7392  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7393  }
7394  return resultobj;
7395 fail:
7396  return NULL;
7397 }
7398 
7399 
7400 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7401  PyObject *resultobj = 0;
7402  PLFLT *arg1 = (PLFLT *) 0 ;
7403  PLFLT *arg2 = (PLFLT *) 0 ;
7404  PLFLT *arg3 = (PLFLT *) 0 ;
7405  PLFLT *arg4 = (PLFLT *) 0 ;
7406  PLFLT temp1 ;
7407  int res1 = SWIG_TMPOBJ ;
7408  PLFLT temp2 ;
7409  int res2 = SWIG_TMPOBJ ;
7410  PLFLT temp3 ;
7411  int res3 = SWIG_TMPOBJ ;
7412  PLFLT temp4 ;
7413  int res4 = SWIG_TMPOBJ ;
7414 
7415  arg1 = &temp1;
7416  arg2 = &temp2;
7417  arg3 = &temp3;
7418  arg4 = &temp4;
7419  if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
7420  plgvpw(arg1,arg2,arg3,arg4);
7421  resultobj = SWIG_Py_Void();
7422  if (SWIG_IsTmpObj(res1)) {
7423  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7424  } else {
7425  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7427  }
7428  if (SWIG_IsTmpObj(res2)) {
7429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7430  } else {
7431  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7432  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7433  }
7434  if (SWIG_IsTmpObj(res3)) {
7435  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7436  } else {
7437  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7438  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7439  }
7440  if (SWIG_IsTmpObj(res4)) {
7441  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7442  } else {
7443  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7444  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7445  }
7446  return resultobj;
7447 fail:
7448  return NULL;
7449 }
7450 
7451 
7452 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7453  PyObject *resultobj = 0;
7454  PLINT *arg1 = (PLINT *) 0 ;
7455  PLINT *arg2 = (PLINT *) 0 ;
7456  PLINT temp1 ;
7457  int res1 = SWIG_TMPOBJ ;
7458  PLINT temp2 ;
7459  int res2 = SWIG_TMPOBJ ;
7460 
7461  arg1 = &temp1;
7462  arg2 = &temp2;
7463  if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
7464  plgxax(arg1,arg2);
7465  resultobj = SWIG_Py_Void();
7466  if (SWIG_IsTmpObj(res1)) {
7467  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7468  } else {
7469  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7470  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7471  }
7472  if (SWIG_IsTmpObj(res2)) {
7473  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7474  } else {
7475  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7476  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7477  }
7478  return resultobj;
7479 fail:
7480  return NULL;
7481 }
7482 
7483 
7484 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7485  PyObject *resultobj = 0;
7486  PLINT *arg1 = (PLINT *) 0 ;
7487  PLINT *arg2 = (PLINT *) 0 ;
7488  PLINT temp1 ;
7489  int res1 = SWIG_TMPOBJ ;
7490  PLINT temp2 ;
7491  int res2 = SWIG_TMPOBJ ;
7492 
7493  arg1 = &temp1;
7494  arg2 = &temp2;
7495  if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
7496  plgyax(arg1,arg2);
7497  resultobj = SWIG_Py_Void();
7498  if (SWIG_IsTmpObj(res1)) {
7499  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7500  } else {
7501  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7502  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7503  }
7504  if (SWIG_IsTmpObj(res2)) {
7505  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7506  } else {
7507  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7508  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7509  }
7510  return resultobj;
7511 fail:
7512  return NULL;
7513 }
7514 
7515 
7516 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517  PyObject *resultobj = 0;
7518  PLINT *arg1 = (PLINT *) 0 ;
7519  PLINT *arg2 = (PLINT *) 0 ;
7520  PLINT temp1 ;
7521  int res1 = SWIG_TMPOBJ ;
7522  PLINT temp2 ;
7523  int res2 = SWIG_TMPOBJ ;
7524 
7525  arg1 = &temp1;
7526  arg2 = &temp2;
7527  if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
7528  plgzax(arg1,arg2);
7529  resultobj = SWIG_Py_Void();
7530  if (SWIG_IsTmpObj(res1)) {
7531  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7532  } else {
7533  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7534  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7535  }
7536  if (SWIG_IsTmpObj(res2)) {
7537  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7538  } else {
7539  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7540  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7541  }
7542  return resultobj;
7543 fail:
7544  return NULL;
7545 }
7546 
7547 
7548 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7549  PyObject *resultobj = 0;
7550  PLINT arg1 ;
7551  PLFLT *arg2 = (PLFLT *) 0 ;
7552  PLFLT arg3 ;
7553  PLFLT arg4 ;
7554  PLINT arg5 ;
7555  PLINT arg6 ;
7556  PyArrayObject *tmp1 = NULL ;
7557  double val3 ;
7558  int ecode3 = 0 ;
7559  double val4 ;
7560  int ecode4 = 0 ;
7561  int val5 ;
7562  int ecode5 = 0 ;
7563  int val6 ;
7564  int ecode6 = 0 ;
7565  PyObject * obj0 = 0 ;
7566  PyObject * obj1 = 0 ;
7567  PyObject * obj2 = 0 ;
7568  PyObject * obj3 = 0 ;
7569  PyObject * obj4 = 0 ;
7570 
7571  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7572  {
7573  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
7574  if ( tmp1 == NULL )
7575  return NULL;
7576  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7577  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7578  }
7579  ecode3 = SWIG_AsVal_double(obj1, &val3);
7580  if (!SWIG_IsOK(ecode3)) {
7581  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7582  }
7583  arg3 = (PLFLT)(val3);
7584  ecode4 = SWIG_AsVal_double(obj2, &val4);
7585  if (!SWIG_IsOK(ecode4)) {
7586  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7587  }
7588  arg4 = (PLFLT)(val4);
7589  ecode5 = SWIG_AsVal_int(obj3, &val5);
7590  if (!SWIG_IsOK(ecode5)) {
7591  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7592  }
7593  arg5 = (PLINT)(val5);
7594  ecode6 = SWIG_AsVal_int(obj4, &val6);
7595  if (!SWIG_IsOK(ecode6)) {
7596  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7597  }
7598  arg6 = (PLINT)(val6);
7599  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7600  resultobj = SWIG_Py_Void();
7601  {
7602  Py_CLEAR( tmp1 );
7603  }
7604  return resultobj;
7605 fail:
7606  {
7607  Py_CLEAR( tmp1 );
7608  }
7609  return NULL;
7610 }
7611 
7612 
7613 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7614  PyObject *resultobj = 0;
7615  PLFLT arg1 ;
7616  PLFLT arg2 ;
7617  PLFLT arg3 ;
7618  PLFLT *arg4 = (PLFLT *) 0 ;
7619  PLFLT *arg5 = (PLFLT *) 0 ;
7620  PLFLT *arg6 = (PLFLT *) 0 ;
7621  double val1 ;
7622  int ecode1 = 0 ;
7623  double val2 ;
7624  int ecode2 = 0 ;
7625  double val3 ;
7626  int ecode3 = 0 ;
7627  PLFLT temp4 ;
7628  int res4 = SWIG_TMPOBJ ;
7629  PLFLT temp5 ;
7630  int res5 = SWIG_TMPOBJ ;
7631  PLFLT temp6 ;
7632  int res6 = SWIG_TMPOBJ ;
7633  PyObject * obj0 = 0 ;
7634  PyObject * obj1 = 0 ;
7635  PyObject * obj2 = 0 ;
7636 
7637  arg4 = &temp4;
7638  arg5 = &temp5;
7639  arg6 = &temp6;
7640  if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
7641  ecode1 = SWIG_AsVal_double(obj0, &val1);
7642  if (!SWIG_IsOK(ecode1)) {
7643  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7644  }
7645  arg1 = (PLFLT)(val1);
7646  ecode2 = SWIG_AsVal_double(obj1, &val2);
7647  if (!SWIG_IsOK(ecode2)) {
7648  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7649  }
7650  arg2 = (PLFLT)(val2);
7651  ecode3 = SWIG_AsVal_double(obj2, &val3);
7652  if (!SWIG_IsOK(ecode3)) {
7653  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7654  }
7655  arg3 = (PLFLT)(val3);
7656  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7657  resultobj = SWIG_Py_Void();
7658  if (SWIG_IsTmpObj(res4)) {
7659  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7660  } else {
7661  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7662  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7663  }
7664  if (SWIG_IsTmpObj(res5)) {
7665  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7666  } else {
7667  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7668  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7669  }
7670  if (SWIG_IsTmpObj(res6)) {
7671  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7672  } else {
7673  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7674  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7675  }
7676  return resultobj;
7677 fail:
7678  return NULL;
7679 }
7680 
7681 
7682 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683  PyObject *resultobj = 0;
7684 
7685  if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
7686  plinit();
7687  resultobj = SWIG_Py_Void();
7688  return resultobj;
7689 fail:
7690  return NULL;
7691 }
7692 
7693 
7694 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7695  PyObject *resultobj = 0;
7696  PLFLT arg1 ;
7697  PLFLT arg2 ;
7698  PLFLT arg3 ;
7699  PLFLT arg4 ;
7700  double val1 ;
7701  int ecode1 = 0 ;
7702  double val2 ;
7703  int ecode2 = 0 ;
7704  double val3 ;
7705  int ecode3 = 0 ;
7706  double val4 ;
7707  int ecode4 = 0 ;
7708  PyObject * obj0 = 0 ;
7709  PyObject * obj1 = 0 ;
7710  PyObject * obj2 = 0 ;
7711  PyObject * obj3 = 0 ;
7712 
7713  if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7714  ecode1 = SWIG_AsVal_double(obj0, &val1);
7715  if (!SWIG_IsOK(ecode1)) {
7716  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7717  }
7718  arg1 = (PLFLT)(val1);
7719  ecode2 = SWIG_AsVal_double(obj1, &val2);
7720  if (!SWIG_IsOK(ecode2)) {
7721  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7722  }
7723  arg2 = (PLFLT)(val2);
7724  ecode3 = SWIG_AsVal_double(obj2, &val3);
7725  if (!SWIG_IsOK(ecode3)) {
7726  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7727  }
7728  arg3 = (PLFLT)(val3);
7729  ecode4 = SWIG_AsVal_double(obj3, &val4);
7730  if (!SWIG_IsOK(ecode4)) {
7731  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7732  }
7733  arg4 = (PLFLT)(val4);
7734  pljoin(arg1,arg2,arg3,arg4);
7735  resultobj = SWIG_Py_Void();
7736  return resultobj;
7737 fail:
7738  return NULL;
7739 }
7740 
7741 
7742 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7743  PyObject *resultobj = 0;
7744  char *arg1 = (char *) 0 ;
7745  char *arg2 = (char *) 0 ;
7746  char *arg3 = (char *) 0 ;
7747  int res1 ;
7748  char *buf1 = 0 ;
7749  int alloc1 = 0 ;
7750  int res2 ;
7751  char *buf2 = 0 ;
7752  int alloc2 = 0 ;
7753  int res3 ;
7754  char *buf3 = 0 ;
7755  int alloc3 = 0 ;
7756  PyObject * obj0 = 0 ;
7757  PyObject * obj1 = 0 ;
7758  PyObject * obj2 = 0 ;
7759 
7760  if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
7761  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
7762  if (!SWIG_IsOK(res1)) {
7763  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7764  }
7765  arg1 = (char *)(buf1);
7766  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7767  if (!SWIG_IsOK(res2)) {
7768  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7769  }
7770  arg2 = (char *)(buf2);
7771  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
7772  if (!SWIG_IsOK(res3)) {
7773  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7774  }
7775  arg3 = (char *)(buf3);
7776  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7777  resultobj = SWIG_Py_Void();
7778  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7779  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7780  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7781  return resultobj;
7782 fail:
7783  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7784  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7785  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7786  return NULL;
7787 }
7788 
7789 
7790 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7791  PyObject *resultobj = 0;
7792  PLFLT *arg1 = (PLFLT *) 0 ;
7793  PLFLT *arg2 = (PLFLT *) 0 ;
7794  PLINT arg3 ;
7795  PLINT arg4 ;
7796  PLFLT arg5 ;
7797  PLFLT arg6 ;
7798  PLFLT arg7 ;
7799  PLINT arg8 ;
7800  PLINT arg9 ;
7801  PLINT arg10 ;
7802  PLINT arg11 ;
7803  PLINT arg12 ;
7804  PLINT arg13 ;
7805  PLINT *arg14 = (PLINT *) 0 ;
7806  PLFLT arg15 ;
7807  PLFLT arg16 ;
7808  PLFLT arg17 ;
7809  PLFLT arg18 ;
7810  PLINT *arg19 = (PLINT *) 0 ;
7811  char **arg20 = (char **) 0 ;
7812  PLINT *arg21 = (PLINT *) 0 ;
7813  PLINT *arg22 = (PLINT *) 0 ;
7814  PLFLT *arg23 = (PLFLT *) 0 ;
7815  PLFLT *arg24 = (PLFLT *) 0 ;
7816  PLINT *arg25 = (PLINT *) 0 ;
7817  PLINT *arg26 = (PLINT *) 0 ;
7818  PLFLT *arg27 = (PLFLT *) 0 ;
7819  PLINT *arg28 = (PLINT *) 0 ;
7820  PLFLT *arg29 = (PLFLT *) 0 ;
7821  PLINT *arg30 = (PLINT *) 0 ;
7822  char **arg31 = (char **) 0 ;
7823  PLFLT temp1 ;
7824  int res1 = SWIG_TMPOBJ ;
7825  PLFLT temp2 ;
7826  int res2 = SWIG_TMPOBJ ;
7827  int val3 ;
7828  int ecode3 = 0 ;
7829  int val4 ;
7830  int ecode4 = 0 ;
7831  double val5 ;
7832  int ecode5 = 0 ;
7833  double val6 ;
7834  int ecode6 = 0 ;
7835  double val7 ;
7836  int ecode7 = 0 ;
7837  int val8 ;
7838  int ecode8 = 0 ;
7839  int val9 ;
7840  int ecode9 = 0 ;
7841  int val10 ;
7842  int ecode10 = 0 ;
7843  int val11 ;
7844  int ecode11 = 0 ;
7845  int val12 ;
7846  int ecode12 = 0 ;
7847  PyArrayObject *tmp13 = NULL ;
7848  double val15 ;
7849  int ecode15 = 0 ;
7850  double val16 ;
7851  int ecode16 = 0 ;
7852  double val17 ;
7853  int ecode17 = 0 ;
7854  double val18 ;
7855  int ecode18 = 0 ;
7856  PyArrayObject *tmp19 = NULL ;
7857  PyArrayObject *tmp20 = NULL ;
7858  PyArrayObject *tmp21 = NULL ;
7859  PyArrayObject *tmp22 = NULL ;
7860  PyArrayObject *tmp23 = NULL ;
7861  PyArrayObject *tmp24 = NULL ;
7862  PyArrayObject *tmp25 = NULL ;
7863  PyArrayObject *tmp26 = NULL ;
7864  PyArrayObject *tmp27 = NULL ;
7865  PyArrayObject *tmp28 = NULL ;
7866  PyArrayObject *tmp29 = NULL ;
7867  PyArrayObject *tmp30 = NULL ;
7868  PyArrayObject *tmp31 = NULL ;
7869  PyObject * obj0 = 0 ;
7870  PyObject * obj1 = 0 ;
7871  PyObject * obj2 = 0 ;
7872  PyObject * obj3 = 0 ;
7873  PyObject * obj4 = 0 ;
7874  PyObject * obj5 = 0 ;
7875  PyObject * obj6 = 0 ;
7876  PyObject * obj7 = 0 ;
7877  PyObject * obj8 = 0 ;
7878  PyObject * obj9 = 0 ;
7879  PyObject * obj10 = 0 ;
7880  PyObject * obj11 = 0 ;
7881  PyObject * obj12 = 0 ;
7882  PyObject * obj13 = 0 ;
7883  PyObject * obj14 = 0 ;
7884  PyObject * obj15 = 0 ;
7885  PyObject * obj16 = 0 ;
7886  PyObject * obj17 = 0 ;
7887  PyObject * obj18 = 0 ;
7888  PyObject * obj19 = 0 ;
7889  PyObject * obj20 = 0 ;
7890  PyObject * obj21 = 0 ;
7891  PyObject * obj22 = 0 ;
7892  PyObject * obj23 = 0 ;
7893  PyObject * obj24 = 0 ;
7894  PyObject * obj25 = 0 ;
7895  PyObject * obj26 = 0 ;
7896  PyObject * obj27 = 0 ;
7897 
7898  arg1 = &temp1;
7899  arg2 = &temp2;
7900  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
7901  ecode3 = SWIG_AsVal_int(obj0, &val3);
7902  if (!SWIG_IsOK(ecode3)) {
7903  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7904  }
7905  arg3 = (PLINT)(val3);
7906  ecode4 = SWIG_AsVal_int(obj1, &val4);
7907  if (!SWIG_IsOK(ecode4)) {
7908  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7909  }
7910  arg4 = (PLINT)(val4);
7911  ecode5 = SWIG_AsVal_double(obj2, &val5);
7912  if (!SWIG_IsOK(ecode5)) {
7913  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7914  }
7915  arg5 = (PLFLT)(val5);
7916  ecode6 = SWIG_AsVal_double(obj3, &val6);
7917  if (!SWIG_IsOK(ecode6)) {
7918  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7919  }
7920  arg6 = (PLFLT)(val6);
7921  ecode7 = SWIG_AsVal_double(obj4, &val7);
7922  if (!SWIG_IsOK(ecode7)) {
7923  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7924  }
7925  arg7 = (PLFLT)(val7);
7926  ecode8 = SWIG_AsVal_int(obj5, &val8);
7927  if (!SWIG_IsOK(ecode8)) {
7928  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7929  }
7930  arg8 = (PLINT)(val8);
7931  ecode9 = SWIG_AsVal_int(obj6, &val9);
7932  if (!SWIG_IsOK(ecode9)) {
7933  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7934  }
7935  arg9 = (PLINT)(val9);
7936  ecode10 = SWIG_AsVal_int(obj7, &val10);
7937  if (!SWIG_IsOK(ecode10)) {
7938  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7939  }
7940  arg10 = (PLINT)(val10);
7941  ecode11 = SWIG_AsVal_int(obj8, &val11);
7942  if (!SWIG_IsOK(ecode11)) {
7943  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7944  }
7945  arg11 = (PLINT)(val11);
7946  ecode12 = SWIG_AsVal_int(obj9, &val12);
7947  if (!SWIG_IsOK(ecode12)) {
7948  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7949  }
7950  arg12 = (PLINT)(val12);
7951  {
7952  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
7953  if ( tmp13 == NULL )
7954  return NULL;
7955  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7956  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7957  }
7958  ecode15 = SWIG_AsVal_double(obj11, &val15);
7959  if (!SWIG_IsOK(ecode15)) {
7960  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7961  }
7962  arg15 = (PLFLT)(val15);
7963  ecode16 = SWIG_AsVal_double(obj12, &val16);
7964  if (!SWIG_IsOK(ecode16)) {
7965  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7966  }
7967  arg16 = (PLFLT)(val16);
7968  ecode17 = SWIG_AsVal_double(obj13, &val17);
7969  if (!SWIG_IsOK(ecode17)) {
7970  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7971  }
7972  arg17 = (PLFLT)(val17);
7973  ecode18 = SWIG_AsVal_double(obj14, &val18);
7974  if (!SWIG_IsOK(ecode18)) {
7975  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7976  }
7977  arg18 = (PLFLT)(val18);
7978  {
7979  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
7980  if ( tmp19 == NULL )
7981  return NULL;
7982  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7983  {
7984  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7985  return NULL;
7986  }
7987  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7988  }
7989  {
7990  int i;
7991  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
7992  if ( tmp20 == NULL )
7993  return NULL;
7994  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7995  {
7996  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7997  return NULL;
7998  }
7999  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8000  for ( i = 0; i < Alen; i++ )
8001  {
8002  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8003  if ( arg20[i] == NULL )
8004  {
8005  free( arg20 );
8006  return NULL;
8007  }
8008  }
8009  }
8010  {
8011  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8012  if ( tmp21 == NULL )
8013  return NULL;
8014  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8015  {
8016  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8017  return NULL;
8018  }
8019  arg21 = (PLINT *) PyArray_DATA( tmp21 );
8020  }
8021  {
8022  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8023  if ( tmp22 == NULL )
8024  return NULL;
8025  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8026  {
8027  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8028  return NULL;
8029  }
8030  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8031  }
8032  {
8033  if ( obj19 != Py_None )
8034  {
8035  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
8036  if ( tmp23 == NULL )
8037  return NULL;
8038  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8039  {
8040  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8041  return NULL;
8042  }
8043  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8044  }
8045  else
8046  {
8047  arg23 = NULL;
8048  }
8049  }
8050  {
8051  if ( obj20 != Py_None )
8052  {
8053  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
8054  if ( tmp24 == NULL )
8055  return NULL;
8056  if ( PyArray_DIMS( tmp24 )[0] != Alen )
8057  {
8058  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8059  return NULL;
8060  }
8061  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8062  }
8063  else
8064  {
8065  arg24 = NULL;
8066  }
8067  }
8068  {
8069  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
8070  if ( tmp25 == NULL )
8071  return NULL;
8072  if ( PyArray_DIMS( tmp25 )[0] != Alen )
8073  {
8074  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8075  return NULL;
8076  }
8077  arg25 = (PLINT *) PyArray_DATA( tmp25 );
8078  }
8079  {
8080  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
8081  if ( tmp26 == NULL )
8082  return NULL;
8083  if ( PyArray_DIMS( tmp26 )[0] != Alen )
8084  {
8085  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8086  return NULL;
8087  }
8088  arg26 = (PLINT *) PyArray_DATA( tmp26 );
8089  }
8090  {
8091  if ( obj23 != Py_None )
8092  {
8093  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
8094  if ( tmp27 == NULL )
8095  return NULL;
8096  if ( PyArray_DIMS( tmp27 )[0] != Alen )
8097  {
8098  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8099  return NULL;
8100  }
8101  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8102  }
8103  else
8104  {
8105  arg27 = NULL;
8106  }
8107  }
8108  {
8109  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
8110  if ( tmp28 == NULL )
8111  return NULL;
8112  if ( PyArray_DIMS( tmp28 )[0] != Alen )
8113  {
8114  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8115  return NULL;
8116  }
8117  arg28 = (PLINT *) PyArray_DATA( tmp28 );
8118  }
8119  {
8120  if ( obj25 != Py_None )
8121  {
8122  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
8123  if ( tmp29 == NULL )
8124  return NULL;
8125  if ( PyArray_DIMS( tmp29 )[0] != Alen )
8126  {
8127  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8128  return NULL;
8129  }
8130  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8131  }
8132  else
8133  {
8134  arg29 = NULL;
8135  }
8136  }
8137  {
8138  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
8139  if ( tmp30 == NULL )
8140  return NULL;
8141  if ( PyArray_DIMS( tmp30 )[0] != Alen )
8142  {
8143  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8144  return NULL;
8145  }
8146  arg30 = (PLINT *) PyArray_DATA( tmp30 );
8147  }
8148  {
8149  int i;
8150  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
8151  if ( tmp31 == NULL )
8152  return NULL;
8153  if ( PyArray_DIMS( tmp31 )[0] != Alen )
8154  {
8155  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8156  return NULL;
8157  }
8158  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8159  for ( i = 0; i < Alen; i++ )
8160  {
8161  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8162  if ( arg31[i] == NULL )
8163  {
8164  free( arg31 );
8165  return NULL;
8166  }
8167  }
8168  }
8169  pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
8170  resultobj = SWIG_Py_Void();
8171  if (SWIG_IsTmpObj(res1)) {
8172  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8173  } else {
8174  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8175  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8176  }
8177  if (SWIG_IsTmpObj(res2)) {
8178  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8179  } else {
8180  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8181  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8182  }
8183  {
8184  Py_CLEAR( tmp13 );
8185  }
8186  {
8187  Py_CLEAR( tmp19 );
8188  }
8189  {
8190  Py_CLEAR( tmp20 ); free( arg20 );
8191  }
8192  {
8193  Py_CLEAR( tmp21 );
8194  }
8195  {
8196  Py_CLEAR( tmp22 );
8197  }
8198  {
8199  Py_CLEAR( tmp23 );
8200  }
8201  {
8202  Py_CLEAR( tmp24 );
8203  }
8204  {
8205  Py_CLEAR( tmp25 );
8206  }
8207  {
8208  Py_CLEAR( tmp26 );
8209  }
8210  {
8211  Py_CLEAR( tmp27 );
8212  }
8213  {
8214  Py_CLEAR( tmp28 );
8215  }
8216  {
8217  Py_CLEAR( tmp29 );
8218  }
8219  {
8220  Py_CLEAR( tmp30 );
8221  }
8222  {
8223  Py_CLEAR( tmp31 ); free( arg31 );
8224  }
8225  return resultobj;
8226 fail:
8227  {
8228  Py_CLEAR( tmp13 );
8229  }
8230  {
8231  Py_CLEAR( tmp19 );
8232  }
8233  {
8234  Py_CLEAR( tmp20 ); free( arg20 );
8235  }
8236  {
8237  Py_CLEAR( tmp21 );
8238  }
8239  {
8240  Py_CLEAR( tmp22 );
8241  }
8242  {
8243  Py_CLEAR( tmp23 );
8244  }
8245  {
8246  Py_CLEAR( tmp24 );
8247  }
8248  {
8249  Py_CLEAR( tmp25 );
8250  }
8251  {
8252  Py_CLEAR( tmp26 );
8253  }
8254  {
8255  Py_CLEAR( tmp27 );
8256  }
8257  {
8258  Py_CLEAR( tmp28 );
8259  }
8260  {
8261  Py_CLEAR( tmp29 );
8262  }
8263  {
8264  Py_CLEAR( tmp30 );
8265  }
8266  {
8267  Py_CLEAR( tmp31 ); free( arg31 );
8268  }
8269  return NULL;
8270 }
8271 
8272 
8273 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274  PyObject *resultobj = 0;
8275  PLFLT *arg1 = (PLFLT *) 0 ;
8276  PLFLT *arg2 = (PLFLT *) 0 ;
8277  PLINT arg3 ;
8278  PLINT arg4 ;
8279  PLFLT arg5 ;
8280  PLFLT arg6 ;
8281  PLFLT arg7 ;
8282  PLFLT arg8 ;
8283  PLINT arg9 ;
8284  PLINT arg10 ;
8285  PLINT arg11 ;
8286  PLFLT arg12 ;
8287  PLFLT arg13 ;
8288  PLINT arg14 ;
8289  PLFLT arg15 ;
8290  PLINT arg16 ;
8291  PLINT *arg17 = (PLINT *) 0 ;
8292  char **arg18 = (char **) 0 ;
8293  PLINT arg19 ;
8294  char **arg20 = (char **) 0 ;
8295  PLFLT *arg21 = (PLFLT *) 0 ;
8296  PLINT *arg22 = (PLINT *) 0 ;
8297  PLINT *arg23 = (PLINT *) 0 ;
8298  PLFLT **arg24 = (PLFLT **) 0 ;
8299  PLFLT temp1 ;
8300  int res1 = SWIG_TMPOBJ ;
8301  PLFLT temp2 ;
8302  int res2 = SWIG_TMPOBJ ;
8303  int val3 ;
8304  int ecode3 = 0 ;
8305  int val4 ;
8306  int ecode4 = 0 ;
8307  double val5 ;
8308  int ecode5 = 0 ;
8309  double val6 ;
8310  int ecode6 = 0 ;
8311  double val7 ;
8312  int ecode7 = 0 ;
8313  double val8 ;
8314  int ecode8 = 0 ;
8315  int val9 ;
8316  int ecode9 = 0 ;
8317  int val10 ;
8318  int ecode10 = 0 ;
8319  int val11 ;
8320  int ecode11 = 0 ;
8321  double val12 ;
8322  int ecode12 = 0 ;
8323  double val13 ;
8324  int ecode13 = 0 ;
8325  int val14 ;
8326  int ecode14 = 0 ;
8327  double val15 ;
8328  int ecode15 = 0 ;
8329  PyArrayObject *tmp16 = NULL ;
8330  PyArrayObject *tmp18 = NULL ;
8331  PyArrayObject *tmp19 = NULL ;
8332  PyArrayObject *tmp21 = NULL ;
8333  PyArrayObject *tmp22 = NULL ;
8334  PyArrayObject *tmp23 = NULL ;
8335  PyArrayObject *tmp24 = NULL ;
8336  PyObject * obj0 = 0 ;
8337  PyObject * obj1 = 0 ;
8338  PyObject * obj2 = 0 ;
8339  PyObject * obj3 = 0 ;
8340  PyObject * obj4 = 0 ;
8341  PyObject * obj5 = 0 ;
8342  PyObject * obj6 = 0 ;
8343  PyObject * obj7 = 0 ;
8344  PyObject * obj8 = 0 ;
8345  PyObject * obj9 = 0 ;
8346  PyObject * obj10 = 0 ;
8347  PyObject * obj11 = 0 ;
8348  PyObject * obj12 = 0 ;
8349  PyObject * obj13 = 0 ;
8350  PyObject * obj14 = 0 ;
8351  PyObject * obj15 = 0 ;
8352  PyObject * obj16 = 0 ;
8353  PyObject * obj17 = 0 ;
8354  PyObject * obj18 = 0 ;
8355  PyObject * obj19 = 0 ;
8356 
8357  arg1 = &temp1;
8358  arg2 = &temp2;
8359  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:plcolorbar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
8360  ecode3 = SWIG_AsVal_int(obj0, &val3);
8361  if (!SWIG_IsOK(ecode3)) {
8362  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8363  }
8364  arg3 = (PLINT)(val3);
8365  ecode4 = SWIG_AsVal_int(obj1, &val4);
8366  if (!SWIG_IsOK(ecode4)) {
8367  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8368  }
8369  arg4 = (PLINT)(val4);
8370  ecode5 = SWIG_AsVal_double(obj2, &val5);
8371  if (!SWIG_IsOK(ecode5)) {
8372  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8373  }
8374  arg5 = (PLFLT)(val5);
8375  ecode6 = SWIG_AsVal_double(obj3, &val6);
8376  if (!SWIG_IsOK(ecode6)) {
8377  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8378  }
8379  arg6 = (PLFLT)(val6);
8380  ecode7 = SWIG_AsVal_double(obj4, &val7);
8381  if (!SWIG_IsOK(ecode7)) {
8382  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8383  }
8384  arg7 = (PLFLT)(val7);
8385  ecode8 = SWIG_AsVal_double(obj5, &val8);
8386  if (!SWIG_IsOK(ecode8)) {
8387  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8388  }
8389  arg8 = (PLFLT)(val8);
8390  ecode9 = SWIG_AsVal_int(obj6, &val9);
8391  if (!SWIG_IsOK(ecode9)) {
8392  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8393  }
8394  arg9 = (PLINT)(val9);
8395  ecode10 = SWIG_AsVal_int(obj7, &val10);
8396  if (!SWIG_IsOK(ecode10)) {
8397  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8398  }
8399  arg10 = (PLINT)(val10);
8400  ecode11 = SWIG_AsVal_int(obj8, &val11);
8401  if (!SWIG_IsOK(ecode11)) {
8402  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8403  }
8404  arg11 = (PLINT)(val11);
8405  ecode12 = SWIG_AsVal_double(obj9, &val12);
8406  if (!SWIG_IsOK(ecode12)) {
8407  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8408  }
8409  arg12 = (PLFLT)(val12);
8410  ecode13 = SWIG_AsVal_double(obj10, &val13);
8411  if (!SWIG_IsOK(ecode13)) {
8412  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8413  }
8414  arg13 = (PLFLT)(val13);
8415  ecode14 = SWIG_AsVal_int(obj11, &val14);
8416  if (!SWIG_IsOK(ecode14)) {
8417  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8418  }
8419  arg14 = (PLINT)(val14);
8420  ecode15 = SWIG_AsVal_double(obj12, &val15);
8421  if (!SWIG_IsOK(ecode15)) {
8422  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8423  }
8424  arg15 = (PLFLT)(val15);
8425  {
8426  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
8427  if ( tmp16 == NULL )
8428  return NULL;
8429  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8430  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8431  }
8432  {
8433  int i;
8434  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
8435  if ( tmp18 == NULL )
8436  return NULL;
8437  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8438  {
8439  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8440  return NULL;
8441  }
8442  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8443  for ( i = 0; i < Alen; i++ )
8444  {
8445  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8446  if ( arg18[i] == NULL )
8447  {
8448  free( arg18 );
8449  return NULL;
8450  }
8451  }
8452  }
8453  {
8454  int i;
8455  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
8456  if ( tmp19 == NULL )
8457  return NULL;
8458  Alen = PyArray_DIMS( tmp19 )[0];
8459  arg19 = Alen;
8460  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8461  for ( i = 0; i < Alen; i++ )
8462  {
8463  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8464  if ( arg20[i] == NULL )
8465  {
8466  free( arg20 );
8467  return NULL;
8468  }
8469  }
8470  }
8471  {
8472  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
8473  if ( tmp21 == NULL )
8474  return NULL;
8475  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8476  {
8477  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8478  return NULL;
8479  }
8480  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8481  }
8482  {
8483  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
8484  if ( tmp22 == NULL )
8485  return NULL;
8486  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8487  {
8488  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8489  return NULL;
8490  }
8491  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8492  }
8493  {
8494  int i;
8495  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
8496  if ( tmp23 == NULL )
8497  return NULL;
8498  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8499  {
8500  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8501  return NULL;
8502  }
8503  Xlen = PyArray_DIMS( tmp23 )[0];
8504  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8505  Ylen = -1;
8506  for ( i = 0; i < Xlen; i++ )
8507  if ( arg23[i] > Ylen )
8508  Ylen = arg23[i];
8509  }
8510  {
8511  int i, size;
8512  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
8513  if ( tmp24 == NULL )
8514  return NULL;
8515  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8516  {
8517  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8518  return NULL;
8519  }
8520  size = Ylen;
8521  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8522  for ( i = 0; i < Xlen; i++ )
8523  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8524  }
8525  plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
8526  resultobj = SWIG_Py_Void();
8527  if (SWIG_IsTmpObj(res1)) {
8528  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8529  } else {
8530  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8531  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8532  }
8533  if (SWIG_IsTmpObj(res2)) {
8534  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8535  } else {
8536  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8537  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8538  }
8539  {
8540  Py_CLEAR( tmp16 );
8541  }
8542  {
8543  Py_CLEAR( tmp18 ); free( arg18 );
8544  }
8545  {
8546  Py_CLEAR( tmp19 ); free( arg20 );
8547  }
8548  {
8549  Py_CLEAR( tmp21 );
8550  }
8551  {
8552  Py_CLEAR( tmp22 );
8553  }
8554  {
8555  Py_CLEAR( tmp23 );
8556  }
8557  {
8558  Py_CLEAR( tmp24 );
8559  free( arg24 );
8560  }
8561  return resultobj;
8562 fail:
8563  {
8564  Py_CLEAR( tmp16 );
8565  }
8566  {
8567  Py_CLEAR( tmp18 ); free( arg18 );
8568  }
8569  {
8570  Py_CLEAR( tmp19 ); free( arg20 );
8571  }
8572  {
8573  Py_CLEAR( tmp21 );
8574  }
8575  {
8576  Py_CLEAR( tmp22 );
8577  }
8578  {
8579  Py_CLEAR( tmp23 );
8580  }
8581  {
8582  Py_CLEAR( tmp24 );
8583  free( arg24 );
8584  }
8585  return NULL;
8586 }
8587 
8588 
8589 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8590  PyObject *resultobj = 0;
8591  PLFLT arg1 ;
8592  PLFLT arg2 ;
8593  PLFLT arg3 ;
8594  double val1 ;
8595  int ecode1 = 0 ;
8596  double val2 ;
8597  int ecode2 = 0 ;
8598  double val3 ;
8599  int ecode3 = 0 ;
8600  PyObject * obj0 = 0 ;
8601  PyObject * obj1 = 0 ;
8602  PyObject * obj2 = 0 ;
8603 
8604  if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
8605  ecode1 = SWIG_AsVal_double(obj0, &val1);
8606  if (!SWIG_IsOK(ecode1)) {
8607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8608  }
8609  arg1 = (PLFLT)(val1);
8610  ecode2 = SWIG_AsVal_double(obj1, &val2);
8611  if (!SWIG_IsOK(ecode2)) {
8612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8613  }
8614  arg2 = (PLFLT)(val2);
8615  ecode3 = SWIG_AsVal_double(obj2, &val3);
8616  if (!SWIG_IsOK(ecode3)) {
8617  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8618  }
8619  arg3 = (PLFLT)(val3);
8620  pllightsource(arg1,arg2,arg3);
8621  resultobj = SWIG_Py_Void();
8622  return resultobj;
8623 fail:
8624  return NULL;
8625 }
8626 
8627 
8628 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8629  PyObject *resultobj = 0;
8630  PLINT arg1 ;
8631  PLFLT *arg2 = (PLFLT *) 0 ;
8632  PLFLT *arg3 = (PLFLT *) 0 ;
8633  PyArrayObject *tmp1 = NULL ;
8634  PyArrayObject *tmp3 = NULL ;
8635  PyObject * obj0 = 0 ;
8636  PyObject * obj1 = 0 ;
8637 
8638  if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
8639  {
8640  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8641  if ( tmp1 == NULL )
8642  return NULL;
8643  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8644  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8645  }
8646  {
8647  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8648  if ( tmp3 == NULL )
8649  return NULL;
8650  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8651  {
8652  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8653  return NULL;
8654  }
8655  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8656  }
8657  plline(arg1,(double const *)arg2,(double const *)arg3);
8658  resultobj = SWIG_Py_Void();
8659  {
8660  Py_CLEAR( tmp1 );
8661  }
8662  {
8663  Py_CLEAR( tmp3 );
8664  }
8665  return resultobj;
8666 fail:
8667  {
8668  Py_CLEAR( tmp1 );
8669  }
8670  {
8671  Py_CLEAR( tmp3 );
8672  }
8673  return NULL;
8674 }
8675 
8676 
8677 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678  PyObject *resultobj = 0;
8679  PLINT arg1 ;
8680  PLFLT *arg2 = (PLFLT *) 0 ;
8681  PLFLT *arg3 = (PLFLT *) 0 ;
8682  PLFLT *arg4 = (PLFLT *) 0 ;
8683  PyArrayObject *tmp1 = NULL ;
8684  PyArrayObject *tmp3 = NULL ;
8685  PyArrayObject *tmp4 = NULL ;
8686  PyObject * obj0 = 0 ;
8687  PyObject * obj1 = 0 ;
8688  PyObject * obj2 = 0 ;
8689 
8690  if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
8691  {
8692  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8693  if ( tmp1 == NULL )
8694  return NULL;
8695  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8696  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8697  }
8698  {
8699  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8700  if ( tmp3 == NULL )
8701  return NULL;
8702  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8703  {
8704  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8705  return NULL;
8706  }
8707  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8708  }
8709  {
8710  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
8711  if ( tmp4 == NULL )
8712  return NULL;
8713  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8714  {
8715  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8716  return NULL;
8717  }
8718  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8719  }
8720  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8721  resultobj = SWIG_Py_Void();
8722  {
8723  Py_CLEAR( tmp1 );
8724  }
8725  {
8726  Py_CLEAR( tmp3 );
8727  }
8728  {
8729  Py_CLEAR( tmp4 );
8730  }
8731  return resultobj;
8732 fail:
8733  {
8734  Py_CLEAR( tmp1 );
8735  }
8736  {
8737  Py_CLEAR( tmp3 );
8738  }
8739  {
8740  Py_CLEAR( tmp4 );
8741  }
8742  return NULL;
8743 }
8744 
8745 
8746 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747  PyObject *resultobj = 0;
8748  PLINT arg1 ;
8749  int val1 ;
8750  int ecode1 = 0 ;
8751  PyObject * obj0 = 0 ;
8752 
8753  if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
8754  ecode1 = SWIG_AsVal_int(obj0, &val1);
8755  if (!SWIG_IsOK(ecode1)) {
8756  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8757  }
8758  arg1 = (PLINT)(val1);
8759  pllsty(arg1);
8760  resultobj = SWIG_Py_Void();
8761  return resultobj;
8762 fail:
8763  return NULL;
8764 }
8765 
8766 
8767 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768  PyObject *resultobj = 0;
8769  PLFLT *arg1 = (PLFLT *) 0 ;
8770  PLFLT *arg2 = (PLFLT *) 0 ;
8771  PLFLT **arg3 = (PLFLT **) 0 ;
8772  PLINT arg4 ;
8773  PLINT arg5 ;
8774  PLINT arg6 ;
8775  PyArrayObject *tmp1 = NULL ;
8776  PyArrayObject *tmp2 = NULL ;
8777  PyArrayObject *tmp3 = NULL ;
8778  int val6 ;
8779  int ecode6 = 0 ;
8780  PyObject * obj0 = 0 ;
8781  PyObject * obj1 = 0 ;
8782  PyObject * obj2 = 0 ;
8783  PyObject * obj3 = 0 ;
8784 
8785  if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8786  {
8787  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8788  if ( tmp1 == NULL )
8789  return NULL;
8790  Xlen = PyArray_DIMS( tmp1 )[0];
8791  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8792  }
8793  {
8794  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8795  if ( tmp2 == NULL )
8796  return NULL;
8797  Ylen = PyArray_DIMS( tmp2 )[0];
8798  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8799  }
8800  {
8801  int i, size;
8802  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8803  if ( tmp3 == NULL )
8804  return NULL;
8805  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8806  {
8807  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8808  return NULL;
8809  }
8810  arg4 = PyArray_DIMS( tmp3 )[0];
8811  arg5 = PyArray_DIMS( tmp3 )[1];
8812  size = arg5;
8813  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8814  for ( i = 0; i < arg4; i++ )
8815  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8816  }
8817  ecode6 = SWIG_AsVal_int(obj3, &val6);
8818  if (!SWIG_IsOK(ecode6)) {
8819  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8820  }
8821  arg6 = (PLINT)(val6);
8822  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8823  resultobj = SWIG_Py_Void();
8824  {
8825  Py_CLEAR( tmp1 );
8826  }
8827  {
8828  Py_CLEAR( tmp2 );
8829  }
8830  {
8831  Py_CLEAR( tmp3 );
8832  free( arg3 );
8833  }
8834  return resultobj;
8835 fail:
8836  {
8837  Py_CLEAR( tmp1 );
8838  }
8839  {
8840  Py_CLEAR( tmp2 );
8841  }
8842  {
8843  Py_CLEAR( tmp3 );
8844  free( arg3 );
8845  }
8846  return NULL;
8847 }
8848 
8849 
8850 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851  PyObject *resultobj = 0;
8852  PLFLT *arg1 = (PLFLT *) 0 ;
8853  PLFLT *arg2 = (PLFLT *) 0 ;
8854  PLFLT **arg3 = (PLFLT **) 0 ;
8855  PLINT arg4 ;
8856  PLINT arg5 ;
8857  PLINT arg6 ;
8858  PLFLT *arg7 = (PLFLT *) 0 ;
8859  PLINT arg8 ;
8860  PyArrayObject *tmp1 = NULL ;
8861  PyArrayObject *tmp2 = NULL ;
8862  PyArrayObject *tmp3 = NULL ;
8863  int val6 ;
8864  int ecode6 = 0 ;
8865  PyArrayObject *tmp7 = NULL ;
8866  PyObject * obj0 = 0 ;
8867  PyObject * obj1 = 0 ;
8868  PyObject * obj2 = 0 ;
8869  PyObject * obj3 = 0 ;
8870  PyObject * obj4 = 0 ;
8871 
8872  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8873  {
8874  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
8875  if ( tmp1 == NULL )
8876  return NULL;
8877  Xlen = PyArray_DIMS( tmp1 )[0];
8878  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8879  }
8880  {
8881  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
8882  if ( tmp2 == NULL )
8883  return NULL;
8884  Ylen = PyArray_DIMS( tmp2 )[0];
8885  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8886  }
8887  {
8888  int i, size;
8889  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
8890  if ( tmp3 == NULL )
8891  return NULL;
8892  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8893  {
8894  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8895  return NULL;
8896  }
8897  arg4 = PyArray_DIMS( tmp3 )[0];
8898  arg5 = PyArray_DIMS( tmp3 )[1];
8899  size = arg5;
8900  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8901  for ( i = 0; i < arg4; i++ )
8902  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8903  }
8904  ecode6 = SWIG_AsVal_int(obj3, &val6);
8905  if (!SWIG_IsOK(ecode6)) {
8906  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8907  }
8908  arg6 = (PLINT)(val6);
8909  {
8910  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
8911  if ( tmp7 == NULL )
8912  return NULL;
8913  arg8 = PyArray_DIMS( tmp7 )[0];
8914  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8915  }
8916  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8917  resultobj = SWIG_Py_Void();
8918  {
8919  Py_CLEAR( tmp1 );
8920  }
8921  {
8922  Py_CLEAR( tmp2 );
8923  }
8924  {
8925  Py_CLEAR( tmp3 );
8926  free( arg3 );
8927  }
8928  {
8929  Py_CLEAR( tmp7 );
8930  }
8931  return resultobj;
8932 fail:
8933  {
8934  Py_CLEAR( tmp1 );
8935  }
8936  {
8937  Py_CLEAR( tmp2 );
8938  }
8939  {
8940  Py_CLEAR( tmp3 );
8941  free( arg3 );
8942  }
8943  {
8944  Py_CLEAR( tmp7 );
8945  }
8946  return NULL;
8947 }
8948 
8949 
8950 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951  PyObject *resultobj = 0;
8952  PLINT *arg1 = (PLINT *) 0 ;
8953  PLINT temp1 ;
8954  int res1 = SWIG_TMPOBJ ;
8955 
8956  arg1 = &temp1;
8957  if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
8958  plmkstrm(arg1);
8959  resultobj = SWIG_Py_Void();
8960  if (SWIG_IsTmpObj(res1)) {
8961  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8962  } else {
8963  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8964  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8965  }
8966  return resultobj;
8967 fail:
8968  return NULL;
8969 }
8970 
8971 
8972 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8973  PyObject *resultobj = 0;
8974  char *arg1 = (char *) 0 ;
8975  PLFLT arg2 ;
8976  PLFLT arg3 ;
8977  PLFLT arg4 ;
8978  char *arg5 = (char *) 0 ;
8979  int res1 ;
8980  char *buf1 = 0 ;
8981  int alloc1 = 0 ;
8982  double val2 ;
8983  int ecode2 = 0 ;
8984  double val3 ;
8985  int ecode3 = 0 ;
8986  double val4 ;
8987  int ecode4 = 0 ;
8988  int res5 ;
8989  char *buf5 = 0 ;
8990  int alloc5 = 0 ;
8991  PyObject * obj0 = 0 ;
8992  PyObject * obj1 = 0 ;
8993  PyObject * obj2 = 0 ;
8994  PyObject * obj3 = 0 ;
8995  PyObject * obj4 = 0 ;
8996 
8997  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8998  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8999  if (!SWIG_IsOK(res1)) {
9000  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9001  }
9002  arg1 = (char *)(buf1);
9003  ecode2 = SWIG_AsVal_double(obj1, &val2);
9004  if (!SWIG_IsOK(ecode2)) {
9005  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9006  }
9007  arg2 = (PLFLT)(val2);
9008  ecode3 = SWIG_AsVal_double(obj2, &val3);
9009  if (!SWIG_IsOK(ecode3)) {
9010  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9011  }
9012  arg3 = (PLFLT)(val3);
9013  ecode4 = SWIG_AsVal_double(obj3, &val4);
9014  if (!SWIG_IsOK(ecode4)) {
9015  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9016  }
9017  arg4 = (PLFLT)(val4);
9018  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9019  if (!SWIG_IsOK(res5)) {
9020  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9021  }
9022  arg5 = (char *)(buf5);
9023  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9024  resultobj = SWIG_Py_Void();
9025  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9026  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9027  return resultobj;
9028 fail:
9029  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9030  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9031  return NULL;
9032 }
9033 
9034 
9035 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9036  PyObject *resultobj = 0;
9037  char *arg1 = (char *) 0 ;
9038  PLFLT arg2 ;
9039  PLFLT arg3 ;
9040  PLFLT arg4 ;
9041  char *arg5 = (char *) 0 ;
9042  int res1 ;
9043  char *buf1 = 0 ;
9044  int alloc1 = 0 ;
9045  double val2 ;
9046  int ecode2 = 0 ;
9047  double val3 ;
9048  int ecode3 = 0 ;
9049  double val4 ;
9050  int ecode4 = 0 ;
9051  int res5 ;
9052  char *buf5 = 0 ;
9053  int alloc5 = 0 ;
9054  PyObject * obj0 = 0 ;
9055  PyObject * obj1 = 0 ;
9056  PyObject * obj2 = 0 ;
9057  PyObject * obj3 = 0 ;
9058  PyObject * obj4 = 0 ;
9059 
9060  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9061  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
9062  if (!SWIG_IsOK(res1)) {
9063  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9064  }
9065  arg1 = (char *)(buf1);
9066  ecode2 = SWIG_AsVal_double(obj1, &val2);
9067  if (!SWIG_IsOK(ecode2)) {
9068  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9069  }
9070  arg2 = (PLFLT)(val2);
9071  ecode3 = SWIG_AsVal_double(obj2, &val3);
9072  if (!SWIG_IsOK(ecode3)) {
9073  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9074  }
9075  arg3 = (PLFLT)(val3);
9076  ecode4 = SWIG_AsVal_double(obj3, &val4);
9077  if (!SWIG_IsOK(ecode4)) {
9078  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9079  }
9080  arg4 = (PLFLT)(val4);
9081  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
9082  if (!SWIG_IsOK(res5)) {
9083  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9084  }
9085  arg5 = (char *)(buf5);
9086  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9087  resultobj = SWIG_Py_Void();
9088  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9089  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9090  return resultobj;
9091 fail:
9092  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9093  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9094  return NULL;
9095 }
9096 
9097 
9098 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099  PyObject *resultobj = 0;
9100  PLFLT *arg1 = (PLFLT *) 0 ;
9101  PLFLT *arg2 = (PLFLT *) 0 ;
9102  PLFLT **arg3 = (PLFLT **) 0 ;
9103  PLINT arg4 ;
9104  PLINT arg5 ;
9105  PLINT arg6 ;
9106  PLBOOL arg7 ;
9107  PyArrayObject *tmp1 = NULL ;
9108  PyArrayObject *tmp2 = NULL ;
9109  PyArrayObject *tmp3 = NULL ;
9110  int val6 ;
9111  int ecode6 = 0 ;
9112  int val7 ;
9113  int ecode7 = 0 ;
9114  PyObject * obj0 = 0 ;
9115  PyObject * obj1 = 0 ;
9116  PyObject * obj2 = 0 ;
9117  PyObject * obj3 = 0 ;
9118  PyObject * obj4 = 0 ;
9119 
9120  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9121  {
9122  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9123  if ( tmp1 == NULL )
9124  return NULL;
9125  Xlen = PyArray_DIMS( tmp1 )[0];
9126  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9127  }
9128  {
9129  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9130  if ( tmp2 == NULL )
9131  return NULL;
9132  Ylen = PyArray_DIMS( tmp2 )[0];
9133  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9134  }
9135  {
9136  int i, size;
9137  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9138  if ( tmp3 == NULL )
9139  return NULL;
9140  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9141  {
9142  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9143  return NULL;
9144  }
9145  arg4 = PyArray_DIMS( tmp3 )[0];
9146  arg5 = PyArray_DIMS( tmp3 )[1];
9147  size = arg5;
9148  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9149  for ( i = 0; i < arg4; i++ )
9150  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9151  }
9152  ecode6 = SWIG_AsVal_int(obj3, &val6);
9153  if (!SWIG_IsOK(ecode6)) {
9154  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9155  }
9156  arg6 = (PLINT)(val6);
9157  ecode7 = SWIG_AsVal_int(obj4, &val7);
9158  if (!SWIG_IsOK(ecode7)) {
9159  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9160  }
9161  arg7 = (PLBOOL)(val7);
9162  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9163  resultobj = SWIG_Py_Void();
9164  {
9165  Py_CLEAR( tmp1 );
9166  }
9167  {
9168  Py_CLEAR( tmp2 );
9169  }
9170  {
9171  Py_CLEAR( tmp3 );
9172  free( arg3 );
9173  }
9174  return resultobj;
9175 fail:
9176  {
9177  Py_CLEAR( tmp1 );
9178  }
9179  {
9180  Py_CLEAR( tmp2 );
9181  }
9182  {
9183  Py_CLEAR( tmp3 );
9184  free( arg3 );
9185  }
9186  return NULL;
9187 }
9188 
9189 
9190 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9191  PyObject *resultobj = 0;
9192  PLFLT *arg1 = (PLFLT *) 0 ;
9193  PLFLT *arg2 = (PLFLT *) 0 ;
9194  PLFLT **arg3 = (PLFLT **) 0 ;
9195  PLINT arg4 ;
9196  PLINT arg5 ;
9197  PLINT arg6 ;
9198  PLFLT *arg7 = (PLFLT *) 0 ;
9199  PLINT arg8 ;
9200  PyArrayObject *tmp1 = NULL ;
9201  PyArrayObject *tmp2 = NULL ;
9202  PyArrayObject *tmp3 = NULL ;
9203  int val6 ;
9204  int ecode6 = 0 ;
9205  PyArrayObject *tmp7 = NULL ;
9206  PyObject * obj0 = 0 ;
9207  PyObject * obj1 = 0 ;
9208  PyObject * obj2 = 0 ;
9209  PyObject * obj3 = 0 ;
9210  PyObject * obj4 = 0 ;
9211 
9212  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9213  {
9214  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9215  if ( tmp1 == NULL )
9216  return NULL;
9217  Xlen = PyArray_DIMS( tmp1 )[0];
9218  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9219  }
9220  {
9221  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9222  if ( tmp2 == NULL )
9223  return NULL;
9224  Ylen = PyArray_DIMS( tmp2 )[0];
9225  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9226  }
9227  {
9228  int i, size;
9229  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9230  if ( tmp3 == NULL )
9231  return NULL;
9232  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9233  {
9234  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9235  return NULL;
9236  }
9237  arg4 = PyArray_DIMS( tmp3 )[0];
9238  arg5 = PyArray_DIMS( tmp3 )[1];
9239  size = arg5;
9240  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9241  for ( i = 0; i < arg4; i++ )
9242  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9243  }
9244  ecode6 = SWIG_AsVal_int(obj3, &val6);
9245  if (!SWIG_IsOK(ecode6)) {
9246  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9247  }
9248  arg6 = (PLINT)(val6);
9249  {
9250  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9251  if ( tmp7 == NULL )
9252  return NULL;
9253  arg8 = PyArray_DIMS( tmp7 )[0];
9254  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9255  }
9256  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9257  resultobj = SWIG_Py_Void();
9258  {
9259  Py_CLEAR( tmp1 );
9260  }
9261  {
9262  Py_CLEAR( tmp2 );
9263  }
9264  {
9265  Py_CLEAR( tmp3 );
9266  free( arg3 );
9267  }
9268  {
9269  Py_CLEAR( tmp7 );
9270  }
9271  return resultobj;
9272 fail:
9273  {
9274  Py_CLEAR( tmp1 );
9275  }
9276  {
9277  Py_CLEAR( tmp2 );
9278  }
9279  {
9280  Py_CLEAR( tmp3 );
9281  free( arg3 );
9282  }
9283  {
9284  Py_CLEAR( tmp7 );
9285  }
9286  return NULL;
9287 }
9288 
9289 
9290 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291  PyObject *resultobj = 0;
9292  PLFLT *arg1 = (PLFLT *) 0 ;
9293  PLFLT *arg2 = (PLFLT *) 0 ;
9294  PLFLT **arg3 = (PLFLT **) 0 ;
9295  PLINT arg4 ;
9296  PLINT arg5 ;
9297  PLINT arg6 ;
9298  PLFLT *arg7 = (PLFLT *) 0 ;
9299  PLINT arg8 ;
9300  PLINT arg9 ;
9301  PLINT arg10 ;
9302  PLINT *arg11 = (PLINT *) 0 ;
9303  PLINT *arg12 = (PLINT *) 0 ;
9304  PyArrayObject *tmp1 = NULL ;
9305  PyArrayObject *tmp2 = NULL ;
9306  PyArrayObject *tmp3 = NULL ;
9307  int val6 ;
9308  int ecode6 = 0 ;
9309  PyArrayObject *tmp7 = NULL ;
9310  int val9 ;
9311  int ecode9 = 0 ;
9312  PyArrayObject *tmp10 = NULL ;
9313  PyArrayObject *tmp12 = NULL ;
9314  PyObject * obj0 = 0 ;
9315  PyObject * obj1 = 0 ;
9316  PyObject * obj2 = 0 ;
9317  PyObject * obj3 = 0 ;
9318  PyObject * obj4 = 0 ;
9319  PyObject * obj5 = 0 ;
9320  PyObject * obj6 = 0 ;
9321  PyObject * obj7 = 0 ;
9322 
9323  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9324  {
9325  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9326  if ( tmp1 == NULL )
9327  return NULL;
9328  Xlen = PyArray_DIMS( tmp1 )[0];
9329  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9330  }
9331  {
9332  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9333  if ( tmp2 == NULL )
9334  return NULL;
9335  Ylen = PyArray_DIMS( tmp2 )[0];
9336  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9337  }
9338  {
9339  int i, size;
9340  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9341  if ( tmp3 == NULL )
9342  return NULL;
9343  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9344  {
9345  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9346  return NULL;
9347  }
9348  arg4 = PyArray_DIMS( tmp3 )[0];
9349  arg5 = PyArray_DIMS( tmp3 )[1];
9350  size = arg5;
9351  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9352  for ( i = 0; i < arg4; i++ )
9353  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9354  }
9355  ecode6 = SWIG_AsVal_int(obj3, &val6);
9356  if (!SWIG_IsOK(ecode6)) {
9357  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9358  }
9359  arg6 = (PLINT)(val6);
9360  {
9361  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9362  if ( tmp7 == NULL )
9363  return NULL;
9364  arg8 = PyArray_DIMS( tmp7 )[0];
9365  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9366  }
9367  ecode9 = SWIG_AsVal_int(obj5, &val9);
9368  if (!SWIG_IsOK(ecode9)) {
9369  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9370  }
9371  arg9 = (PLINT)(val9);
9372  {
9373  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9374  if ( tmp10 == NULL )
9375  return NULL;
9376  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9377  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9378  }
9379  {
9380  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9381  if ( tmp12 == NULL )
9382  return NULL;
9383  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9384  {
9385  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9386  return NULL;
9387  }
9388  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9389  }
9390  plot3dcl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
9391  resultobj = SWIG_Py_Void();
9392  {
9393  Py_CLEAR( tmp1 );
9394  }
9395  {
9396  Py_CLEAR( tmp2 );
9397  }
9398  {
9399  Py_CLEAR( tmp3 );
9400  free( arg3 );
9401  }
9402  {
9403  Py_CLEAR( tmp7 );
9404  }
9405  {
9406  Py_CLEAR( tmp10 );
9407  }
9408  {
9409  Py_CLEAR( tmp12 );
9410  }
9411  return resultobj;
9412 fail:
9413  {
9414  Py_CLEAR( tmp1 );
9415  }
9416  {
9417  Py_CLEAR( tmp2 );
9418  }
9419  {
9420  Py_CLEAR( tmp3 );
9421  free( arg3 );
9422  }
9423  {
9424  Py_CLEAR( tmp7 );
9425  }
9426  {
9427  Py_CLEAR( tmp10 );
9428  }
9429  {
9430  Py_CLEAR( tmp12 );
9431  }
9432  return NULL;
9433 }
9434 
9435 
9436 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9437  PyObject *resultobj = 0;
9438  PLFLT *arg1 = (PLFLT *) 0 ;
9439  PLFLT *arg2 = (PLFLT *) 0 ;
9440  PLFLT **arg3 = (PLFLT **) 0 ;
9441  PLINT arg4 ;
9442  PLINT arg5 ;
9443  PLINT arg6 ;
9444  PLFLT *arg7 = (PLFLT *) 0 ;
9445  PLINT arg8 ;
9446  PyArrayObject *tmp1 = NULL ;
9447  PyArrayObject *tmp2 = NULL ;
9448  PyArrayObject *tmp3 = NULL ;
9449  int val6 ;
9450  int ecode6 = 0 ;
9451  PyArrayObject *tmp7 = NULL ;
9452  PyObject * obj0 = 0 ;
9453  PyObject * obj1 = 0 ;
9454  PyObject * obj2 = 0 ;
9455  PyObject * obj3 = 0 ;
9456  PyObject * obj4 = 0 ;
9457 
9458  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9459  {
9460  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9461  if ( tmp1 == NULL )
9462  return NULL;
9463  Xlen = PyArray_DIMS( tmp1 )[0];
9464  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9465  }
9466  {
9467  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9468  if ( tmp2 == NULL )
9469  return NULL;
9470  Ylen = PyArray_DIMS( tmp2 )[0];
9471  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9472  }
9473  {
9474  int i, size;
9475  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9476  if ( tmp3 == NULL )
9477  return NULL;
9478  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9479  {
9480  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9481  return NULL;
9482  }
9483  arg4 = PyArray_DIMS( tmp3 )[0];
9484  arg5 = PyArray_DIMS( tmp3 )[1];
9485  size = arg5;
9486  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9487  for ( i = 0; i < arg4; i++ )
9488  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9489  }
9490  ecode6 = SWIG_AsVal_int(obj3, &val6);
9491  if (!SWIG_IsOK(ecode6)) {
9492  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9493  }
9494  arg6 = (PLINT)(val6);
9495  {
9496  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9497  if ( tmp7 == NULL )
9498  return NULL;
9499  arg8 = PyArray_DIMS( tmp7 )[0];
9500  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9501  }
9502  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9503  resultobj = SWIG_Py_Void();
9504  {
9505  Py_CLEAR( tmp1 );
9506  }
9507  {
9508  Py_CLEAR( tmp2 );
9509  }
9510  {
9511  Py_CLEAR( tmp3 );
9512  free( arg3 );
9513  }
9514  {
9515  Py_CLEAR( tmp7 );
9516  }
9517  return resultobj;
9518 fail:
9519  {
9520  Py_CLEAR( tmp1 );
9521  }
9522  {
9523  Py_CLEAR( tmp2 );
9524  }
9525  {
9526  Py_CLEAR( tmp3 );
9527  free( arg3 );
9528  }
9529  {
9530  Py_CLEAR( tmp7 );
9531  }
9532  return NULL;
9533 }
9534 
9535 
9536 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537  PyObject *resultobj = 0;
9538  PLFLT *arg1 = (PLFLT *) 0 ;
9539  PLFLT *arg2 = (PLFLT *) 0 ;
9540  PLFLT **arg3 = (PLFLT **) 0 ;
9541  PLINT arg4 ;
9542  PLINT arg5 ;
9543  PLINT arg6 ;
9544  PLFLT *arg7 = (PLFLT *) 0 ;
9545  PLINT arg8 ;
9546  PLINT arg9 ;
9547  PLINT arg10 ;
9548  PLINT *arg11 = (PLINT *) 0 ;
9549  PLINT *arg12 = (PLINT *) 0 ;
9550  PyArrayObject *tmp1 = NULL ;
9551  PyArrayObject *tmp2 = NULL ;
9552  PyArrayObject *tmp3 = NULL ;
9553  int val6 ;
9554  int ecode6 = 0 ;
9555  PyArrayObject *tmp7 = NULL ;
9556  int val9 ;
9557  int ecode9 = 0 ;
9558  PyArrayObject *tmp10 = NULL ;
9559  PyArrayObject *tmp12 = NULL ;
9560  PyObject * obj0 = 0 ;
9561  PyObject * obj1 = 0 ;
9562  PyObject * obj2 = 0 ;
9563  PyObject * obj3 = 0 ;
9564  PyObject * obj4 = 0 ;
9565  PyObject * obj5 = 0 ;
9566  PyObject * obj6 = 0 ;
9567  PyObject * obj7 = 0 ;
9568 
9569  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
9570  {
9571  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9572  if ( tmp1 == NULL )
9573  return NULL;
9574  Xlen = PyArray_DIMS( tmp1 )[0];
9575  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9576  }
9577  {
9578  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9579  if ( tmp2 == NULL )
9580  return NULL;
9581  Ylen = PyArray_DIMS( tmp2 )[0];
9582  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9583  }
9584  {
9585  int i, size;
9586  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
9587  if ( tmp3 == NULL )
9588  return NULL;
9589  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9590  {
9591  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9592  return NULL;
9593  }
9594  arg4 = PyArray_DIMS( tmp3 )[0];
9595  arg5 = PyArray_DIMS( tmp3 )[1];
9596  size = arg5;
9597  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9598  for ( i = 0; i < arg4; i++ )
9599  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9600  }
9601  ecode6 = SWIG_AsVal_int(obj3, &val6);
9602  if (!SWIG_IsOK(ecode6)) {
9603  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9604  }
9605  arg6 = (PLINT)(val6);
9606  {
9607  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
9608  if ( tmp7 == NULL )
9609  return NULL;
9610  arg8 = PyArray_DIMS( tmp7 )[0];
9611  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9612  }
9613  ecode9 = SWIG_AsVal_int(obj5, &val9);
9614  if (!SWIG_IsOK(ecode9)) {
9615  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9616  }
9617  arg9 = (PLINT)(val9);
9618  {
9619  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
9620  if ( tmp10 == NULL )
9621  return NULL;
9622  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9623  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9624  }
9625  {
9626  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
9627  if ( tmp12 == NULL )
9628  return NULL;
9629  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9630  {
9631  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9632  return NULL;
9633  }
9634  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9635  }
9636  plsurf3dl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
9637  resultobj = SWIG_Py_Void();
9638  {
9639  Py_CLEAR( tmp1 );
9640  }
9641  {
9642  Py_CLEAR( tmp2 );
9643  }
9644  {
9645  Py_CLEAR( tmp3 );
9646  free( arg3 );
9647  }
9648  {
9649  Py_CLEAR( tmp7 );
9650  }
9651  {
9652  Py_CLEAR( tmp10 );
9653  }
9654  {
9655  Py_CLEAR( tmp12 );
9656  }
9657  return resultobj;
9658 fail:
9659  {
9660  Py_CLEAR( tmp1 );
9661  }
9662  {
9663  Py_CLEAR( tmp2 );
9664  }
9665  {
9666  Py_CLEAR( tmp3 );
9667  free( arg3 );
9668  }
9669  {
9670  Py_CLEAR( tmp7 );
9671  }
9672  {
9673  Py_CLEAR( tmp10 );
9674  }
9675  {
9676  Py_CLEAR( tmp12 );
9677  }
9678  return NULL;
9679 }
9680 
9681 
9682 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9683  PyObject *resultobj = 0;
9684  int *arg1 = (int *) 0 ;
9685  char **arg2 = (char **) 0 ;
9686  PLINT arg3 ;
9687  int tmp1 ;
9688  int val3 ;
9689  int ecode3 = 0 ;
9690  PyObject * obj0 = 0 ;
9691  PyObject * obj1 = 0 ;
9692  PLINT result;
9693 
9694  if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
9695  {
9696  int i;
9697  if ( !PyList_Check( obj0 ) )
9698  {
9699  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9700  return NULL;
9701  }
9702  tmp1 = PyList_Size( obj0 );
9703  arg1 = &tmp1;
9704  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9705  for ( i = 0; i < tmp1; i++ )
9706  {
9707  PyObject *s = PyList_GetItem( obj0, i );
9708  if ( !PyString_Check( s ) )
9709  {
9710  free( arg2 );
9711  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9712  return NULL;
9713  }
9714  arg2[i] = PyString_AsString( s );
9715  }
9716  arg2[i] = 0;
9717  }
9718  ecode3 = SWIG_AsVal_int(obj1, &val3);
9719  if (!SWIG_IsOK(ecode3)) {
9720  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9721  }
9722  arg3 = (PLINT)(val3);
9723  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
9724  resultobj = SWIG_From_int((int)(result));
9725  {
9726  if ( arg2 )
9727  free( arg2 );
9728  }
9729  return resultobj;
9730 fail:
9731  {
9732  if ( arg2 )
9733  free( arg2 );
9734  }
9735  return NULL;
9736 }
9737 
9738 
9739 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9740  PyObject *resultobj = 0;
9741  PLINT arg1 ;
9742  PLINT *arg2 = (PLINT *) 0 ;
9743  PLINT *arg3 = (PLINT *) 0 ;
9744  PyArrayObject *tmp1 = NULL ;
9745  PyArrayObject *tmp3 = NULL ;
9746  PyObject * obj0 = 0 ;
9747  PyObject * obj1 = 0 ;
9748 
9749  if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
9750  {
9751  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
9752  if ( tmp1 == NULL )
9753  return NULL;
9754  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9755  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9756  }
9757  {
9758  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
9759  if ( tmp3 == NULL )
9760  return NULL;
9761  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9762  {
9763  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9764  return NULL;
9765  }
9766  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9767  }
9768  plpat(arg1,(int const *)arg2,(int const *)arg3);
9769  resultobj = SWIG_Py_Void();
9770  {
9771  Py_CLEAR( tmp1 );
9772  }
9773  {
9774  Py_CLEAR( tmp3 );
9775  }
9776  return resultobj;
9777 fail:
9778  {
9779  Py_CLEAR( tmp1 );
9780  }
9781  {
9782  Py_CLEAR( tmp3 );
9783  }
9784  return NULL;
9785 }
9786 
9787 
9788 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9789  PyObject *resultobj = 0;
9790  PLINT arg1 ;
9791  PLFLT arg2 ;
9792  PLFLT arg3 ;
9793  PLFLT arg4 ;
9794  PLFLT arg5 ;
9795  int val1 ;
9796  int ecode1 = 0 ;
9797  double val2 ;
9798  int ecode2 = 0 ;
9799  double val3 ;
9800  int ecode3 = 0 ;
9801  double val4 ;
9802  int ecode4 = 0 ;
9803  double val5 ;
9804  int ecode5 = 0 ;
9805  PyObject * obj0 = 0 ;
9806  PyObject * obj1 = 0 ;
9807  PyObject * obj2 = 0 ;
9808  PyObject * obj3 = 0 ;
9809  PyObject * obj4 = 0 ;
9810 
9811  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9812  ecode1 = SWIG_AsVal_int(obj0, &val1);
9813  if (!SWIG_IsOK(ecode1)) {
9814  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9815  }
9816  arg1 = (PLINT)(val1);
9817  ecode2 = SWIG_AsVal_double(obj1, &val2);
9818  if (!SWIG_IsOK(ecode2)) {
9819  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9820  }
9821  arg2 = (PLFLT)(val2);
9822  ecode3 = SWIG_AsVal_double(obj2, &val3);
9823  if (!SWIG_IsOK(ecode3)) {
9824  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9825  }
9826  arg3 = (PLFLT)(val3);
9827  ecode4 = SWIG_AsVal_double(obj3, &val4);
9828  if (!SWIG_IsOK(ecode4)) {
9829  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9830  }
9831  arg4 = (PLFLT)(val4);
9832  ecode5 = SWIG_AsVal_double(obj4, &val5);
9833  if (!SWIG_IsOK(ecode5)) {
9834  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9835  }
9836  arg5 = (PLFLT)(val5);
9837  plpath(arg1,arg2,arg3,arg4,arg5);
9838  resultobj = SWIG_Py_Void();
9839  return resultobj;
9840 fail:
9841  return NULL;
9842 }
9843 
9844 
9845 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846  PyObject *resultobj = 0;
9847  PLINT arg1 ;
9848  PLFLT *arg2 = (PLFLT *) 0 ;
9849  PLFLT *arg3 = (PLFLT *) 0 ;
9850  PLINT arg4 ;
9851  PyArrayObject *tmp1 = NULL ;
9852  PyArrayObject *tmp3 = NULL ;
9853  int val4 ;
9854  int ecode4 = 0 ;
9855  PyObject * obj0 = 0 ;
9856  PyObject * obj1 = 0 ;
9857  PyObject * obj2 = 0 ;
9858 
9859  if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
9860  {
9861  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9862  if ( tmp1 == NULL )
9863  return NULL;
9864  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9865  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9866  }
9867  {
9868  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9869  if ( tmp3 == NULL )
9870  return NULL;
9871  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9872  {
9873  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9874  return NULL;
9875  }
9876  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9877  }
9878  ecode4 = SWIG_AsVal_int(obj2, &val4);
9879  if (!SWIG_IsOK(ecode4)) {
9880  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9881  }
9882  arg4 = (PLINT)(val4);
9883  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9884  resultobj = SWIG_Py_Void();
9885  {
9886  Py_CLEAR( tmp1 );
9887  }
9888  {
9889  Py_CLEAR( tmp3 );
9890  }
9891  return resultobj;
9892 fail:
9893  {
9894  Py_CLEAR( tmp1 );
9895  }
9896  {
9897  Py_CLEAR( tmp3 );
9898  }
9899  return NULL;
9900 }
9901 
9902 
9903 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9904  PyObject *resultobj = 0;
9905  PLINT arg1 ;
9906  PLFLT *arg2 = (PLFLT *) 0 ;
9907  PLFLT *arg3 = (PLFLT *) 0 ;
9908  PLFLT *arg4 = (PLFLT *) 0 ;
9909  PLINT arg5 ;
9910  PyArrayObject *tmp1 = NULL ;
9911  PyArrayObject *tmp3 = NULL ;
9912  PyArrayObject *tmp4 = NULL ;
9913  int val5 ;
9914  int ecode5 = 0 ;
9915  PyObject * obj0 = 0 ;
9916  PyObject * obj1 = 0 ;
9917  PyObject * obj2 = 0 ;
9918  PyObject * obj3 = 0 ;
9919 
9920  if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9921  {
9922  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
9923  if ( tmp1 == NULL )
9924  return NULL;
9925  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9926  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9927  }
9928  {
9929  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
9930  if ( tmp3 == NULL )
9931  return NULL;
9932  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9933  {
9934  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9935  return NULL;
9936  }
9937  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9938  }
9939  {
9940  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
9941  if ( tmp4 == NULL )
9942  return NULL;
9943  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9944  {
9945  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9946  return NULL;
9947  }
9948  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9949  }
9950  ecode5 = SWIG_AsVal_int(obj3, &val5);
9951  if (!SWIG_IsOK(ecode5)) {
9952  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9953  }
9954  arg5 = (PLINT)(val5);
9955  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9956  resultobj = SWIG_Py_Void();
9957  {
9958  Py_CLEAR( tmp1 );
9959  }
9960  {
9961  Py_CLEAR( tmp3 );
9962  }
9963  {
9964  Py_CLEAR( tmp4 );
9965  }
9966  return resultobj;
9967 fail:
9968  {
9969  Py_CLEAR( tmp1 );
9970  }
9971  {
9972  Py_CLEAR( tmp3 );
9973  }
9974  {
9975  Py_CLEAR( tmp4 );
9976  }
9977  return NULL;
9978 }
9979 
9980 
9981 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9982  PyObject *resultobj = 0;
9983  PLINT arg1 ;
9984  PLFLT *arg2 = (PLFLT *) 0 ;
9985  PLFLT *arg3 = (PLFLT *) 0 ;
9986  PLFLT *arg4 = (PLFLT *) 0 ;
9987  PLBOOL *arg5 = (PLBOOL *) 0 ;
9988  PLBOOL arg6 ;
9989  PyArrayObject *tmp1 = NULL ;
9990  PyArrayObject *tmp3 = NULL ;
9991  PyArrayObject *tmp4 = NULL ;
9992  PyArrayObject *tmp5 = NULL ;
9993  int val6 ;
9994  int ecode6 = 0 ;
9995  PyObject * obj0 = 0 ;
9996  PyObject * obj1 = 0 ;
9997  PyObject * obj2 = 0 ;
9998  PyObject * obj3 = 0 ;
9999  PyObject * obj4 = 0 ;
10000 
10001  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10002  {
10003  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10004  if ( tmp1 == NULL )
10005  return NULL;
10006  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10007  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10008  }
10009  {
10010  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10011  if ( tmp3 == NULL )
10012  return NULL;
10013  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10014  {
10015  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10016  return NULL;
10017  }
10018  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10019  }
10020  {
10021  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10022  if ( tmp4 == NULL )
10023  return NULL;
10024  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10025  {
10026  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10027  return NULL;
10028  }
10029  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10030  }
10031  {
10032  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10033  if ( tmp5 == NULL )
10034  return NULL;
10035  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10036  {
10037  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10038  return NULL;
10039  }
10040  arg5 = (PLINT *) PyArray_DATA( tmp5 );
10041  }
10042  ecode6 = SWIG_AsVal_int(obj4, &val6);
10043  if (!SWIG_IsOK(ecode6)) {
10044  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10045  }
10046  arg6 = (PLBOOL)(val6);
10047  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10048  resultobj = SWIG_Py_Void();
10049  {
10050  Py_CLEAR( tmp1 );
10051  }
10052  {
10053  Py_CLEAR( tmp3 );
10054  }
10055  {
10056  Py_CLEAR( tmp4 );
10057  }
10058  {
10059  Py_CLEAR( tmp5 );
10060  }
10061  return resultobj;
10062 fail:
10063  {
10064  Py_CLEAR( tmp1 );
10065  }
10066  {
10067  Py_CLEAR( tmp3 );
10068  }
10069  {
10070  Py_CLEAR( tmp4 );
10071  }
10072  {
10073  Py_CLEAR( tmp5 );
10074  }
10075  return NULL;
10076 }
10077 
10078 
10079 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10080  PyObject *resultobj = 0;
10081  PLINT arg1 ;
10082  PLINT arg2 ;
10083  int val1 ;
10084  int ecode1 = 0 ;
10085  int val2 ;
10086  int ecode2 = 0 ;
10087  PyObject * obj0 = 0 ;
10088  PyObject * obj1 = 0 ;
10089 
10090  if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10091  ecode1 = SWIG_AsVal_int(obj0, &val1);
10092  if (!SWIG_IsOK(ecode1)) {
10093  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10094  }
10095  arg1 = (PLINT)(val1);
10096  ecode2 = SWIG_AsVal_int(obj1, &val2);
10097  if (!SWIG_IsOK(ecode2)) {
10098  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10099  }
10100  arg2 = (PLINT)(val2);
10101  plprec(arg1,arg2);
10102  resultobj = SWIG_Py_Void();
10103  return resultobj;
10104 fail:
10105  return NULL;
10106 }
10107 
10108 
10109 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10110  PyObject *resultobj = 0;
10111  PLINT arg1 ;
10112  int val1 ;
10113  int ecode1 = 0 ;
10114  PyObject * obj0 = 0 ;
10115 
10116  if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10117  ecode1 = SWIG_AsVal_int(obj0, &val1);
10118  if (!SWIG_IsOK(ecode1)) {
10119  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10120  }
10121  arg1 = (PLINT)(val1);
10122  plpsty(arg1);
10123  resultobj = SWIG_Py_Void();
10124  return resultobj;
10125 fail:
10126  return NULL;
10127 }
10128 
10129 
10130 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131  PyObject *resultobj = 0;
10132  PLFLT arg1 ;
10133  PLFLT arg2 ;
10134  PLFLT arg3 ;
10135  PLFLT arg4 ;
10136  PLFLT arg5 ;
10137  char *arg6 = (char *) 0 ;
10138  double val1 ;
10139  int ecode1 = 0 ;
10140  double val2 ;
10141  int ecode2 = 0 ;
10142  double val3 ;
10143  int ecode3 = 0 ;
10144  double val4 ;
10145  int ecode4 = 0 ;
10146  double val5 ;
10147  int ecode5 = 0 ;
10148  int res6 ;
10149  char *buf6 = 0 ;
10150  int alloc6 = 0 ;
10151  PyObject * obj0 = 0 ;
10152  PyObject * obj1 = 0 ;
10153  PyObject * obj2 = 0 ;
10154  PyObject * obj3 = 0 ;
10155  PyObject * obj4 = 0 ;
10156  PyObject * obj5 = 0 ;
10157 
10158  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10159  ecode1 = SWIG_AsVal_double(obj0, &val1);
10160  if (!SWIG_IsOK(ecode1)) {
10161  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10162  }
10163  arg1 = (PLFLT)(val1);
10164  ecode2 = SWIG_AsVal_double(obj1, &val2);
10165  if (!SWIG_IsOK(ecode2)) {
10166  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10167  }
10168  arg2 = (PLFLT)(val2);
10169  ecode3 = SWIG_AsVal_double(obj2, &val3);
10170  if (!SWIG_IsOK(ecode3)) {
10171  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10172  }
10173  arg3 = (PLFLT)(val3);
10174  ecode4 = SWIG_AsVal_double(obj3, &val4);
10175  if (!SWIG_IsOK(ecode4)) {
10176  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10177  }
10178  arg4 = (PLFLT)(val4);
10179  ecode5 = SWIG_AsVal_double(obj4, &val5);
10180  if (!SWIG_IsOK(ecode5)) {
10181  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10182  }
10183  arg5 = (PLFLT)(val5);
10184  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10185  if (!SWIG_IsOK(res6)) {
10186  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10187  }
10188  arg6 = (char *)(buf6);
10189  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10190  resultobj = SWIG_Py_Void();
10191  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10192  return resultobj;
10193 fail:
10194  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10195  return NULL;
10196 }
10197 
10198 
10199 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200  PyObject *resultobj = 0;
10201  PLFLT arg1 ;
10202  PLFLT arg2 ;
10203  PLFLT arg3 ;
10204  PLFLT arg4 ;
10205  PLFLT arg5 ;
10206  PLFLT arg6 ;
10207  PLFLT arg7 ;
10208  PLFLT arg8 ;
10209  PLFLT arg9 ;
10210  PLFLT arg10 ;
10211  char *arg11 = (char *) 0 ;
10212  double val1 ;
10213  int ecode1 = 0 ;
10214  double val2 ;
10215  int ecode2 = 0 ;
10216  double val3 ;
10217  int ecode3 = 0 ;
10218  double val4 ;
10219  int ecode4 = 0 ;
10220  double val5 ;
10221  int ecode5 = 0 ;
10222  double val6 ;
10223  int ecode6 = 0 ;
10224  double val7 ;
10225  int ecode7 = 0 ;
10226  double val8 ;
10227  int ecode8 = 0 ;
10228  double val9 ;
10229  int ecode9 = 0 ;
10230  double val10 ;
10231  int ecode10 = 0 ;
10232  int res11 ;
10233  char *buf11 = 0 ;
10234  int alloc11 = 0 ;
10235  PyObject * obj0 = 0 ;
10236  PyObject * obj1 = 0 ;
10237  PyObject * obj2 = 0 ;
10238  PyObject * obj3 = 0 ;
10239  PyObject * obj4 = 0 ;
10240  PyObject * obj5 = 0 ;
10241  PyObject * obj6 = 0 ;
10242  PyObject * obj7 = 0 ;
10243  PyObject * obj8 = 0 ;
10244  PyObject * obj9 = 0 ;
10245  PyObject * obj10 = 0 ;
10246 
10247  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10248  ecode1 = SWIG_AsVal_double(obj0, &val1);
10249  if (!SWIG_IsOK(ecode1)) {
10250  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10251  }
10252  arg1 = (PLFLT)(val1);
10253  ecode2 = SWIG_AsVal_double(obj1, &val2);
10254  if (!SWIG_IsOK(ecode2)) {
10255  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10256  }
10257  arg2 = (PLFLT)(val2);
10258  ecode3 = SWIG_AsVal_double(obj2, &val3);
10259  if (!SWIG_IsOK(ecode3)) {
10260  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10261  }
10262  arg3 = (PLFLT)(val3);
10263  ecode4 = SWIG_AsVal_double(obj3, &val4);
10264  if (!SWIG_IsOK(ecode4)) {
10265  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10266  }
10267  arg4 = (PLFLT)(val4);
10268  ecode5 = SWIG_AsVal_double(obj4, &val5);
10269  if (!SWIG_IsOK(ecode5)) {
10270  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10271  }
10272  arg5 = (PLFLT)(val5);
10273  ecode6 = SWIG_AsVal_double(obj5, &val6);
10274  if (!SWIG_IsOK(ecode6)) {
10275  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10276  }
10277  arg6 = (PLFLT)(val6);
10278  ecode7 = SWIG_AsVal_double(obj6, &val7);
10279  if (!SWIG_IsOK(ecode7)) {
10280  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10281  }
10282  arg7 = (PLFLT)(val7);
10283  ecode8 = SWIG_AsVal_double(obj7, &val8);
10284  if (!SWIG_IsOK(ecode8)) {
10285  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10286  }
10287  arg8 = (PLFLT)(val8);
10288  ecode9 = SWIG_AsVal_double(obj8, &val9);
10289  if (!SWIG_IsOK(ecode9)) {
10290  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10291  }
10292  arg9 = (PLFLT)(val9);
10293  ecode10 = SWIG_AsVal_double(obj9, &val10);
10294  if (!SWIG_IsOK(ecode10)) {
10295  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10296  }
10297  arg10 = (PLFLT)(val10);
10298  res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10299  if (!SWIG_IsOK(res11)) {
10300  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10301  }
10302  arg11 = (char *)(buf11);
10303  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10304  resultobj = SWIG_Py_Void();
10305  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10306  return resultobj;
10307 fail:
10308  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10309  return NULL;
10310 }
10311 
10312 
10313 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314  PyObject *resultobj = 0;
10315  PLFLT result;
10316 
10317  if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10318  result = (PLFLT)plrandd();
10319  resultobj = SWIG_From_double((double)(result));
10320  return resultobj;
10321 fail:
10322  return NULL;
10323 }
10324 
10325 
10326 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10327  PyObject *resultobj = 0;
10328 
10329  if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10330  plreplot();
10331  resultobj = SWIG_Py_Void();
10332  return resultobj;
10333 fail:
10334  return NULL;
10335 }
10336 
10337 
10338 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10339  PyObject *resultobj = 0;
10340  PLFLT arg1 ;
10341  PLFLT arg2 ;
10342  PLFLT arg3 ;
10343  PLFLT *arg4 = (PLFLT *) 0 ;
10344  PLFLT *arg5 = (PLFLT *) 0 ;
10345  PLFLT *arg6 = (PLFLT *) 0 ;
10346  double val1 ;
10347  int ecode1 = 0 ;
10348  double val2 ;
10349  int ecode2 = 0 ;
10350  double val3 ;
10351  int ecode3 = 0 ;
10352  PLFLT temp4 ;
10353  int res4 = SWIG_TMPOBJ ;
10354  PLFLT temp5 ;
10355  int res5 = SWIG_TMPOBJ ;
10356  PLFLT temp6 ;
10357  int res6 = SWIG_TMPOBJ ;
10358  PyObject * obj0 = 0 ;
10359  PyObject * obj1 = 0 ;
10360  PyObject * obj2 = 0 ;
10361 
10362  arg4 = &temp4;
10363  arg5 = &temp5;
10364  arg6 = &temp6;
10365  if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10366  ecode1 = SWIG_AsVal_double(obj0, &val1);
10367  if (!SWIG_IsOK(ecode1)) {
10368  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10369  }
10370  arg1 = (PLFLT)(val1);
10371  ecode2 = SWIG_AsVal_double(obj1, &val2);
10372  if (!SWIG_IsOK(ecode2)) {
10373  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10374  }
10375  arg2 = (PLFLT)(val2);
10376  ecode3 = SWIG_AsVal_double(obj2, &val3);
10377  if (!SWIG_IsOK(ecode3)) {
10378  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10379  }
10380  arg3 = (PLFLT)(val3);
10381  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10382  resultobj = SWIG_Py_Void();
10383  if (SWIG_IsTmpObj(res4)) {
10384  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10385  } else {
10386  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10387  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10388  }
10389  if (SWIG_IsTmpObj(res5)) {
10390  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10391  } else {
10392  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10393  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10394  }
10395  if (SWIG_IsTmpObj(res6)) {
10396  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10397  } else {
10398  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10399  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10400  }
10401  return resultobj;
10402 fail:
10403  return NULL;
10404 }
10405 
10406 
10407 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10408  PyObject *resultobj = 0;
10409  PLFLT arg1 ;
10410  PLFLT arg2 ;
10411  double val1 ;
10412  int ecode1 = 0 ;
10413  double val2 ;
10414  int ecode2 = 0 ;
10415  PyObject * obj0 = 0 ;
10416  PyObject * obj1 = 0 ;
10417 
10418  if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10419  ecode1 = SWIG_AsVal_double(obj0, &val1);
10420  if (!SWIG_IsOK(ecode1)) {
10421  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10422  }
10423  arg1 = (PLFLT)(val1);
10424  ecode2 = SWIG_AsVal_double(obj1, &val2);
10425  if (!SWIG_IsOK(ecode2)) {
10426  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10427  }
10428  arg2 = (PLFLT)(val2);
10429  plschr(arg1,arg2);
10430  resultobj = SWIG_Py_Void();
10431  return resultobj;
10432 fail:
10433  return NULL;
10434 }
10435 
10436 
10437 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10438  PyObject *resultobj = 0;
10439  PLINT *arg1 = (PLINT *) 0 ;
10440  PLINT *arg2 = (PLINT *) 0 ;
10441  PLINT *arg3 = (PLINT *) 0 ;
10442  PLINT arg4 ;
10443  PyArrayObject *tmp1 = NULL ;
10444  PyArrayObject *tmp2 = NULL ;
10445  PyArrayObject *tmp3 = NULL ;
10446  PyObject * obj0 = 0 ;
10447  PyObject * obj1 = 0 ;
10448  PyObject * obj2 = 0 ;
10449 
10450  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10451  {
10452  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10453  if ( tmp1 == NULL )
10454  return NULL;
10455  Alen = PyArray_DIMS( tmp1 )[0];
10456  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10457  }
10458  {
10459  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10460  if ( tmp2 == NULL )
10461  return NULL;
10462  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10463  {
10464  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10465  return NULL;
10466  }
10467  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10468  }
10469  {
10470  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10471  if ( tmp3 == NULL )
10472  return NULL;
10473  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10474  {
10475  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10476  return NULL;
10477  }
10478  arg4 = PyArray_DIMS( tmp3 )[0];
10479  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10480  }
10481  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10482  resultobj = SWIG_Py_Void();
10483  {
10484  Py_CLEAR( tmp1 );
10485  }
10486  {
10487  Py_CLEAR( tmp2 );
10488  }
10489  {
10490  Py_CLEAR( tmp3 );
10491  }
10492  return resultobj;
10493 fail:
10494  {
10495  Py_CLEAR( tmp1 );
10496  }
10497  {
10498  Py_CLEAR( tmp2 );
10499  }
10500  {
10501  Py_CLEAR( tmp3 );
10502  }
10503  return NULL;
10504 }
10505 
10506 
10507 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508  PyObject *resultobj = 0;
10509  PLINT *arg1 = (PLINT *) 0 ;
10510  PLINT *arg2 = (PLINT *) 0 ;
10511  PLINT *arg3 = (PLINT *) 0 ;
10512  PLFLT *arg4 = (PLFLT *) 0 ;
10513  PLINT arg5 ;
10514  PyArrayObject *tmp1 = NULL ;
10515  PyArrayObject *tmp2 = NULL ;
10516  PyArrayObject *tmp3 = NULL ;
10517  PyArrayObject *tmp4 = NULL ;
10518  PyObject * obj0 = 0 ;
10519  PyObject * obj1 = 0 ;
10520  PyObject * obj2 = 0 ;
10521  PyObject * obj3 = 0 ;
10522 
10523  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10524  {
10525  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10526  if ( tmp1 == NULL )
10527  return NULL;
10528  Alen = PyArray_DIMS( tmp1 )[0];
10529  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10530  }
10531  {
10532  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10533  if ( tmp2 == NULL )
10534  return NULL;
10535  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10536  {
10537  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10538  return NULL;
10539  }
10540  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10541  }
10542  {
10543  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10544  if ( tmp3 == NULL )
10545  return NULL;
10546  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10547  {
10548  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10549  return NULL;
10550  }
10551  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10552  }
10553  {
10554  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10555  if ( tmp4 == NULL )
10556  return NULL;
10557  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10558  {
10559  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10560  return NULL;
10561  }
10562  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10563  arg5 = PyArray_DIMS( tmp4 )[0];
10564  }
10565  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10566  resultobj = SWIG_Py_Void();
10567  {
10568  Py_CLEAR( tmp1 );
10569  }
10570  {
10571  Py_CLEAR( tmp2 );
10572  }
10573  {
10574  Py_CLEAR( tmp3 );
10575  }
10576  {
10577  Py_CLEAR( tmp4 );
10578  }
10579  return resultobj;
10580 fail:
10581  {
10582  Py_CLEAR( tmp1 );
10583  }
10584  {
10585  Py_CLEAR( tmp2 );
10586  }
10587  {
10588  Py_CLEAR( tmp3 );
10589  }
10590  {
10591  Py_CLEAR( tmp4 );
10592  }
10593  return NULL;
10594 }
10595 
10596 
10597 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10598  PyObject *resultobj = 0;
10599  PLINT arg1 ;
10600  int val1 ;
10601  int ecode1 = 0 ;
10602  PyObject * obj0 = 0 ;
10603 
10604  if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10605  ecode1 = SWIG_AsVal_int(obj0, &val1);
10606  if (!SWIG_IsOK(ecode1)) {
10607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10608  }
10609  arg1 = (PLINT)(val1);
10610  plscmap0n(arg1);
10611  resultobj = SWIG_Py_Void();
10612  return resultobj;
10613 fail:
10614  return NULL;
10615 }
10616 
10617 
10618 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10619  PyObject *resultobj = 0;
10620  PLINT *arg1 = (PLINT *) 0 ;
10621  PLINT *arg2 = (PLINT *) 0 ;
10622  PLINT *arg3 = (PLINT *) 0 ;
10623  PLINT arg4 ;
10624  PyArrayObject *tmp1 = NULL ;
10625  PyArrayObject *tmp2 = NULL ;
10626  PyArrayObject *tmp3 = NULL ;
10627  PyObject * obj0 = 0 ;
10628  PyObject * obj1 = 0 ;
10629  PyObject * obj2 = 0 ;
10630 
10631  if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10632  {
10633  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10634  if ( tmp1 == NULL )
10635  return NULL;
10636  Alen = PyArray_DIMS( tmp1 )[0];
10637  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10638  }
10639  {
10640  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10641  if ( tmp2 == NULL )
10642  return NULL;
10643  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10644  {
10645  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10646  return NULL;
10647  }
10648  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10649  }
10650  {
10651  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10652  if ( tmp3 == NULL )
10653  return NULL;
10654  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10655  {
10656  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10657  return NULL;
10658  }
10659  arg4 = PyArray_DIMS( tmp3 )[0];
10660  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10661  }
10662  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10663  resultobj = SWIG_Py_Void();
10664  {
10665  Py_CLEAR( tmp1 );
10666  }
10667  {
10668  Py_CLEAR( tmp2 );
10669  }
10670  {
10671  Py_CLEAR( tmp3 );
10672  }
10673  return resultobj;
10674 fail:
10675  {
10676  Py_CLEAR( tmp1 );
10677  }
10678  {
10679  Py_CLEAR( tmp2 );
10680  }
10681  {
10682  Py_CLEAR( tmp3 );
10683  }
10684  return NULL;
10685 }
10686 
10687 
10688 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10689  PyObject *resultobj = 0;
10690  PLINT *arg1 = (PLINT *) 0 ;
10691  PLINT *arg2 = (PLINT *) 0 ;
10692  PLINT *arg3 = (PLINT *) 0 ;
10693  PLFLT *arg4 = (PLFLT *) 0 ;
10694  PLINT arg5 ;
10695  PyArrayObject *tmp1 = NULL ;
10696  PyArrayObject *tmp2 = NULL ;
10697  PyArrayObject *tmp3 = NULL ;
10698  PyArrayObject *tmp4 = NULL ;
10699  PyObject * obj0 = 0 ;
10700  PyObject * obj1 = 0 ;
10701  PyObject * obj2 = 0 ;
10702  PyObject * obj3 = 0 ;
10703 
10704  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10705  {
10706  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10707  if ( tmp1 == NULL )
10708  return NULL;
10709  Alen = PyArray_DIMS( tmp1 )[0];
10710  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10711  }
10712  {
10713  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10714  if ( tmp2 == NULL )
10715  return NULL;
10716  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10717  {
10718  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10719  return NULL;
10720  }
10721  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10722  }
10723  {
10724  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10725  if ( tmp3 == NULL )
10726  return NULL;
10727  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10728  {
10729  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10730  return NULL;
10731  }
10732  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10733  }
10734  {
10735  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10736  if ( tmp4 == NULL )
10737  return NULL;
10738  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10739  {
10740  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10741  return NULL;
10742  }
10743  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10744  arg5 = PyArray_DIMS( tmp4 )[0];
10745  }
10746  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10747  resultobj = SWIG_Py_Void();
10748  {
10749  Py_CLEAR( tmp1 );
10750  }
10751  {
10752  Py_CLEAR( tmp2 );
10753  }
10754  {
10755  Py_CLEAR( tmp3 );
10756  }
10757  {
10758  Py_CLEAR( tmp4 );
10759  }
10760  return resultobj;
10761 fail:
10762  {
10763  Py_CLEAR( tmp1 );
10764  }
10765  {
10766  Py_CLEAR( tmp2 );
10767  }
10768  {
10769  Py_CLEAR( tmp3 );
10770  }
10771  {
10772  Py_CLEAR( tmp4 );
10773  }
10774  return NULL;
10775 }
10776 
10777 
10778 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779  PyObject *resultobj = 0;
10780  PLBOOL arg1 ;
10781  PLINT arg2 ;
10782  PLFLT *arg3 = (PLFLT *) 0 ;
10783  PLFLT *arg4 = (PLFLT *) 0 ;
10784  PLFLT *arg5 = (PLFLT *) 0 ;
10785  PLFLT *arg6 = (PLFLT *) 0 ;
10786  PLBOOL *arg7 = (PLBOOL *) 0 ;
10787  int val1 ;
10788  int ecode1 = 0 ;
10789  PyArrayObject *tmp2 = NULL ;
10790  PyArrayObject *tmp4 = NULL ;
10791  PyArrayObject *tmp5 = NULL ;
10792  PyArrayObject *tmp6 = NULL ;
10793  PyArrayObject *tmp7 = NULL ;
10794  PyObject * obj0 = 0 ;
10795  PyObject * obj1 = 0 ;
10796  PyObject * obj2 = 0 ;
10797  PyObject * obj3 = 0 ;
10798  PyObject * obj4 = 0 ;
10799  PyObject * obj5 = 0 ;
10800 
10801  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10802  ecode1 = SWIG_AsVal_int(obj0, &val1);
10803  if (!SWIG_IsOK(ecode1)) {
10804  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10805  }
10806  arg1 = (PLBOOL)(val1);
10807  {
10808  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10809  if ( tmp2 == NULL )
10810  return NULL;
10811  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10812  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10813  }
10814  {
10815  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10816  if ( tmp4 == NULL )
10817  return NULL;
10818  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10819  {
10820  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10821  return NULL;
10822  }
10823  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10824  }
10825  {
10826  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10827  if ( tmp5 == NULL )
10828  return NULL;
10829  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10830  {
10831  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10832  return NULL;
10833  }
10834  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10835  }
10836  {
10837  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10838  if ( tmp6 == NULL )
10839  return NULL;
10840  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10841  {
10842  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10843  return NULL;
10844  }
10845  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10846  }
10847  {
10848  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10849  if ( tmp7 == NULL )
10850  return NULL;
10851  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10852  {
10853  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10854  return NULL;
10855  }
10856  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10857  }
10858  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10859  resultobj = SWIG_Py_Void();
10860  {
10861  Py_CLEAR( tmp2 );
10862  }
10863  {
10864  Py_CLEAR( tmp4 );
10865  }
10866  {
10867  Py_CLEAR( tmp5 );
10868  }
10869  {
10870  Py_CLEAR( tmp6 );
10871  }
10872  {
10873  Py_CLEAR( tmp7 );
10874  }
10875  return resultobj;
10876 fail:
10877  {
10878  Py_CLEAR( tmp2 );
10879  }
10880  {
10881  Py_CLEAR( tmp4 );
10882  }
10883  {
10884  Py_CLEAR( tmp5 );
10885  }
10886  {
10887  Py_CLEAR( tmp6 );
10888  }
10889  {
10890  Py_CLEAR( tmp7 );
10891  }
10892  return NULL;
10893 }
10894 
10895 
10896 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10897  PyObject *resultobj = 0;
10898  PLBOOL arg1 ;
10899  PLINT arg2 ;
10900  PLFLT *arg3 = (PLFLT *) 0 ;
10901  PLFLT *arg4 = (PLFLT *) 0 ;
10902  PLFLT *arg5 = (PLFLT *) 0 ;
10903  PLFLT *arg6 = (PLFLT *) 0 ;
10904  PLFLT *arg7 = (PLFLT *) 0 ;
10905  PLBOOL *arg8 = (PLBOOL *) 0 ;
10906  int val1 ;
10907  int ecode1 = 0 ;
10908  PyArrayObject *tmp2 = NULL ;
10909  PyArrayObject *tmp4 = NULL ;
10910  PyArrayObject *tmp5 = NULL ;
10911  PyArrayObject *tmp6 = NULL ;
10912  PyArrayObject *tmp7 = NULL ;
10913  PyArrayObject *tmp8 = NULL ;
10914  PyObject * obj0 = 0 ;
10915  PyObject * obj1 = 0 ;
10916  PyObject * obj2 = 0 ;
10917  PyObject * obj3 = 0 ;
10918  PyObject * obj4 = 0 ;
10919  PyObject * obj5 = 0 ;
10920  PyObject * obj6 = 0 ;
10921 
10922  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10923  ecode1 = SWIG_AsVal_int(obj0, &val1);
10924  if (!SWIG_IsOK(ecode1)) {
10925  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10926  }
10927  arg1 = (PLBOOL)(val1);
10928  {
10929  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10930  if ( tmp2 == NULL )
10931  return NULL;
10932  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10933  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10934  }
10935  {
10936  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10937  if ( tmp4 == NULL )
10938  return NULL;
10939  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10940  {
10941  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10942  return NULL;
10943  }
10944  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10945  }
10946  {
10947  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10948  if ( tmp5 == NULL )
10949  return NULL;
10950  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10951  {
10952  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10953  return NULL;
10954  }
10955  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10956  }
10957  {
10958  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10959  if ( tmp6 == NULL )
10960  return NULL;
10961  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10962  {
10963  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10964  return NULL;
10965  }
10966  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10967  }
10968  {
10969  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10970  if ( tmp7 == NULL )
10971  return NULL;
10972  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10973  {
10974  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10975  return NULL;
10976  }
10977  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10978  }
10979  {
10980  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10981  if ( tmp8 == NULL )
10982  return NULL;
10983  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10984  {
10985  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10986  return NULL;
10987  }
10988  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10989  }
10990  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10991  resultobj = SWIG_Py_Void();
10992  {
10993  Py_CLEAR( tmp2 );
10994  }
10995  {
10996  Py_CLEAR( tmp4 );
10997  }
10998  {
10999  Py_CLEAR( tmp5 );
11000  }
11001  {
11002  Py_CLEAR( tmp6 );
11003  }
11004  {
11005  Py_CLEAR( tmp7 );
11006  }
11007  {
11008  Py_CLEAR( tmp8 );
11009  }
11010  return resultobj;
11011 fail:
11012  {
11013  Py_CLEAR( tmp2 );
11014  }
11015  {
11016  Py_CLEAR( tmp4 );
11017  }
11018  {
11019  Py_CLEAR( tmp5 );
11020  }
11021  {
11022  Py_CLEAR( tmp6 );
11023  }
11024  {
11025  Py_CLEAR( tmp7 );
11026  }
11027  {
11028  Py_CLEAR( tmp8 );
11029  }
11030  return NULL;
11031 }
11032 
11033 
11034 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11035  PyObject *resultobj = 0;
11036  PLINT arg1 ;
11037  int val1 ;
11038  int ecode1 = 0 ;
11039  PyObject * obj0 = 0 ;
11040 
11041  if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11042  ecode1 = SWIG_AsVal_int(obj0, &val1);
11043  if (!SWIG_IsOK(ecode1)) {
11044  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11045  }
11046  arg1 = (PLINT)(val1);
11047  plscmap1n(arg1);
11048  resultobj = SWIG_Py_Void();
11049  return resultobj;
11050 fail:
11051  return NULL;
11052 }
11053 
11054 
11055 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056  PyObject *resultobj = 0;
11057  PLFLT arg1 ;
11058  PLFLT arg2 ;
11059  double val1 ;
11060  int ecode1 = 0 ;
11061  double val2 ;
11062  int ecode2 = 0 ;
11063  PyObject * obj0 = 0 ;
11064  PyObject * obj1 = 0 ;
11065 
11066  if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11067  ecode1 = SWIG_AsVal_double(obj0, &val1);
11068  if (!SWIG_IsOK(ecode1)) {
11069  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11070  }
11071  arg1 = (PLFLT)(val1);
11072  ecode2 = SWIG_AsVal_double(obj1, &val2);
11073  if (!SWIG_IsOK(ecode2)) {
11074  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11075  }
11076  arg2 = (PLFLT)(val2);
11077  plscmap1_range(arg1,arg2);
11078  resultobj = SWIG_Py_Void();
11079  return resultobj;
11080 fail:
11081  return NULL;
11082 }
11083 
11084 
11085 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11086  PyObject *resultobj = 0;
11087  PLFLT *arg1 = (PLFLT *) 0 ;
11088  PLFLT *arg2 = (PLFLT *) 0 ;
11089  PLFLT temp1 ;
11090  int res1 = SWIG_TMPOBJ ;
11091  PLFLT temp2 ;
11092  int res2 = SWIG_TMPOBJ ;
11093 
11094  arg1 = &temp1;
11095  arg2 = &temp2;
11096  if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11097  plgcmap1_range(arg1,arg2);
11098  resultobj = SWIG_Py_Void();
11099  if (SWIG_IsTmpObj(res1)) {
11100  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11101  } else {
11102  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11103  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11104  }
11105  if (SWIG_IsTmpObj(res2)) {
11106  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11107  } else {
11108  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11109  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11110  }
11111  return resultobj;
11112 fail:
11113  return NULL;
11114 }
11115 
11116 
11117 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118  PyObject *resultobj = 0;
11119  PLINT arg1 ;
11120  PLINT arg2 ;
11121  PLINT arg3 ;
11122  PLINT arg4 ;
11123  int val1 ;
11124  int ecode1 = 0 ;
11125  int val2 ;
11126  int ecode2 = 0 ;
11127  int val3 ;
11128  int ecode3 = 0 ;
11129  int val4 ;
11130  int ecode4 = 0 ;
11131  PyObject * obj0 = 0 ;
11132  PyObject * obj1 = 0 ;
11133  PyObject * obj2 = 0 ;
11134  PyObject * obj3 = 0 ;
11135 
11136  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11137  ecode1 = SWIG_AsVal_int(obj0, &val1);
11138  if (!SWIG_IsOK(ecode1)) {
11139  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11140  }
11141  arg1 = (PLINT)(val1);
11142  ecode2 = SWIG_AsVal_int(obj1, &val2);
11143  if (!SWIG_IsOK(ecode2)) {
11144  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11145  }
11146  arg2 = (PLINT)(val2);
11147  ecode3 = SWIG_AsVal_int(obj2, &val3);
11148  if (!SWIG_IsOK(ecode3)) {
11149  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11150  }
11151  arg3 = (PLINT)(val3);
11152  ecode4 = SWIG_AsVal_int(obj3, &val4);
11153  if (!SWIG_IsOK(ecode4)) {
11154  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11155  }
11156  arg4 = (PLINT)(val4);
11157  plscol0(arg1,arg2,arg3,arg4);
11158  resultobj = SWIG_Py_Void();
11159  return resultobj;
11160 fail:
11161  return NULL;
11162 }
11163 
11164 
11165 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11166  PyObject *resultobj = 0;
11167  PLINT arg1 ;
11168  PLINT arg2 ;
11169  PLINT arg3 ;
11170  PLINT arg4 ;
11171  PLFLT arg5 ;
11172  int val1 ;
11173  int ecode1 = 0 ;
11174  int val2 ;
11175  int ecode2 = 0 ;
11176  int val3 ;
11177  int ecode3 = 0 ;
11178  int val4 ;
11179  int ecode4 = 0 ;
11180  double val5 ;
11181  int ecode5 = 0 ;
11182  PyObject * obj0 = 0 ;
11183  PyObject * obj1 = 0 ;
11184  PyObject * obj2 = 0 ;
11185  PyObject * obj3 = 0 ;
11186  PyObject * obj4 = 0 ;
11187 
11188  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11189  ecode1 = SWIG_AsVal_int(obj0, &val1);
11190  if (!SWIG_IsOK(ecode1)) {
11191  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11192  }
11193  arg1 = (PLINT)(val1);
11194  ecode2 = SWIG_AsVal_int(obj1, &val2);
11195  if (!SWIG_IsOK(ecode2)) {
11196  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11197  }
11198  arg2 = (PLINT)(val2);
11199  ecode3 = SWIG_AsVal_int(obj2, &val3);
11200  if (!SWIG_IsOK(ecode3)) {
11201  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11202  }
11203  arg3 = (PLINT)(val3);
11204  ecode4 = SWIG_AsVal_int(obj3, &val4);
11205  if (!SWIG_IsOK(ecode4)) {
11206  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11207  }
11208  arg4 = (PLINT)(val4);
11209  ecode5 = SWIG_AsVal_double(obj4, &val5);
11210  if (!SWIG_IsOK(ecode5)) {
11211  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11212  }
11213  arg5 = (PLFLT)(val5);
11214  plscol0a(arg1,arg2,arg3,arg4,arg5);
11215  resultobj = SWIG_Py_Void();
11216  return resultobj;
11217 fail:
11218  return NULL;
11219 }
11220 
11221 
11222 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11223  PyObject *resultobj = 0;
11224  PLINT arg1 ;
11225  PLINT arg2 ;
11226  PLINT arg3 ;
11227  int val1 ;
11228  int ecode1 = 0 ;
11229  int val2 ;
11230  int ecode2 = 0 ;
11231  int val3 ;
11232  int ecode3 = 0 ;
11233  PyObject * obj0 = 0 ;
11234  PyObject * obj1 = 0 ;
11235  PyObject * obj2 = 0 ;
11236 
11237  if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11238  ecode1 = SWIG_AsVal_int(obj0, &val1);
11239  if (!SWIG_IsOK(ecode1)) {
11240  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11241  }
11242  arg1 = (PLINT)(val1);
11243  ecode2 = SWIG_AsVal_int(obj1, &val2);
11244  if (!SWIG_IsOK(ecode2)) {
11245  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11246  }
11247  arg2 = (PLINT)(val2);
11248  ecode3 = SWIG_AsVal_int(obj2, &val3);
11249  if (!SWIG_IsOK(ecode3)) {
11250  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11251  }
11252  arg3 = (PLINT)(val3);
11253  plscolbg(arg1,arg2,arg3);
11254  resultobj = SWIG_Py_Void();
11255  return resultobj;
11256 fail:
11257  return NULL;
11258 }
11259 
11260 
11261 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11262  PyObject *resultobj = 0;
11263  PLINT arg1 ;
11264  PLINT arg2 ;
11265  PLINT arg3 ;
11266  PLFLT arg4 ;
11267  int val1 ;
11268  int ecode1 = 0 ;
11269  int val2 ;
11270  int ecode2 = 0 ;
11271  int val3 ;
11272  int ecode3 = 0 ;
11273  double val4 ;
11274  int ecode4 = 0 ;
11275  PyObject * obj0 = 0 ;
11276  PyObject * obj1 = 0 ;
11277  PyObject * obj2 = 0 ;
11278  PyObject * obj3 = 0 ;
11279 
11280  if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11281  ecode1 = SWIG_AsVal_int(obj0, &val1);
11282  if (!SWIG_IsOK(ecode1)) {
11283  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11284  }
11285  arg1 = (PLINT)(val1);
11286  ecode2 = SWIG_AsVal_int(obj1, &val2);
11287  if (!SWIG_IsOK(ecode2)) {
11288  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11289  }
11290  arg2 = (PLINT)(val2);
11291  ecode3 = SWIG_AsVal_int(obj2, &val3);
11292  if (!SWIG_IsOK(ecode3)) {
11293  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11294  }
11295  arg3 = (PLINT)(val3);
11296  ecode4 = SWIG_AsVal_double(obj3, &val4);
11297  if (!SWIG_IsOK(ecode4)) {
11298  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11299  }
11300  arg4 = (PLFLT)(val4);
11301  plscolbga(arg1,arg2,arg3,arg4);
11302  resultobj = SWIG_Py_Void();
11303  return resultobj;
11304 fail:
11305  return NULL;
11306 }
11307 
11308 
11309 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310  PyObject *resultobj = 0;
11311  PLINT arg1 ;
11312  int val1 ;
11313  int ecode1 = 0 ;
11314  PyObject * obj0 = 0 ;
11315 
11316  if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11317  ecode1 = SWIG_AsVal_int(obj0, &val1);
11318  if (!SWIG_IsOK(ecode1)) {
11319  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11320  }
11321  arg1 = (PLINT)(val1);
11322  plscolor(arg1);
11323  resultobj = SWIG_Py_Void();
11324  return resultobj;
11325 fail:
11326  return NULL;
11327 }
11328 
11329 
11330 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11331  PyObject *resultobj = 0;
11332  PLINT arg1 ;
11333  int val1 ;
11334  int ecode1 = 0 ;
11335  PyObject * obj0 = 0 ;
11336 
11337  if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11338  ecode1 = SWIG_AsVal_int(obj0, &val1);
11339  if (!SWIG_IsOK(ecode1)) {
11340  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11341  }
11342  arg1 = (PLINT)(val1);
11343  plscompression(arg1);
11344  resultobj = SWIG_Py_Void();
11345  return resultobj;
11346 fail:
11347  return NULL;
11348 }
11349 
11350 
11351 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11352  PyObject *resultobj = 0;
11353  char *arg1 = (char *) 0 ;
11354  int res1 ;
11355  char *buf1 = 0 ;
11356  int alloc1 = 0 ;
11357  PyObject * obj0 = 0 ;
11358 
11359  if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11360  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11361  if (!SWIG_IsOK(res1)) {
11362  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11363  }
11364  arg1 = (char *)(buf1);
11365  plsdev((char const *)arg1);
11366  resultobj = SWIG_Py_Void();
11367  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11368  return resultobj;
11369 fail:
11370  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11371  return NULL;
11372 }
11373 
11374 
11375 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11376  PyObject *resultobj = 0;
11377  PLFLT arg1 ;
11378  PLFLT arg2 ;
11379  PLFLT arg3 ;
11380  PLFLT arg4 ;
11381  double val1 ;
11382  int ecode1 = 0 ;
11383  double val2 ;
11384  int ecode2 = 0 ;
11385  double val3 ;
11386  int ecode3 = 0 ;
11387  double val4 ;
11388  int ecode4 = 0 ;
11389  PyObject * obj0 = 0 ;
11390  PyObject * obj1 = 0 ;
11391  PyObject * obj2 = 0 ;
11392  PyObject * obj3 = 0 ;
11393 
11394  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11395  ecode1 = SWIG_AsVal_double(obj0, &val1);
11396  if (!SWIG_IsOK(ecode1)) {
11397  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11398  }
11399  arg1 = (PLFLT)(val1);
11400  ecode2 = SWIG_AsVal_double(obj1, &val2);
11401  if (!SWIG_IsOK(ecode2)) {
11402  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11403  }
11404  arg2 = (PLFLT)(val2);
11405  ecode3 = SWIG_AsVal_double(obj2, &val3);
11406  if (!SWIG_IsOK(ecode3)) {
11407  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11408  }
11409  arg3 = (PLFLT)(val3);
11410  ecode4 = SWIG_AsVal_double(obj3, &val4);
11411  if (!SWIG_IsOK(ecode4)) {
11412  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11413  }
11414  arg4 = (PLFLT)(val4);
11415  plsdidev(arg1,arg2,arg3,arg4);
11416  resultobj = SWIG_Py_Void();
11417  return resultobj;
11418 fail:
11419  return NULL;
11420 }
11421 
11422 
11423 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11424  PyObject *resultobj = 0;
11425  PLINT arg1 ;
11426  PLINT arg2 ;
11427  PLINT arg3 ;
11428  PLINT arg4 ;
11429  PLFLT arg5 ;
11430  PLFLT arg6 ;
11431  int val1 ;
11432  int ecode1 = 0 ;
11433  int val2 ;
11434  int ecode2 = 0 ;
11435  int val3 ;
11436  int ecode3 = 0 ;
11437  int val4 ;
11438  int ecode4 = 0 ;
11439  double val5 ;
11440  int ecode5 = 0 ;
11441  double val6 ;
11442  int ecode6 = 0 ;
11443  PyObject * obj0 = 0 ;
11444  PyObject * obj1 = 0 ;
11445  PyObject * obj2 = 0 ;
11446  PyObject * obj3 = 0 ;
11447  PyObject * obj4 = 0 ;
11448  PyObject * obj5 = 0 ;
11449 
11450  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11451  ecode1 = SWIG_AsVal_int(obj0, &val1);
11452  if (!SWIG_IsOK(ecode1)) {
11453  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11454  }
11455  arg1 = (PLINT)(val1);
11456  ecode2 = SWIG_AsVal_int(obj1, &val2);
11457  if (!SWIG_IsOK(ecode2)) {
11458  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11459  }
11460  arg2 = (PLINT)(val2);
11461  ecode3 = SWIG_AsVal_int(obj2, &val3);
11462  if (!SWIG_IsOK(ecode3)) {
11463  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11464  }
11465  arg3 = (PLINT)(val3);
11466  ecode4 = SWIG_AsVal_int(obj3, &val4);
11467  if (!SWIG_IsOK(ecode4)) {
11468  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11469  }
11470  arg4 = (PLINT)(val4);
11471  ecode5 = SWIG_AsVal_double(obj4, &val5);
11472  if (!SWIG_IsOK(ecode5)) {
11473  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11474  }
11475  arg5 = (PLFLT)(val5);
11476  ecode6 = SWIG_AsVal_double(obj5, &val6);
11477  if (!SWIG_IsOK(ecode6)) {
11478  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11479  }
11480  arg6 = (PLFLT)(val6);
11481  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11482  resultobj = SWIG_Py_Void();
11483  return resultobj;
11484 fail:
11485  return NULL;
11486 }
11487 
11488 
11489 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11490  PyObject *resultobj = 0;
11491  PLFLT arg1 ;
11492  double val1 ;
11493  int ecode1 = 0 ;
11494  PyObject * obj0 = 0 ;
11495 
11496  if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11497  ecode1 = SWIG_AsVal_double(obj0, &val1);
11498  if (!SWIG_IsOK(ecode1)) {
11499  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11500  }
11501  arg1 = (PLFLT)(val1);
11502  plsdiori(arg1);
11503  resultobj = SWIG_Py_Void();
11504  return resultobj;
11505 fail:
11506  return NULL;
11507 }
11508 
11509 
11510 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11511  PyObject *resultobj = 0;
11512  PLFLT arg1 ;
11513  PLFLT arg2 ;
11514  PLFLT arg3 ;
11515  PLFLT arg4 ;
11516  double val1 ;
11517  int ecode1 = 0 ;
11518  double val2 ;
11519  int ecode2 = 0 ;
11520  double val3 ;
11521  int ecode3 = 0 ;
11522  double val4 ;
11523  int ecode4 = 0 ;
11524  PyObject * obj0 = 0 ;
11525  PyObject * obj1 = 0 ;
11526  PyObject * obj2 = 0 ;
11527  PyObject * obj3 = 0 ;
11528 
11529  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11530  ecode1 = SWIG_AsVal_double(obj0, &val1);
11531  if (!SWIG_IsOK(ecode1)) {
11532  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11533  }
11534  arg1 = (PLFLT)(val1);
11535  ecode2 = SWIG_AsVal_double(obj1, &val2);
11536  if (!SWIG_IsOK(ecode2)) {
11537  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11538  }
11539  arg2 = (PLFLT)(val2);
11540  ecode3 = SWIG_AsVal_double(obj2, &val3);
11541  if (!SWIG_IsOK(ecode3)) {
11542  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11543  }
11544  arg3 = (PLFLT)(val3);
11545  ecode4 = SWIG_AsVal_double(obj3, &val4);
11546  if (!SWIG_IsOK(ecode4)) {
11547  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11548  }
11549  arg4 = (PLFLT)(val4);
11550  plsdiplt(arg1,arg2,arg3,arg4);
11551  resultobj = SWIG_Py_Void();
11552  return resultobj;
11553 fail:
11554  return NULL;
11555 }
11556 
11557 
11558 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11559  PyObject *resultobj = 0;
11560  PLFLT arg1 ;
11561  PLFLT arg2 ;
11562  PLFLT arg3 ;
11563  PLFLT arg4 ;
11564  double val1 ;
11565  int ecode1 = 0 ;
11566  double val2 ;
11567  int ecode2 = 0 ;
11568  double val3 ;
11569  int ecode3 = 0 ;
11570  double val4 ;
11571  int ecode4 = 0 ;
11572  PyObject * obj0 = 0 ;
11573  PyObject * obj1 = 0 ;
11574  PyObject * obj2 = 0 ;
11575  PyObject * obj3 = 0 ;
11576 
11577  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11578  ecode1 = SWIG_AsVal_double(obj0, &val1);
11579  if (!SWIG_IsOK(ecode1)) {
11580  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11581  }
11582  arg1 = (PLFLT)(val1);
11583  ecode2 = SWIG_AsVal_double(obj1, &val2);
11584  if (!SWIG_IsOK(ecode2)) {
11585  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11586  }
11587  arg2 = (PLFLT)(val2);
11588  ecode3 = SWIG_AsVal_double(obj2, &val3);
11589  if (!SWIG_IsOK(ecode3)) {
11590  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11591  }
11592  arg3 = (PLFLT)(val3);
11593  ecode4 = SWIG_AsVal_double(obj3, &val4);
11594  if (!SWIG_IsOK(ecode4)) {
11595  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11596  }
11597  arg4 = (PLFLT)(val4);
11598  plsdiplz(arg1,arg2,arg3,arg4);
11599  resultobj = SWIG_Py_Void();
11600  return resultobj;
11601 fail:
11602  return NULL;
11603 }
11604 
11605 
11606 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607  PyObject *resultobj = 0;
11608  unsigned int arg1 ;
11609  unsigned int val1 ;
11610  int ecode1 = 0 ;
11611  PyObject * obj0 = 0 ;
11612 
11613  if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11614  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11615  if (!SWIG_IsOK(ecode1)) {
11616  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11617  }
11618  arg1 = (unsigned int)(val1);
11619  plseed(arg1);
11620  resultobj = SWIG_Py_Void();
11621  return resultobj;
11622 fail:
11623  return NULL;
11624 }
11625 
11626 
11627 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11628  PyObject *resultobj = 0;
11629  char arg1 ;
11630  char val1 ;
11631  int ecode1 = 0 ;
11632  PyObject * obj0 = 0 ;
11633 
11634  if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11635  ecode1 = SWIG_AsVal_char(obj0, &val1);
11636  if (!SWIG_IsOK(ecode1)) {
11637  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11638  }
11639  arg1 = (char)(val1);
11640  plsesc(arg1);
11641  resultobj = SWIG_Py_Void();
11642  return resultobj;
11643 fail:
11644  return NULL;
11645 }
11646 
11647 
11648 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649  PyObject *resultobj = 0;
11650  char *arg1 = (char *) 0 ;
11651  char *arg2 = (char *) 0 ;
11652  int res1 ;
11653  char *buf1 = 0 ;
11654  int alloc1 = 0 ;
11655  int res2 ;
11656  char *buf2 = 0 ;
11657  int alloc2 = 0 ;
11658  PyObject * obj0 = 0 ;
11659  PyObject * obj1 = 0 ;
11660  PLINT result;
11661 
11662  if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11663  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11664  if (!SWIG_IsOK(res1)) {
11665  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11666  }
11667  arg1 = (char *)(buf1);
11668  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11669  if (!SWIG_IsOK(res2)) {
11670  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11671  }
11672  arg2 = (char *)(buf2);
11673  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11674  resultobj = SWIG_From_int((int)(result));
11675  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11676  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11677  return resultobj;
11678 fail:
11679  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11680  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11681  return NULL;
11682 }
11683 
11684 
11685 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686  PyObject *resultobj = 0;
11687  PLINT arg1 ;
11688  PLINT arg2 ;
11689  PLINT arg3 ;
11690  int val1 ;
11691  int ecode1 = 0 ;
11692  int val2 ;
11693  int ecode2 = 0 ;
11694  int val3 ;
11695  int ecode3 = 0 ;
11696  PyObject * obj0 = 0 ;
11697  PyObject * obj1 = 0 ;
11698  PyObject * obj2 = 0 ;
11699 
11700  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11701  ecode1 = SWIG_AsVal_int(obj0, &val1);
11702  if (!SWIG_IsOK(ecode1)) {
11703  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11704  }
11705  arg1 = (PLINT)(val1);
11706  ecode2 = SWIG_AsVal_int(obj1, &val2);
11707  if (!SWIG_IsOK(ecode2)) {
11708  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11709  }
11710  arg2 = (PLINT)(val2);
11711  ecode3 = SWIG_AsVal_int(obj2, &val3);
11712  if (!SWIG_IsOK(ecode3)) {
11713  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11714  }
11715  arg3 = (PLINT)(val3);
11716  plsfam(arg1,arg2,arg3);
11717  resultobj = SWIG_Py_Void();
11718  return resultobj;
11719 fail:
11720  return NULL;
11721 }
11722 
11723 
11724 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725  PyObject *resultobj = 0;
11726  PLUNICODE arg1 ;
11727  unsigned int val1 ;
11728  int ecode1 = 0 ;
11729  PyObject * obj0 = 0 ;
11730 
11731  if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11732  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11733  if (!SWIG_IsOK(ecode1)) {
11734  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11735  }
11736  arg1 = (PLUNICODE)(val1);
11737  plsfci(arg1);
11738  resultobj = SWIG_Py_Void();
11739  return resultobj;
11740 fail:
11741  return NULL;
11742 }
11743 
11744 
11745 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11746  PyObject *resultobj = 0;
11747  char *arg1 = (char *) 0 ;
11748  int res1 ;
11749  char *buf1 = 0 ;
11750  int alloc1 = 0 ;
11751  PyObject * obj0 = 0 ;
11752 
11753  if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11754  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11755  if (!SWIG_IsOK(res1)) {
11756  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11757  }
11758  arg1 = (char *)(buf1);
11759  plsfnam((char const *)arg1);
11760  resultobj = SWIG_Py_Void();
11761  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11762  return resultobj;
11763 fail:
11764  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11765  return NULL;
11766 }
11767 
11768 
11769 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770  PyObject *resultobj = 0;
11771  PLINT arg1 ;
11772  PLINT arg2 ;
11773  PLINT arg3 ;
11774  int val1 ;
11775  int ecode1 = 0 ;
11776  int val2 ;
11777  int ecode2 = 0 ;
11778  int val3 ;
11779  int ecode3 = 0 ;
11780  PyObject * obj0 = 0 ;
11781  PyObject * obj1 = 0 ;
11782  PyObject * obj2 = 0 ;
11783 
11784  if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11785  ecode1 = SWIG_AsVal_int(obj0, &val1);
11786  if (!SWIG_IsOK(ecode1)) {
11787  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11788  }
11789  arg1 = (PLINT)(val1);
11790  ecode2 = SWIG_AsVal_int(obj1, &val2);
11791  if (!SWIG_IsOK(ecode2)) {
11792  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11793  }
11794  arg2 = (PLINT)(val2);
11795  ecode3 = SWIG_AsVal_int(obj2, &val3);
11796  if (!SWIG_IsOK(ecode3)) {
11797  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11798  }
11799  arg3 = (PLINT)(val3);
11800  plsfont(arg1,arg2,arg3);
11801  resultobj = SWIG_Py_Void();
11802  return resultobj;
11803 fail:
11804  return NULL;
11805 }
11806 
11807 
11808 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809  PyObject *resultobj = 0;
11810  PLFLT **arg1 = (PLFLT **) 0 ;
11811  PLINT arg2 ;
11812  PLINT arg3 ;
11813  defined_func arg4 = (defined_func) 0 ;
11814  PLFLT arg5 ;
11815  PLFLT arg6 ;
11816  PLFLT arg7 ;
11817  PLFLT arg8 ;
11818  PLFLT *arg9 = (PLFLT *) 0 ;
11819  PLINT arg10 ;
11820  PLFLT arg11 ;
11821  PLINT arg12 ;
11822  PLFLT arg13 ;
11823  fill_func arg14 = (fill_func) 0 ;
11824  PLBOOL arg15 ;
11825  pltr_func arg16 = (pltr_func) 0 ;
11826  PLPointer arg17 = (PLPointer) 0 ;
11827  PyArrayObject *tmp1 = NULL ;
11828  double val5 ;
11829  int ecode5 = 0 ;
11830  double val6 ;
11831  int ecode6 = 0 ;
11832  double val7 ;
11833  int ecode7 = 0 ;
11834  double val8 ;
11835  int ecode8 = 0 ;
11836  PyArrayObject *tmp9 = NULL ;
11837  double val11 ;
11838  int ecode11 = 0 ;
11839  int val12 ;
11840  int ecode12 = 0 ;
11841  double val13 ;
11842  int ecode13 = 0 ;
11843  int val15 ;
11844  int ecode15 = 0 ;
11845  PyObject * obj0 = 0 ;
11846  PyObject * obj1 = 0 ;
11847  PyObject * obj2 = 0 ;
11848  PyObject * obj3 = 0 ;
11849  PyObject * obj4 = 0 ;
11850  PyObject * obj5 = 0 ;
11851  PyObject * obj6 = 0 ;
11852  PyObject * obj7 = 0 ;
11853  PyObject * obj8 = 0 ;
11854  PyObject * obj9 = 0 ;
11855  PyObject * obj10 = 0 ;
11856  PyObject * obj11 = 0 ;
11857 
11858  {
11859  python_pltr = 0;
11860  arg16 = NULL;
11861  }
11862  {
11863  arg17 = NULL;
11864  }
11865  {
11866  arg4 = NULL;
11867  }
11868  {
11869  arg14 = plfill;
11870  }
11871  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11872  {
11873  int i, size;
11874  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11875  if ( tmp1 == NULL )
11876  return NULL;
11877  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11878  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11879  size = arg3;
11880  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11881  for ( i = 0; i < arg2; i++ )
11882  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11883  }
11884  ecode5 = SWIG_AsVal_double(obj1, &val5);
11885  if (!SWIG_IsOK(ecode5)) {
11886  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11887  }
11888  arg5 = (PLFLT)(val5);
11889  ecode6 = SWIG_AsVal_double(obj2, &val6);
11890  if (!SWIG_IsOK(ecode6)) {
11891  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11892  }
11893  arg6 = (PLFLT)(val6);
11894  ecode7 = SWIG_AsVal_double(obj3, &val7);
11895  if (!SWIG_IsOK(ecode7)) {
11896  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11897  }
11898  arg7 = (PLFLT)(val7);
11899  ecode8 = SWIG_AsVal_double(obj4, &val8);
11900  if (!SWIG_IsOK(ecode8)) {
11901  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11902  }
11903  arg8 = (PLFLT)(val8);
11904  {
11905  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11906  if ( tmp9 == NULL )
11907  return NULL;
11908  arg10 = PyArray_DIMS( tmp9 )[0];
11909  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11910  }
11911  ecode11 = SWIG_AsVal_double(obj6, &val11);
11912  if (!SWIG_IsOK(ecode11)) {
11913  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11914  }
11915  arg11 = (PLFLT)(val11);
11916  ecode12 = SWIG_AsVal_int(obj7, &val12);
11917  if (!SWIG_IsOK(ecode12)) {
11918  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11919  }
11920  arg12 = (PLINT)(val12);
11921  ecode13 = SWIG_AsVal_double(obj8, &val13);
11922  if (!SWIG_IsOK(ecode13)) {
11923  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11924  }
11925  arg13 = (PLFLT)(val13);
11926  ecode15 = SWIG_AsVal_int(obj9, &val15);
11927  if (!SWIG_IsOK(ecode15)) {
11928  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11929  }
11930  arg15 = (PLBOOL)(val15);
11931  if (obj10) {
11932  {
11933  // it must be a callable or None
11934  if ( obj10 == Py_None )
11935  {
11936  arg16 = NULL;
11937  }
11938  else
11939  {
11940  if ( !PyCallable_Check( (PyObject *) obj10 ) )
11941  {
11942  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11943  return NULL;
11944  }
11945  arg16 = marshal_pltr( obj10 );
11946  }
11947  }
11948  }
11949  if (obj11) {
11950  {
11951  if ( obj11 == Py_None )
11952  arg17 = NULL;
11953  else
11954  {
11955  arg17 = marshal_PLPointer( obj11, 0 );
11956  }
11957  }
11958  }
11959  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11960  resultobj = SWIG_Py_Void();
11961  {
11962  Py_CLEAR( tmp1 );
11963  free( arg1 );
11964  }
11965  {
11966  Py_CLEAR( tmp9 );
11967  }
11968  {
11969  cleanup_pltr();
11970  }
11971  {
11973  }
11974  return resultobj;
11975 fail:
11976  {
11977  Py_CLEAR( tmp1 );
11978  free( arg1 );
11979  }
11980  {
11981  Py_CLEAR( tmp9 );
11982  }
11983  {
11984  cleanup_pltr();
11985  }
11986  {
11988  }
11989  return NULL;
11990 }
11991 
11992 
11993 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11994  PyObject *resultobj = 0;
11995  PLFLT **arg1 = (PLFLT **) 0 ;
11996  PLINT arg2 ;
11997  PLINT arg3 ;
11998  defined_func arg4 = (defined_func) 0 ;
11999  PLFLT arg5 ;
12000  PLFLT arg6 ;
12001  PLFLT arg7 ;
12002  PLFLT arg8 ;
12003  PLFLT arg9 ;
12004  PLFLT arg10 ;
12005  PLINT arg11 ;
12006  PLFLT arg12 ;
12007  PLFLT arg13 ;
12008  PLINT arg14 ;
12009  PLFLT arg15 ;
12010  PLINT arg16 ;
12011  PLFLT arg17 ;
12012  fill_func arg18 = (fill_func) 0 ;
12013  PLBOOL arg19 ;
12014  pltr_func arg20 = (pltr_func) 0 ;
12015  PLPointer arg21 = (PLPointer) 0 ;
12016  PyArrayObject *tmp1 = NULL ;
12017  double val5 ;
12018  int ecode5 = 0 ;
12019  double val6 ;
12020  int ecode6 = 0 ;
12021  double val7 ;
12022  int ecode7 = 0 ;
12023  double val8 ;
12024  int ecode8 = 0 ;
12025  double val9 ;
12026  int ecode9 = 0 ;
12027  double val10 ;
12028  int ecode10 = 0 ;
12029  int val11 ;
12030  int ecode11 = 0 ;
12031  double val12 ;
12032  int ecode12 = 0 ;
12033  double val13 ;
12034  int ecode13 = 0 ;
12035  int val14 ;
12036  int ecode14 = 0 ;
12037  double val15 ;
12038  int ecode15 = 0 ;
12039  int val16 ;
12040  int ecode16 = 0 ;
12041  double val17 ;
12042  int ecode17 = 0 ;
12043  int val19 ;
12044  int ecode19 = 0 ;
12045  PyObject * obj0 = 0 ;
12046  PyObject * obj1 = 0 ;
12047  PyObject * obj2 = 0 ;
12048  PyObject * obj3 = 0 ;
12049  PyObject * obj4 = 0 ;
12050  PyObject * obj5 = 0 ;
12051  PyObject * obj6 = 0 ;
12052  PyObject * obj7 = 0 ;
12053  PyObject * obj8 = 0 ;
12054  PyObject * obj9 = 0 ;
12055  PyObject * obj10 = 0 ;
12056  PyObject * obj11 = 0 ;
12057  PyObject * obj12 = 0 ;
12058  PyObject * obj13 = 0 ;
12059  PyObject * obj14 = 0 ;
12060  PyObject * obj15 = 0 ;
12061  PyObject * obj16 = 0 ;
12062 
12063  {
12064  python_pltr = 0;
12065  arg20 = NULL;
12066  }
12067  {
12068  arg21 = NULL;
12069  }
12070  {
12071  arg4 = NULL;
12072  }
12073  {
12074  arg18 = plfill;
12075  }
12076  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
12077  {
12078  int i, size;
12079  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12080  if ( tmp1 == NULL )
12081  return NULL;
12082  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12083  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12084  size = arg3;
12085  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12086  for ( i = 0; i < arg2; i++ )
12087  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12088  }
12089  ecode5 = SWIG_AsVal_double(obj1, &val5);
12090  if (!SWIG_IsOK(ecode5)) {
12091  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12092  }
12093  arg5 = (PLFLT)(val5);
12094  ecode6 = SWIG_AsVal_double(obj2, &val6);
12095  if (!SWIG_IsOK(ecode6)) {
12096  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12097  }
12098  arg6 = (PLFLT)(val6);
12099  ecode7 = SWIG_AsVal_double(obj3, &val7);
12100  if (!SWIG_IsOK(ecode7)) {
12101  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12102  }
12103  arg7 = (PLFLT)(val7);
12104  ecode8 = SWIG_AsVal_double(obj4, &val8);
12105  if (!SWIG_IsOK(ecode8)) {
12106  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12107  }
12108  arg8 = (PLFLT)(val8);
12109  ecode9 = SWIG_AsVal_double(obj5, &val9);
12110  if (!SWIG_IsOK(ecode9)) {
12111  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12112  }
12113  arg9 = (PLFLT)(val9);
12114  ecode10 = SWIG_AsVal_double(obj6, &val10);
12115  if (!SWIG_IsOK(ecode10)) {
12116  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12117  }
12118  arg10 = (PLFLT)(val10);
12119  ecode11 = SWIG_AsVal_int(obj7, &val11);
12120  if (!SWIG_IsOK(ecode11)) {
12121  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12122  }
12123  arg11 = (PLINT)(val11);
12124  ecode12 = SWIG_AsVal_double(obj8, &val12);
12125  if (!SWIG_IsOK(ecode12)) {
12126  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12127  }
12128  arg12 = (PLFLT)(val12);
12129  ecode13 = SWIG_AsVal_double(obj9, &val13);
12130  if (!SWIG_IsOK(ecode13)) {
12131  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12132  }
12133  arg13 = (PLFLT)(val13);
12134  ecode14 = SWIG_AsVal_int(obj10, &val14);
12135  if (!SWIG_IsOK(ecode14)) {
12136  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12137  }
12138  arg14 = (PLINT)(val14);
12139  ecode15 = SWIG_AsVal_double(obj11, &val15);
12140  if (!SWIG_IsOK(ecode15)) {
12141  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12142  }
12143  arg15 = (PLFLT)(val15);
12144  ecode16 = SWIG_AsVal_int(obj12, &val16);
12145  if (!SWIG_IsOK(ecode16)) {
12146  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12147  }
12148  arg16 = (PLINT)(val16);
12149  ecode17 = SWIG_AsVal_double(obj13, &val17);
12150  if (!SWIG_IsOK(ecode17)) {
12151  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12152  }
12153  arg17 = (PLFLT)(val17);
12154  ecode19 = SWIG_AsVal_int(obj14, &val19);
12155  if (!SWIG_IsOK(ecode19)) {
12156  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12157  }
12158  arg19 = (PLBOOL)(val19);
12159  if (obj15) {
12160  {
12161  // it must be a callable or None
12162  if ( obj15 == Py_None )
12163  {
12164  arg20 = NULL;
12165  }
12166  else
12167  {
12168  if ( !PyCallable_Check( (PyObject *) obj15 ) )
12169  {
12170  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12171  return NULL;
12172  }
12173  arg20 = marshal_pltr( obj15 );
12174  }
12175  }
12176  }
12177  if (obj16) {
12178  {
12179  if ( obj16 == Py_None )
12180  arg21 = NULL;
12181  else
12182  {
12183  arg21 = marshal_PLPointer( obj16, 0 );
12184  }
12185  }
12186  }
12187  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12188  resultobj = SWIG_Py_Void();
12189  {
12190  Py_CLEAR( tmp1 );
12191  free( arg1 );
12192  }
12193  {
12194  cleanup_pltr();
12195  }
12196  {
12198  }
12199  return resultobj;
12200 fail:
12201  {
12202  Py_CLEAR( tmp1 );
12203  free( arg1 );
12204  }
12205  {
12206  cleanup_pltr();
12207  }
12208  {
12210  }
12211  return NULL;
12212 }
12213 
12214 
12215 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12216  PyObject *resultobj = 0;
12217  label_func arg1 = (label_func) 0 ;
12218  PLPointer arg2 = (PLPointer) 0 ;
12219  int res2 ;
12220  PyObject * obj0 = 0 ;
12221  PyObject * obj1 = 0 ;
12222 
12223  if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12224  {
12225  // Release reference to previous function if applicable
12226  if ( python_label )
12227  {
12228  Py_CLEAR( python_label );
12229  python_label = 0;
12230  }
12231  // it must be a callable or None
12232  if ( obj0 == Py_None )
12233  {
12234  arg1 = NULL;
12235  }
12236  else
12237  {
12238  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12239  {
12240  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12241  return NULL;
12242  }
12243  // hold a reference to it
12244  Py_XINCREF( (PyObject *) obj0 );
12245  python_label = (PyObject *) obj0;
12246  // this function handles calling the python function
12247  arg1 = do_label_callback;
12248  }
12249  }
12250  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12251  if (!SWIG_IsOK(res2)) {
12252  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12253  }
12254  plslabelfunc(arg1,arg2);
12255  resultobj = SWIG_Py_Void();
12256  return resultobj;
12257 fail:
12258  return NULL;
12259 }
12260 
12261 
12262 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12263  PyObject *resultobj = 0;
12264  PLFLT arg1 ;
12265  PLFLT arg2 ;
12266  double val1 ;
12267  int ecode1 = 0 ;
12268  double val2 ;
12269  int ecode2 = 0 ;
12270  PyObject * obj0 = 0 ;
12271  PyObject * obj1 = 0 ;
12272 
12273  if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12274  ecode1 = SWIG_AsVal_double(obj0, &val1);
12275  if (!SWIG_IsOK(ecode1)) {
12276  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12277  }
12278  arg1 = (PLFLT)(val1);
12279  ecode2 = SWIG_AsVal_double(obj1, &val2);
12280  if (!SWIG_IsOK(ecode2)) {
12281  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12282  }
12283  arg2 = (PLFLT)(val2);
12284  plsmaj(arg1,arg2);
12285  resultobj = SWIG_Py_Void();
12286  return resultobj;
12287 fail:
12288  return NULL;
12289 }
12290 
12291 
12292 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12293  PyObject *resultobj = 0;
12294  PLINT arg1 ;
12295  PLINT arg2 ;
12296  void *arg3 = (void *) 0 ;
12297  int val1 ;
12298  int ecode1 = 0 ;
12299  int val2 ;
12300  int ecode2 = 0 ;
12301  int res3 ;
12302  Py_ssize_t size3 = 0 ;
12303  void *buf3 = 0 ;
12304  PyObject * obj0 = 0 ;
12305  PyObject * obj1 = 0 ;
12306  PyObject * obj2 = 0 ;
12307 
12308  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12309  ecode1 = SWIG_AsVal_int(obj0, &val1);
12310  if (!SWIG_IsOK(ecode1)) {
12311  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12312  }
12313  arg1 = (PLINT)(val1);
12314  ecode2 = SWIG_AsVal_int(obj1, &val2);
12315  if (!SWIG_IsOK(ecode2)) {
12316  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12317  }
12318  arg2 = (PLINT)(val2);
12319  {
12320  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12321  if (res3<0) {
12322  PyErr_Clear();
12323  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12324  }
12325  arg3 = (void *) buf3;
12326  }
12327  plsmem(arg1,arg2,arg3);
12328  resultobj = SWIG_Py_Void();
12329  return resultobj;
12330 fail:
12331  return NULL;
12332 }
12333 
12334 
12335 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336  PyObject *resultobj = 0;
12337  PLINT arg1 ;
12338  PLINT arg2 ;
12339  void *arg3 = (void *) 0 ;
12340  int val1 ;
12341  int ecode1 = 0 ;
12342  int val2 ;
12343  int ecode2 = 0 ;
12344  int res3 ;
12345  Py_ssize_t size3 = 0 ;
12346  void *buf3 = 0 ;
12347  PyObject * obj0 = 0 ;
12348  PyObject * obj1 = 0 ;
12349  PyObject * obj2 = 0 ;
12350 
12351  if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12352  ecode1 = SWIG_AsVal_int(obj0, &val1);
12353  if (!SWIG_IsOK(ecode1)) {
12354  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12355  }
12356  arg1 = (PLINT)(val1);
12357  ecode2 = SWIG_AsVal_int(obj1, &val2);
12358  if (!SWIG_IsOK(ecode2)) {
12359  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12360  }
12361  arg2 = (PLINT)(val2);
12362  {
12363  res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12364  if (res3<0) {
12365  PyErr_Clear();
12366  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12367  }
12368  arg3 = (void *) buf3;
12369  }
12370  plsmema(arg1,arg2,arg3);
12371  resultobj = SWIG_Py_Void();
12372  return resultobj;
12373 fail:
12374  return NULL;
12375 }
12376 
12377 
12378 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12379  PyObject *resultobj = 0;
12380  PLFLT arg1 ;
12381  PLFLT arg2 ;
12382  double val1 ;
12383  int ecode1 = 0 ;
12384  double val2 ;
12385  int ecode2 = 0 ;
12386  PyObject * obj0 = 0 ;
12387  PyObject * obj1 = 0 ;
12388 
12389  if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12390  ecode1 = SWIG_AsVal_double(obj0, &val1);
12391  if (!SWIG_IsOK(ecode1)) {
12392  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12393  }
12394  arg1 = (PLFLT)(val1);
12395  ecode2 = SWIG_AsVal_double(obj1, &val2);
12396  if (!SWIG_IsOK(ecode2)) {
12397  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12398  }
12399  arg2 = (PLFLT)(val2);
12400  plsmin(arg1,arg2);
12401  resultobj = SWIG_Py_Void();
12402  return resultobj;
12403 fail:
12404  return NULL;
12405 }
12406 
12407 
12408 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12409  PyObject *resultobj = 0;
12410  PLINT arg1 ;
12411  int val1 ;
12412  int ecode1 = 0 ;
12413  PyObject * obj0 = 0 ;
12414 
12415  if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12416  ecode1 = SWIG_AsVal_int(obj0, &val1);
12417  if (!SWIG_IsOK(ecode1)) {
12418  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12419  }
12420  arg1 = (PLINT)(val1);
12421  plsori(arg1);
12422  resultobj = SWIG_Py_Void();
12423  return resultobj;
12424 fail:
12425  return NULL;
12426 }
12427 
12428 
12429 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430  PyObject *resultobj = 0;
12431  PLFLT arg1 ;
12432  PLFLT arg2 ;
12433  PLINT arg3 ;
12434  PLINT arg4 ;
12435  PLINT arg5 ;
12436  PLINT arg6 ;
12437  double val1 ;
12438  int ecode1 = 0 ;
12439  double val2 ;
12440  int ecode2 = 0 ;
12441  int val3 ;
12442  int ecode3 = 0 ;
12443  int val4 ;
12444  int ecode4 = 0 ;
12445  int val5 ;
12446  int ecode5 = 0 ;
12447  int val6 ;
12448  int ecode6 = 0 ;
12449  PyObject * obj0 = 0 ;
12450  PyObject * obj1 = 0 ;
12451  PyObject * obj2 = 0 ;
12452  PyObject * obj3 = 0 ;
12453  PyObject * obj4 = 0 ;
12454  PyObject * obj5 = 0 ;
12455 
12456  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12457  ecode1 = SWIG_AsVal_double(obj0, &val1);
12458  if (!SWIG_IsOK(ecode1)) {
12459  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12460  }
12461  arg1 = (PLFLT)(val1);
12462  ecode2 = SWIG_AsVal_double(obj1, &val2);
12463  if (!SWIG_IsOK(ecode2)) {
12464  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12465  }
12466  arg2 = (PLFLT)(val2);
12467  ecode3 = SWIG_AsVal_int(obj2, &val3);
12468  if (!SWIG_IsOK(ecode3)) {
12469  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12470  }
12471  arg3 = (PLINT)(val3);
12472  ecode4 = SWIG_AsVal_int(obj3, &val4);
12473  if (!SWIG_IsOK(ecode4)) {
12474  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12475  }
12476  arg4 = (PLINT)(val4);
12477  ecode5 = SWIG_AsVal_int(obj4, &val5);
12478  if (!SWIG_IsOK(ecode5)) {
12479  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12480  }
12481  arg5 = (PLINT)(val5);
12482  ecode6 = SWIG_AsVal_int(obj5, &val6);
12483  if (!SWIG_IsOK(ecode6)) {
12484  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12485  }
12486  arg6 = (PLINT)(val6);
12487  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12488  resultobj = SWIG_Py_Void();
12489  return resultobj;
12490 fail:
12491  return NULL;
12492 }
12493 
12494 
12495 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496  PyObject *resultobj = 0;
12497  char *arg1 = (char *) 0 ;
12498  int res1 ;
12499  char *buf1 = 0 ;
12500  int alloc1 = 0 ;
12501  PyObject * obj0 = 0 ;
12502 
12503  if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12504  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12505  if (!SWIG_IsOK(res1)) {
12506  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12507  }
12508  arg1 = (char *)(buf1);
12509  plspal0((char const *)arg1);
12510  resultobj = SWIG_Py_Void();
12511  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12512  return resultobj;
12513 fail:
12514  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12515  return NULL;
12516 }
12517 
12518 
12519 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12520  PyObject *resultobj = 0;
12521  char *arg1 = (char *) 0 ;
12522  PLBOOL arg2 ;
12523  int res1 ;
12524  char *buf1 = 0 ;
12525  int alloc1 = 0 ;
12526  int val2 ;
12527  int ecode2 = 0 ;
12528  PyObject * obj0 = 0 ;
12529  PyObject * obj1 = 0 ;
12530 
12531  if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12532  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12533  if (!SWIG_IsOK(res1)) {
12534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12535  }
12536  arg1 = (char *)(buf1);
12537  ecode2 = SWIG_AsVal_int(obj1, &val2);
12538  if (!SWIG_IsOK(ecode2)) {
12539  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12540  }
12541  arg2 = (PLBOOL)(val2);
12542  plspal1((char const *)arg1,arg2);
12543  resultobj = SWIG_Py_Void();
12544  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12545  return resultobj;
12546 fail:
12547  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12548  return NULL;
12549 }
12550 
12551 
12552 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12553  PyObject *resultobj = 0;
12554  PLBOOL arg1 ;
12555  int val1 ;
12556  int ecode1 = 0 ;
12557  PyObject * obj0 = 0 ;
12558 
12559  if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12560  ecode1 = SWIG_AsVal_int(obj0, &val1);
12561  if (!SWIG_IsOK(ecode1)) {
12562  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12563  }
12564  arg1 = (PLBOOL)(val1);
12565  plspause(arg1);
12566  resultobj = SWIG_Py_Void();
12567  return resultobj;
12568 fail:
12569  return NULL;
12570 }
12571 
12572 
12573 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574  PyObject *resultobj = 0;
12575  PLINT arg1 ;
12576  int val1 ;
12577  int ecode1 = 0 ;
12578  PyObject * obj0 = 0 ;
12579 
12580  if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12581  ecode1 = SWIG_AsVal_int(obj0, &val1);
12582  if (!SWIG_IsOK(ecode1)) {
12583  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12584  }
12585  arg1 = (PLINT)(val1);
12586  plsstrm(arg1);
12587  resultobj = SWIG_Py_Void();
12588  return resultobj;
12589 fail:
12590  return NULL;
12591 }
12592 
12593 
12594 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12595  PyObject *resultobj = 0;
12596  PLINT arg1 ;
12597  PLINT arg2 ;
12598  int val1 ;
12599  int ecode1 = 0 ;
12600  int val2 ;
12601  int ecode2 = 0 ;
12602  PyObject * obj0 = 0 ;
12603  PyObject * obj1 = 0 ;
12604 
12605  if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12606  ecode1 = SWIG_AsVal_int(obj0, &val1);
12607  if (!SWIG_IsOK(ecode1)) {
12608  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12609  }
12610  arg1 = (PLINT)(val1);
12611  ecode2 = SWIG_AsVal_int(obj1, &val2);
12612  if (!SWIG_IsOK(ecode2)) {
12613  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12614  }
12615  arg2 = (PLINT)(val2);
12616  plssub(arg1,arg2);
12617  resultobj = SWIG_Py_Void();
12618  return resultobj;
12619 fail:
12620  return NULL;
12621 }
12622 
12623 
12624 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625  PyObject *resultobj = 0;
12626  PLFLT arg1 ;
12627  PLFLT arg2 ;
12628  double val1 ;
12629  int ecode1 = 0 ;
12630  double val2 ;
12631  int ecode2 = 0 ;
12632  PyObject * obj0 = 0 ;
12633  PyObject * obj1 = 0 ;
12634 
12635  if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12636  ecode1 = SWIG_AsVal_double(obj0, &val1);
12637  if (!SWIG_IsOK(ecode1)) {
12638  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12639  }
12640  arg1 = (PLFLT)(val1);
12641  ecode2 = SWIG_AsVal_double(obj1, &val2);
12642  if (!SWIG_IsOK(ecode2)) {
12643  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12644  }
12645  arg2 = (PLFLT)(val2);
12646  plssym(arg1,arg2);
12647  resultobj = SWIG_Py_Void();
12648  return resultobj;
12649 fail:
12650  return NULL;
12651 }
12652 
12653 
12654 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12655  PyObject *resultobj = 0;
12656  PLINT arg1 ;
12657  PLINT arg2 ;
12658  int val1 ;
12659  int ecode1 = 0 ;
12660  int val2 ;
12661  int ecode2 = 0 ;
12662  PyObject * obj0 = 0 ;
12663  PyObject * obj1 = 0 ;
12664 
12665  if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12666  ecode1 = SWIG_AsVal_int(obj0, &val1);
12667  if (!SWIG_IsOK(ecode1)) {
12668  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12669  }
12670  arg1 = (PLINT)(val1);
12671  ecode2 = SWIG_AsVal_int(obj1, &val2);
12672  if (!SWIG_IsOK(ecode2)) {
12673  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12674  }
12675  arg2 = (PLINT)(val2);
12676  plstar(arg1,arg2);
12677  resultobj = SWIG_Py_Void();
12678  return resultobj;
12679 fail:
12680  return NULL;
12681 }
12682 
12683 
12684 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685  PyObject *resultobj = 0;
12686  char *arg1 = (char *) 0 ;
12687  PLINT arg2 ;
12688  PLINT arg3 ;
12689  int res1 ;
12690  char *buf1 = 0 ;
12691  int alloc1 = 0 ;
12692  int val2 ;
12693  int ecode2 = 0 ;
12694  int val3 ;
12695  int ecode3 = 0 ;
12696  PyObject * obj0 = 0 ;
12697  PyObject * obj1 = 0 ;
12698  PyObject * obj2 = 0 ;
12699 
12700  if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12701  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12702  if (!SWIG_IsOK(res1)) {
12703  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12704  }
12705  arg1 = (char *)(buf1);
12706  ecode2 = SWIG_AsVal_int(obj1, &val2);
12707  if (!SWIG_IsOK(ecode2)) {
12708  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12709  }
12710  arg2 = (PLINT)(val2);
12711  ecode3 = SWIG_AsVal_int(obj2, &val3);
12712  if (!SWIG_IsOK(ecode3)) {
12713  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12714  }
12715  arg3 = (PLINT)(val3);
12716  plstart((char const *)arg1,arg2,arg3);
12717  resultobj = SWIG_Py_Void();
12718  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12719  return resultobj;
12720 fail:
12721  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12722  return NULL;
12723 }
12724 
12725 
12726 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727  PyObject *resultobj = 0;
12728  ct_func arg1 = (ct_func) 0 ;
12729  PLPointer arg2 = (PLPointer) 0 ;
12730  int res2 ;
12731  PyObject * obj0 = 0 ;
12732  PyObject * obj1 = 0 ;
12733 
12734  {
12735  python_ct = 0;
12736  arg1 = NULL;
12737  }
12738  if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12739  if (obj0) {
12740  {
12741  if ( python_ct )
12742  cleanup_ct();
12743  // it must be a callable or none
12744  if ( obj0 == Py_None )
12745  {
12746  arg1 = NULL;
12747  }
12748  else
12749  {
12750  if ( !PyCallable_Check( (PyObject *) obj0 ) )
12751  {
12752  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12753  return NULL;
12754  }
12755  arg1 = marshal_ct( obj0 );
12756  }
12757  }
12758  }
12759  if (obj1) {
12760  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12761  if (!SWIG_IsOK(res2)) {
12762  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12763  }
12764  }
12765  plstransform(arg1,arg2);
12766  resultobj = SWIG_Py_Void();
12767  return resultobj;
12768 fail:
12769  return NULL;
12770 }
12771 
12772 
12773 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774  PyObject *resultobj = 0;
12775  PLINT arg1 ;
12776  PLFLT *arg2 = (PLFLT *) 0 ;
12777  PLFLT *arg3 = (PLFLT *) 0 ;
12778  char *arg4 = (char *) 0 ;
12779  PyArrayObject *tmp1 = NULL ;
12780  PyArrayObject *tmp3 = NULL ;
12781  int res4 ;
12782  char *buf4 = 0 ;
12783  int alloc4 = 0 ;
12784  PyObject * obj0 = 0 ;
12785  PyObject * obj1 = 0 ;
12786  PyObject * obj2 = 0 ;
12787 
12788  if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12789  {
12790  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12791  if ( tmp1 == NULL )
12792  return NULL;
12793  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12794  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12795  }
12796  {
12797  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12798  if ( tmp3 == NULL )
12799  return NULL;
12800  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12801  {
12802  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12803  return NULL;
12804  }
12805  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12806  }
12807  res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12808  if (!SWIG_IsOK(res4)) {
12809  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12810  }
12811  arg4 = (char *)(buf4);
12812  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12813  resultobj = SWIG_Py_Void();
12814  {
12815  Py_CLEAR( tmp1 );
12816  }
12817  {
12818  Py_CLEAR( tmp3 );
12819  }
12820  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12821  return resultobj;
12822 fail:
12823  {
12824  Py_CLEAR( tmp1 );
12825  }
12826  {
12827  Py_CLEAR( tmp3 );
12828  }
12829  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12830  return NULL;
12831 }
12832 
12833 
12834 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835  PyObject *resultobj = 0;
12836  PLINT arg1 ;
12837  PLFLT *arg2 = (PLFLT *) 0 ;
12838  PLFLT *arg3 = (PLFLT *) 0 ;
12839  PLFLT *arg4 = (PLFLT *) 0 ;
12840  char *arg5 = (char *) 0 ;
12841  PyArrayObject *tmp1 = NULL ;
12842  PyArrayObject *tmp3 = NULL ;
12843  PyArrayObject *tmp4 = NULL ;
12844  int res5 ;
12845  char *buf5 = 0 ;
12846  int alloc5 = 0 ;
12847  PyObject * obj0 = 0 ;
12848  PyObject * obj1 = 0 ;
12849  PyObject * obj2 = 0 ;
12850  PyObject * obj3 = 0 ;
12851 
12852  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12853  {
12854  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12855  if ( tmp1 == NULL )
12856  return NULL;
12857  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12858  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12859  }
12860  {
12861  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12862  if ( tmp3 == NULL )
12863  return NULL;
12864  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12865  {
12866  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12867  return NULL;
12868  }
12869  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12870  }
12871  {
12872  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12873  if ( tmp4 == NULL )
12874  return NULL;
12875  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12876  {
12877  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12878  return NULL;
12879  }
12880  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12881  }
12882  res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12883  if (!SWIG_IsOK(res5)) {
12884  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12885  }
12886  arg5 = (char *)(buf5);
12887  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12888  resultobj = SWIG_Py_Void();
12889  {
12890  Py_CLEAR( tmp1 );
12891  }
12892  {
12893  Py_CLEAR( tmp3 );
12894  }
12895  {
12896  Py_CLEAR( tmp4 );
12897  }
12898  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12899  return resultobj;
12900 fail:
12901  {
12902  Py_CLEAR( tmp1 );
12903  }
12904  {
12905  Py_CLEAR( tmp3 );
12906  }
12907  {
12908  Py_CLEAR( tmp4 );
12909  }
12910  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12911  return NULL;
12912 }
12913 
12914 
12915 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916  PyObject *resultobj = 0;
12917  PLINT arg1 ;
12918  PLINT arg2 ;
12919  PLFLT arg3 ;
12920  PLFLT arg4 ;
12921  int val1 ;
12922  int ecode1 = 0 ;
12923  int val2 ;
12924  int ecode2 = 0 ;
12925  double val3 ;
12926  int ecode3 = 0 ;
12927  double val4 ;
12928  int ecode4 = 0 ;
12929  PyObject * obj0 = 0 ;
12930  PyObject * obj1 = 0 ;
12931  PyObject * obj2 = 0 ;
12932  PyObject * obj3 = 0 ;
12933 
12934  if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12935  ecode1 = SWIG_AsVal_int(obj0, &val1);
12936  if (!SWIG_IsOK(ecode1)) {
12937  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12938  }
12939  arg1 = (PLINT)(val1);
12940  ecode2 = SWIG_AsVal_int(obj1, &val2);
12941  if (!SWIG_IsOK(ecode2)) {
12942  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12943  }
12944  arg2 = (PLINT)(val2);
12945  ecode3 = SWIG_AsVal_double(obj2, &val3);
12946  if (!SWIG_IsOK(ecode3)) {
12947  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12948  }
12949  arg3 = (PLFLT)(val3);
12950  ecode4 = SWIG_AsVal_double(obj3, &val4);
12951  if (!SWIG_IsOK(ecode4)) {
12952  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12953  }
12954  arg4 = (PLFLT)(val4);
12955  plstripa(arg1,arg2,arg3,arg4);
12956  resultobj = SWIG_Py_Void();
12957  return resultobj;
12958 fail:
12959  return NULL;
12960 }
12961 
12962 
12963 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964  PyObject *resultobj = 0;
12965  PLINT *arg1 = (PLINT *) 0 ;
12966  char *arg2 = (char *) 0 ;
12967  char *arg3 = (char *) 0 ;
12968  PLFLT arg4 ;
12969  PLFLT arg5 ;
12970  PLFLT arg6 ;
12971  PLFLT arg7 ;
12972  PLFLT arg8 ;
12973  PLFLT arg9 ;
12974  PLFLT arg10 ;
12975  PLBOOL arg11 ;
12976  PLBOOL arg12 ;
12977  PLINT arg13 ;
12978  PLINT arg14 ;
12979  PLINT *arg15 = (PLINT *) 0 ;
12980  PLINT *arg16 = (PLINT *) 0 ;
12981  char **arg17 ;
12982  char *arg18 = (char *) 0 ;
12983  char *arg19 = (char *) 0 ;
12984  char *arg20 = (char *) 0 ;
12985  PLINT temp1 ;
12986  int res1 = SWIG_TMPOBJ ;
12987  int res2 ;
12988  char *buf2 = 0 ;
12989  int alloc2 = 0 ;
12990  int res3 ;
12991  char *buf3 = 0 ;
12992  int alloc3 = 0 ;
12993  double val4 ;
12994  int ecode4 = 0 ;
12995  double val5 ;
12996  int ecode5 = 0 ;
12997  double val6 ;
12998  int ecode6 = 0 ;
12999  double val7 ;
13000  int ecode7 = 0 ;
13001  double val8 ;
13002  int ecode8 = 0 ;
13003  double val9 ;
13004  int ecode9 = 0 ;
13005  double val10 ;
13006  int ecode10 = 0 ;
13007  int val11 ;
13008  int ecode11 = 0 ;
13009  int val12 ;
13010  int ecode12 = 0 ;
13011  int val13 ;
13012  int ecode13 = 0 ;
13013  int val14 ;
13014  int ecode14 = 0 ;
13015  PyArrayObject *tmp15 = NULL ;
13016  PyArrayObject *tmp16 = NULL ;
13017  char **tmp17 = NULL ;
13018  int res18 ;
13019  char *buf18 = 0 ;
13020  int alloc18 = 0 ;
13021  int res19 ;
13022  char *buf19 = 0 ;
13023  int alloc19 = 0 ;
13024  int res20 ;
13025  char *buf20 = 0 ;
13026  int alloc20 = 0 ;
13027  PyObject * obj0 = 0 ;
13028  PyObject * obj1 = 0 ;
13029  PyObject * obj2 = 0 ;
13030  PyObject * obj3 = 0 ;
13031  PyObject * obj4 = 0 ;
13032  PyObject * obj5 = 0 ;
13033  PyObject * obj6 = 0 ;
13034  PyObject * obj7 = 0 ;
13035  PyObject * obj8 = 0 ;
13036  PyObject * obj9 = 0 ;
13037  PyObject * obj10 = 0 ;
13038  PyObject * obj11 = 0 ;
13039  PyObject * obj12 = 0 ;
13040  PyObject * obj13 = 0 ;
13041  PyObject * obj14 = 0 ;
13042  PyObject * obj15 = 0 ;
13043  PyObject * obj16 = 0 ;
13044  PyObject * obj17 = 0 ;
13045  PyObject * obj18 = 0 ;
13046 
13047  arg1 = &temp1;
13048  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
13049  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13050  if (!SWIG_IsOK(res2)) {
13051  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13052  }
13053  arg2 = (char *)(buf2);
13054  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13055  if (!SWIG_IsOK(res3)) {
13056  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13057  }
13058  arg3 = (char *)(buf3);
13059  ecode4 = SWIG_AsVal_double(obj2, &val4);
13060  if (!SWIG_IsOK(ecode4)) {
13061  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13062  }
13063  arg4 = (PLFLT)(val4);
13064  ecode5 = SWIG_AsVal_double(obj3, &val5);
13065  if (!SWIG_IsOK(ecode5)) {
13066  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13067  }
13068  arg5 = (PLFLT)(val5);
13069  ecode6 = SWIG_AsVal_double(obj4, &val6);
13070  if (!SWIG_IsOK(ecode6)) {
13071  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13072  }
13073  arg6 = (PLFLT)(val6);
13074  ecode7 = SWIG_AsVal_double(obj5, &val7);
13075  if (!SWIG_IsOK(ecode7)) {
13076  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13077  }
13078  arg7 = (PLFLT)(val7);
13079  ecode8 = SWIG_AsVal_double(obj6, &val8);
13080  if (!SWIG_IsOK(ecode8)) {
13081  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13082  }
13083  arg8 = (PLFLT)(val8);
13084  ecode9 = SWIG_AsVal_double(obj7, &val9);
13085  if (!SWIG_IsOK(ecode9)) {
13086  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13087  }
13088  arg9 = (PLFLT)(val9);
13089  ecode10 = SWIG_AsVal_double(obj8, &val10);
13090  if (!SWIG_IsOK(ecode10)) {
13091  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13092  }
13093  arg10 = (PLFLT)(val10);
13094  ecode11 = SWIG_AsVal_int(obj9, &val11);
13095  if (!SWIG_IsOK(ecode11)) {
13096  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13097  }
13098  arg11 = (PLBOOL)(val11);
13099  ecode12 = SWIG_AsVal_int(obj10, &val12);
13100  if (!SWIG_IsOK(ecode12)) {
13101  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13102  }
13103  arg12 = (PLBOOL)(val12);
13104  ecode13 = SWIG_AsVal_int(obj11, &val13);
13105  if (!SWIG_IsOK(ecode13)) {
13106  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13107  }
13108  arg13 = (PLINT)(val13);
13109  ecode14 = SWIG_AsVal_int(obj12, &val14);
13110  if (!SWIG_IsOK(ecode14)) {
13111  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13112  }
13113  arg14 = (PLINT)(val14);
13114  {
13115  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13116  if ( tmp15 == NULL )
13117  return NULL;
13118  Alen = PyArray_DIMS( tmp15 )[0];
13119  arg15 = (PLINT *) PyArray_DATA( tmp15 );
13120  }
13121  {
13122  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13123  if ( tmp16 == NULL )
13124  return NULL;
13125  if ( PyArray_DIMS( tmp16 )[0] != Alen )
13126  {
13127  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13128  return NULL;
13129  }
13130  arg16 = (PLINT *) PyArray_DATA( tmp16 );
13131  }
13132  {
13133  int i;
13134  if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13135  {
13136  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13137  return NULL;
13138  }
13139  if ( Alen != 4 )
13140  {
13141  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13142  return NULL;
13143  }
13144  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13145  if ( tmp17 == NULL )
13146  return NULL;
13147  arg17 = tmp17;
13148  for ( i = 0; i < 4; i++ )
13149  {
13150  arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13151  if ( arg17[i] == NULL )
13152  {
13153  free( tmp17 );
13154  return NULL;
13155  }
13156  }
13157  }
13158  res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13159  if (!SWIG_IsOK(res18)) {
13160  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13161  }
13162  arg18 = (char *)(buf18);
13163  res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13164  if (!SWIG_IsOK(res19)) {
13165  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13166  }
13167  arg19 = (char *)(buf19);
13168  res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13169  if (!SWIG_IsOK(res20)) {
13170  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13171  }
13172  arg20 = (char *)(buf20);
13173  plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *(*))arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20);
13174  resultobj = SWIG_Py_Void();
13175  if (SWIG_IsTmpObj(res1)) {
13176  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13177  } else {
13178  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13179  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13180  }
13181  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13182  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13183  {
13184  Py_CLEAR( tmp15 );
13185  }
13186  {
13187  Py_CLEAR( tmp16 );
13188  }
13189  {
13190  free( tmp17 );
13191  }
13192  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13193  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13194  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13195  return resultobj;
13196 fail:
13197  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13198  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13199  {
13200  Py_CLEAR( tmp15 );
13201  }
13202  {
13203  Py_CLEAR( tmp16 );
13204  }
13205  {
13206  free( tmp17 );
13207  }
13208  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13209  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13210  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13211  return NULL;
13212 }
13213 
13214 
13215 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13216  PyObject *resultobj = 0;
13217  PLINT arg1 ;
13218  int val1 ;
13219  int ecode1 = 0 ;
13220  PyObject * obj0 = 0 ;
13221 
13222  if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13223  ecode1 = SWIG_AsVal_int(obj0, &val1);
13224  if (!SWIG_IsOK(ecode1)) {
13225  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13226  }
13227  arg1 = (PLINT)(val1);
13228  plstripd(arg1);
13229  resultobj = SWIG_Py_Void();
13230  return resultobj;
13231 fail:
13232  return NULL;
13233 }
13234 
13235 
13236 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13237  PyObject *resultobj = 0;
13238  PLINT arg1 ;
13239  PLINT *arg2 = (PLINT *) 0 ;
13240  PLINT *arg3 = (PLINT *) 0 ;
13241  PyArrayObject *tmp1 = NULL ;
13242  PyArrayObject *tmp3 = NULL ;
13243  PyObject * obj0 = 0 ;
13244  PyObject * obj1 = 0 ;
13245 
13246  if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13247  {
13248  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13249  if ( tmp1 == NULL )
13250  return NULL;
13251  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13252  arg2 = (PLINT *) PyArray_DATA( tmp1 );
13253  }
13254  {
13255  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13256  if ( tmp3 == NULL )
13257  return NULL;
13258  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13259  {
13260  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13261  return NULL;
13262  }
13263  arg3 = (PLINT *) PyArray_DATA( tmp3 );
13264  }
13265  plstyl(arg1,(int const *)arg2,(int const *)arg3);
13266  resultobj = SWIG_Py_Void();
13267  {
13268  Py_CLEAR( tmp1 );
13269  }
13270  {
13271  Py_CLEAR( tmp3 );
13272  }
13273  return resultobj;
13274 fail:
13275  {
13276  Py_CLEAR( tmp1 );
13277  }
13278  {
13279  Py_CLEAR( tmp3 );
13280  }
13281  return NULL;
13282 }
13283 
13284 
13285 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13286  PyObject *resultobj = 0;
13287  PLFLT *arg1 = (PLFLT *) 0 ;
13288  PLFLT *arg2 = (PLFLT *) 0 ;
13289  PLINT arg3 ;
13290  PLBOOL arg4 ;
13291  PyArrayObject *tmp1 = NULL ;
13292  PyArrayObject *tmp2 = NULL ;
13293  int val4 ;
13294  int ecode4 = 0 ;
13295  PyObject * obj0 = 0 ;
13296  PyObject * obj1 = 0 ;
13297  PyObject * obj2 = 0 ;
13298 
13299  if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13300  {
13301  if ( obj0 != Py_None )
13302  {
13303  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13304  if ( tmp1 == NULL )
13305  return NULL;
13306  Alen = PyArray_DIMS( tmp1 )[0];
13307  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13308  }
13309  else
13310  {
13311  arg1 = NULL;
13312  Alen = 0;
13313  }
13314  }
13315  {
13316  if ( obj1 != Py_None )
13317  {
13318  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13319  if ( tmp2 == NULL )
13320  return NULL;
13321  if ( PyArray_DIMS( tmp2 )[0] != Alen )
13322  {
13323  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13324  return NULL;
13325  }
13326  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13327  arg3 = PyArray_DIMS( tmp2 )[0];
13328  }
13329  else
13330  {
13331  arg2 = NULL;
13332  arg3 = 0;
13333  }
13334  }
13335  ecode4 = SWIG_AsVal_int(obj2, &val4);
13336  if (!SWIG_IsOK(ecode4)) {
13337  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13338  }
13339  arg4 = (PLBOOL)(val4);
13340  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13341  resultobj = SWIG_Py_Void();
13342  {
13343  Py_CLEAR( tmp1 );
13344  }
13345  {
13346  Py_CLEAR( tmp2 );
13347  }
13348  return resultobj;
13349 fail:
13350  {
13351  Py_CLEAR( tmp1 );
13352  }
13353  {
13354  Py_CLEAR( tmp2 );
13355  }
13356  return NULL;
13357 }
13358 
13359 
13360 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13361  PyObject *resultobj = 0;
13362  PLFLT arg1 ;
13363  PLFLT arg2 ;
13364  PLFLT arg3 ;
13365  PLFLT arg4 ;
13366  double val1 ;
13367  int ecode1 = 0 ;
13368  double val2 ;
13369  int ecode2 = 0 ;
13370  double val3 ;
13371  int ecode3 = 0 ;
13372  double val4 ;
13373  int ecode4 = 0 ;
13374  PyObject * obj0 = 0 ;
13375  PyObject * obj1 = 0 ;
13376  PyObject * obj2 = 0 ;
13377  PyObject * obj3 = 0 ;
13378 
13379  if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13380  ecode1 = SWIG_AsVal_double(obj0, &val1);
13381  if (!SWIG_IsOK(ecode1)) {
13382  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13383  }
13384  arg1 = (PLFLT)(val1);
13385  ecode2 = SWIG_AsVal_double(obj1, &val2);
13386  if (!SWIG_IsOK(ecode2)) {
13387  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13388  }
13389  arg2 = (PLFLT)(val2);
13390  ecode3 = SWIG_AsVal_double(obj2, &val3);
13391  if (!SWIG_IsOK(ecode3)) {
13392  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13393  }
13394  arg3 = (PLFLT)(val3);
13395  ecode4 = SWIG_AsVal_double(obj3, &val4);
13396  if (!SWIG_IsOK(ecode4)) {
13397  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13398  }
13399  arg4 = (PLFLT)(val4);
13400  plsvpa(arg1,arg2,arg3,arg4);
13401  resultobj = SWIG_Py_Void();
13402  return resultobj;
13403 fail:
13404  return NULL;
13405 }
13406 
13407 
13408 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13409  PyObject *resultobj = 0;
13410  PLINT arg1 ;
13411  PLINT arg2 ;
13412  int val1 ;
13413  int ecode1 = 0 ;
13414  int val2 ;
13415  int ecode2 = 0 ;
13416  PyObject * obj0 = 0 ;
13417  PyObject * obj1 = 0 ;
13418 
13419  if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13420  ecode1 = SWIG_AsVal_int(obj0, &val1);
13421  if (!SWIG_IsOK(ecode1)) {
13422  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13423  }
13424  arg1 = (PLINT)(val1);
13425  ecode2 = SWIG_AsVal_int(obj1, &val2);
13426  if (!SWIG_IsOK(ecode2)) {
13427  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13428  }
13429  arg2 = (PLINT)(val2);
13430  plsxax(arg1,arg2);
13431  resultobj = SWIG_Py_Void();
13432  return resultobj;
13433 fail:
13434  return NULL;
13435 }
13436 
13437 
13438 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439  PyObject *resultobj = 0;
13440  PLINT arg1 ;
13441  PLINT arg2 ;
13442  int val1 ;
13443  int ecode1 = 0 ;
13444  int val2 ;
13445  int ecode2 = 0 ;
13446  PyObject * obj0 = 0 ;
13447  PyObject * obj1 = 0 ;
13448 
13449  if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13450  ecode1 = SWIG_AsVal_int(obj0, &val1);
13451  if (!SWIG_IsOK(ecode1)) {
13452  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13453  }
13454  arg1 = (PLINT)(val1);
13455  ecode2 = SWIG_AsVal_int(obj1, &val2);
13456  if (!SWIG_IsOK(ecode2)) {
13457  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13458  }
13459  arg2 = (PLINT)(val2);
13460  plsyax(arg1,arg2);
13461  resultobj = SWIG_Py_Void();
13462  return resultobj;
13463 fail:
13464  return NULL;
13465 }
13466 
13467 
13468 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469  PyObject *resultobj = 0;
13470  PLINT arg1 ;
13471  PLFLT *arg2 = (PLFLT *) 0 ;
13472  PLFLT *arg3 = (PLFLT *) 0 ;
13473  PLINT arg4 ;
13474  PyArrayObject *tmp1 = NULL ;
13475  PyArrayObject *tmp3 = NULL ;
13476  int val4 ;
13477  int ecode4 = 0 ;
13478  PyObject * obj0 = 0 ;
13479  PyObject * obj1 = 0 ;
13480  PyObject * obj2 = 0 ;
13481 
13482  if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13483  {
13484  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13485  if ( tmp1 == NULL )
13486  return NULL;
13487  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13488  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13489  }
13490  {
13491  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13492  if ( tmp3 == NULL )
13493  return NULL;
13494  if ( PyArray_DIMS( tmp3 )[0] != Alen )
13495  {
13496  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13497  return NULL;
13498  }
13499  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13500  }
13501  ecode4 = SWIG_AsVal_int(obj2, &val4);
13502  if (!SWIG_IsOK(ecode4)) {
13503  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13504  }
13505  arg4 = (PLINT)(val4);
13506  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13507  resultobj = SWIG_Py_Void();
13508  {
13509  Py_CLEAR( tmp1 );
13510  }
13511  {
13512  Py_CLEAR( tmp3 );
13513  }
13514  return resultobj;
13515 fail:
13516  {
13517  Py_CLEAR( tmp1 );
13518  }
13519  {
13520  Py_CLEAR( tmp3 );
13521  }
13522  return NULL;
13523 }
13524 
13525 
13526 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13527  PyObject *resultobj = 0;
13528  PLINT arg1 ;
13529  PLINT arg2 ;
13530  int val1 ;
13531  int ecode1 = 0 ;
13532  int val2 ;
13533  int ecode2 = 0 ;
13534  PyObject * obj0 = 0 ;
13535  PyObject * obj1 = 0 ;
13536 
13537  if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13538  ecode1 = SWIG_AsVal_int(obj0, &val1);
13539  if (!SWIG_IsOK(ecode1)) {
13540  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13541  }
13542  arg1 = (PLINT)(val1);
13543  ecode2 = SWIG_AsVal_int(obj1, &val2);
13544  if (!SWIG_IsOK(ecode2)) {
13545  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13546  }
13547  arg2 = (PLINT)(val2);
13548  plszax(arg1,arg2);
13549  resultobj = SWIG_Py_Void();
13550  return resultobj;
13551 fail:
13552  return NULL;
13553 }
13554 
13555 
13556 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13557  PyObject *resultobj = 0;
13558 
13559  if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13560  pltext();
13561  resultobj = SWIG_Py_Void();
13562  return resultobj;
13563 fail:
13564  return NULL;
13565 }
13566 
13567 
13568 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13569  PyObject *resultobj = 0;
13570  char *arg1 = (char *) 0 ;
13571  int res1 ;
13572  char *buf1 = 0 ;
13573  int alloc1 = 0 ;
13574  PyObject * obj0 = 0 ;
13575 
13576  if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13577  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13578  if (!SWIG_IsOK(res1)) {
13579  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13580  }
13581  arg1 = (char *)(buf1);
13582  pltimefmt((char const *)arg1);
13583  resultobj = SWIG_Py_Void();
13584  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13585  return resultobj;
13586 fail:
13587  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13588  return NULL;
13589 }
13590 
13591 
13592 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593  PyObject *resultobj = 0;
13594  PLFLT arg1 ;
13595  double val1 ;
13596  int ecode1 = 0 ;
13597  PyObject * obj0 = 0 ;
13598 
13599  if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13600  ecode1 = SWIG_AsVal_double(obj0, &val1);
13601  if (!SWIG_IsOK(ecode1)) {
13602  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13603  }
13604  arg1 = (PLFLT)(val1);
13605  plvasp(arg1);
13606  resultobj = SWIG_Py_Void();
13607  return resultobj;
13608 fail:
13609  return NULL;
13610 }
13611 
13612 
13613 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13614  PyObject *resultobj = 0;
13615  PLFLT **arg1 = (PLFLT **) 0 ;
13616  PLFLT **arg2 = (PLFLT **) 0 ;
13617  PLINT arg3 ;
13618  PLINT arg4 ;
13619  PLFLT arg5 ;
13620  pltr_func arg6 = (pltr_func) 0 ;
13621  PLPointer arg7 = (PLPointer) 0 ;
13622  PyArrayObject *tmp1 = NULL ;
13623  PyArrayObject *tmp2 = NULL ;
13624  double val5 ;
13625  int ecode5 = 0 ;
13626  PyObject * obj0 = 0 ;
13627  PyObject * obj1 = 0 ;
13628  PyObject * obj2 = 0 ;
13629  PyObject * obj3 = 0 ;
13630  PyObject * obj4 = 0 ;
13631 
13632  {
13633  python_pltr = 0;
13634  arg6 = NULL;
13635  }
13636  {
13637  arg7 = NULL;
13638  }
13639  if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13640  {
13641  int i, size;
13642  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13643  if ( tmp1 == NULL )
13644  return NULL;
13645  Xlen = PyArray_DIMS( tmp1 )[0];
13646  Ylen = PyArray_DIMS( tmp1 )[1];
13647  size = Ylen;
13648  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13649  for ( i = 0; i < Xlen; i++ )
13650  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13651  }
13652  {
13653  int i, size;
13654  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13655  if ( tmp2 == NULL )
13656  return NULL;
13657  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13658  {
13659  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13660  return NULL;
13661  }
13662  arg3 = PyArray_DIMS( tmp2 )[0];
13663  arg4 = PyArray_DIMS( tmp2 )[1];
13664  size = arg4;
13665  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13666  for ( i = 0; i < arg3; i++ )
13667  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13668  }
13669  ecode5 = SWIG_AsVal_double(obj2, &val5);
13670  if (!SWIG_IsOK(ecode5)) {
13671  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13672  }
13673  arg5 = (PLFLT)(val5);
13674  if (obj3) {
13675  {
13676  // it must be a callable or None
13677  if ( obj3 == Py_None )
13678  {
13679  arg6 = NULL;
13680  }
13681  else
13682  {
13683  if ( !PyCallable_Check( (PyObject *) obj3 ) )
13684  {
13685  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13686  return NULL;
13687  }
13688  arg6 = marshal_pltr( obj3 );
13689  }
13690  }
13691  }
13692  if (obj4) {
13693  {
13694  if ( obj4 == Py_None )
13695  arg7 = NULL;
13696  else
13697  {
13698  arg7 = marshal_PLPointer( obj4, 0 );
13699  }
13700  }
13701  }
13702  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13703  resultobj = SWIG_Py_Void();
13704  {
13705  Py_CLEAR( tmp1 );
13706  free( arg1 );
13707  }
13708  {
13709  Py_CLEAR( tmp2 );
13710  free( arg2 );
13711  }
13712  {
13713  cleanup_pltr();
13714  }
13715  {
13717  }
13718  return resultobj;
13719 fail:
13720  {
13721  Py_CLEAR( tmp1 );
13722  free( arg1 );
13723  }
13724  {
13725  Py_CLEAR( tmp2 );
13726  free( arg2 );
13727  }
13728  {
13729  cleanup_pltr();
13730  }
13731  {
13733  }
13734  return NULL;
13735 }
13736 
13737 
13738 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13739  PyObject *resultobj = 0;
13740  PLFLT arg1 ;
13741  PLFLT arg2 ;
13742  PLFLT arg3 ;
13743  PLFLT arg4 ;
13744  PLFLT arg5 ;
13745  double val1 ;
13746  int ecode1 = 0 ;
13747  double val2 ;
13748  int ecode2 = 0 ;
13749  double val3 ;
13750  int ecode3 = 0 ;
13751  double val4 ;
13752  int ecode4 = 0 ;
13753  double val5 ;
13754  int ecode5 = 0 ;
13755  PyObject * obj0 = 0 ;
13756  PyObject * obj1 = 0 ;
13757  PyObject * obj2 = 0 ;
13758  PyObject * obj3 = 0 ;
13759  PyObject * obj4 = 0 ;
13760 
13761  if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13762  ecode1 = SWIG_AsVal_double(obj0, &val1);
13763  if (!SWIG_IsOK(ecode1)) {
13764  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13765  }
13766  arg1 = (PLFLT)(val1);
13767  ecode2 = SWIG_AsVal_double(obj1, &val2);
13768  if (!SWIG_IsOK(ecode2)) {
13769  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13770  }
13771  arg2 = (PLFLT)(val2);
13772  ecode3 = SWIG_AsVal_double(obj2, &val3);
13773  if (!SWIG_IsOK(ecode3)) {
13774  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13775  }
13776  arg3 = (PLFLT)(val3);
13777  ecode4 = SWIG_AsVal_double(obj3, &val4);
13778  if (!SWIG_IsOK(ecode4)) {
13779  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13780  }
13781  arg4 = (PLFLT)(val4);
13782  ecode5 = SWIG_AsVal_double(obj4, &val5);
13783  if (!SWIG_IsOK(ecode5)) {
13784  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13785  }
13786  arg5 = (PLFLT)(val5);
13787  plvpas(arg1,arg2,arg3,arg4,arg5);
13788  resultobj = SWIG_Py_Void();
13789  return resultobj;
13790 fail:
13791  return NULL;
13792 }
13793 
13794 
13795 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13796  PyObject *resultobj = 0;
13797  PLFLT arg1 ;
13798  PLFLT arg2 ;
13799  PLFLT arg3 ;
13800  PLFLT arg4 ;
13801  double val1 ;
13802  int ecode1 = 0 ;
13803  double val2 ;
13804  int ecode2 = 0 ;
13805  double val3 ;
13806  int ecode3 = 0 ;
13807  double val4 ;
13808  int ecode4 = 0 ;
13809  PyObject * obj0 = 0 ;
13810  PyObject * obj1 = 0 ;
13811  PyObject * obj2 = 0 ;
13812  PyObject * obj3 = 0 ;
13813 
13814  if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13815  ecode1 = SWIG_AsVal_double(obj0, &val1);
13816  if (!SWIG_IsOK(ecode1)) {
13817  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13818  }
13819  arg1 = (PLFLT)(val1);
13820  ecode2 = SWIG_AsVal_double(obj1, &val2);
13821  if (!SWIG_IsOK(ecode2)) {
13822  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13823  }
13824  arg2 = (PLFLT)(val2);
13825  ecode3 = SWIG_AsVal_double(obj2, &val3);
13826  if (!SWIG_IsOK(ecode3)) {
13827  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13828  }
13829  arg3 = (PLFLT)(val3);
13830  ecode4 = SWIG_AsVal_double(obj3, &val4);
13831  if (!SWIG_IsOK(ecode4)) {
13832  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13833  }
13834  arg4 = (PLFLT)(val4);
13835  plvpor(arg1,arg2,arg3,arg4);
13836  resultobj = SWIG_Py_Void();
13837  return resultobj;
13838 fail:
13839  return NULL;
13840 }
13841 
13842 
13843 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13844  PyObject *resultobj = 0;
13845 
13846  if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13847  plvsta();
13848  resultobj = SWIG_Py_Void();
13849  return resultobj;
13850 fail:
13851  return NULL;
13852 }
13853 
13854 
13855 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13856  PyObject *resultobj = 0;
13857  PLFLT arg1 ;
13858  PLFLT arg2 ;
13859  PLFLT arg3 ;
13860  PLFLT arg4 ;
13861  PLFLT arg5 ;
13862  PLFLT arg6 ;
13863  PLFLT arg7 ;
13864  PLFLT arg8 ;
13865  PLFLT arg9 ;
13866  PLFLT arg10 ;
13867  PLFLT arg11 ;
13868  double val1 ;
13869  int ecode1 = 0 ;
13870  double val2 ;
13871  int ecode2 = 0 ;
13872  double val3 ;
13873  int ecode3 = 0 ;
13874  double val4 ;
13875  int ecode4 = 0 ;
13876  double val5 ;
13877  int ecode5 = 0 ;
13878  double val6 ;
13879  int ecode6 = 0 ;
13880  double val7 ;
13881  int ecode7 = 0 ;
13882  double val8 ;
13883  int ecode8 = 0 ;
13884  double val9 ;
13885  int ecode9 = 0 ;
13886  double val10 ;
13887  int ecode10 = 0 ;
13888  double val11 ;
13889  int ecode11 = 0 ;
13890  PyObject * obj0 = 0 ;
13891  PyObject * obj1 = 0 ;
13892  PyObject * obj2 = 0 ;
13893  PyObject * obj3 = 0 ;
13894  PyObject * obj4 = 0 ;
13895  PyObject * obj5 = 0 ;
13896  PyObject * obj6 = 0 ;
13897  PyObject * obj7 = 0 ;
13898  PyObject * obj8 = 0 ;
13899  PyObject * obj9 = 0 ;
13900  PyObject * obj10 = 0 ;
13901 
13902  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13903  ecode1 = SWIG_AsVal_double(obj0, &val1);
13904  if (!SWIG_IsOK(ecode1)) {
13905  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13906  }
13907  arg1 = (PLFLT)(val1);
13908  ecode2 = SWIG_AsVal_double(obj1, &val2);
13909  if (!SWIG_IsOK(ecode2)) {
13910  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13911  }
13912  arg2 = (PLFLT)(val2);
13913  ecode3 = SWIG_AsVal_double(obj2, &val3);
13914  if (!SWIG_IsOK(ecode3)) {
13915  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13916  }
13917  arg3 = (PLFLT)(val3);
13918  ecode4 = SWIG_AsVal_double(obj3, &val4);
13919  if (!SWIG_IsOK(ecode4)) {
13920  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13921  }
13922  arg4 = (PLFLT)(val4);
13923  ecode5 = SWIG_AsVal_double(obj4, &val5);
13924  if (!SWIG_IsOK(ecode5)) {
13925  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13926  }
13927  arg5 = (PLFLT)(val5);
13928  ecode6 = SWIG_AsVal_double(obj5, &val6);
13929  if (!SWIG_IsOK(ecode6)) {
13930  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13931  }
13932  arg6 = (PLFLT)(val6);
13933  ecode7 = SWIG_AsVal_double(obj6, &val7);
13934  if (!SWIG_IsOK(ecode7)) {
13935  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13936  }
13937  arg7 = (PLFLT)(val7);
13938  ecode8 = SWIG_AsVal_double(obj7, &val8);
13939  if (!SWIG_IsOK(ecode8)) {
13940  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13941  }
13942  arg8 = (PLFLT)(val8);
13943  ecode9 = SWIG_AsVal_double(obj8, &val9);
13944  if (!SWIG_IsOK(ecode9)) {
13945  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13946  }
13947  arg9 = (PLFLT)(val9);
13948  ecode10 = SWIG_AsVal_double(obj9, &val10);
13949  if (!SWIG_IsOK(ecode10)) {
13950  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13951  }
13952  arg10 = (PLFLT)(val10);
13953  ecode11 = SWIG_AsVal_double(obj10, &val11);
13954  if (!SWIG_IsOK(ecode11)) {
13955  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13956  }
13957  arg11 = (PLFLT)(val11);
13958  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13959  resultobj = SWIG_Py_Void();
13960  return resultobj;
13961 fail:
13962  return NULL;
13963 }
13964 
13965 
13966 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13967  PyObject *resultobj = 0;
13968  PLFLT arg1 ;
13969  double val1 ;
13970  int ecode1 = 0 ;
13971  PyObject * obj0 = 0 ;
13972 
13973  if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13974  ecode1 = SWIG_AsVal_double(obj0, &val1);
13975  if (!SWIG_IsOK(ecode1)) {
13976  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13977  }
13978  arg1 = (PLFLT)(val1);
13979  plwidth(arg1);
13980  resultobj = SWIG_Py_Void();
13981  return resultobj;
13982 fail:
13983  return NULL;
13984 }
13985 
13986 
13987 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988  PyObject *resultobj = 0;
13989  PLFLT arg1 ;
13990  PLFLT arg2 ;
13991  PLFLT arg3 ;
13992  PLFLT arg4 ;
13993  double val1 ;
13994  int ecode1 = 0 ;
13995  double val2 ;
13996  int ecode2 = 0 ;
13997  double val3 ;
13998  int ecode3 = 0 ;
13999  double val4 ;
14000  int ecode4 = 0 ;
14001  PyObject * obj0 = 0 ;
14002  PyObject * obj1 = 0 ;
14003  PyObject * obj2 = 0 ;
14004  PyObject * obj3 = 0 ;
14005 
14006  if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14007  ecode1 = SWIG_AsVal_double(obj0, &val1);
14008  if (!SWIG_IsOK(ecode1)) {
14009  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14010  }
14011  arg1 = (PLFLT)(val1);
14012  ecode2 = SWIG_AsVal_double(obj1, &val2);
14013  if (!SWIG_IsOK(ecode2)) {
14014  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14015  }
14016  arg2 = (PLFLT)(val2);
14017  ecode3 = SWIG_AsVal_double(obj2, &val3);
14018  if (!SWIG_IsOK(ecode3)) {
14019  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14020  }
14021  arg3 = (PLFLT)(val3);
14022  ecode4 = SWIG_AsVal_double(obj3, &val4);
14023  if (!SWIG_IsOK(ecode4)) {
14024  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14025  }
14026  arg4 = (PLFLT)(val4);
14027  plwind(arg1,arg2,arg3,arg4);
14028  resultobj = SWIG_Py_Void();
14029  return resultobj;
14030 fail:
14031  return NULL;
14032 }
14033 
14034 
14035 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14036  PyObject *resultobj = 0;
14037  PLBOOL arg1 ;
14038  PLBOOL *arg2 = (PLBOOL *) 0 ;
14039  int val1 ;
14040  int ecode1 = 0 ;
14041  PLBOOL temp2 ;
14042  int res2 = SWIG_TMPOBJ ;
14043  PyObject * obj0 = 0 ;
14044 
14045  arg2 = &temp2;
14046  if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14047  ecode1 = SWIG_AsVal_int(obj0, &val1);
14048  if (!SWIG_IsOK(ecode1)) {
14049  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14050  }
14051  arg1 = (PLBOOL)(val1);
14052  plxormod(arg1,arg2);
14053  resultobj = SWIG_Py_Void();
14054  if (SWIG_IsTmpObj(res2)) {
14055  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14056  } else {
14057  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14058  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14059  }
14060  return resultobj;
14061 fail:
14062  return NULL;
14063 }
14064 
14065 
14066 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14067  PyObject *resultobj = 0;
14068  mapform_func arg1 = (mapform_func) 0 ;
14069  char *arg2 = (char *) 0 ;
14070  PLFLT arg3 ;
14071  PLFLT arg4 ;
14072  PLFLT arg5 ;
14073  PLFLT arg6 ;
14074  int res2 ;
14075  char *buf2 = 0 ;
14076  int alloc2 = 0 ;
14077  double val3 ;
14078  int ecode3 = 0 ;
14079  double val4 ;
14080  int ecode4 = 0 ;
14081  double val5 ;
14082  int ecode5 = 0 ;
14083  double val6 ;
14084  int ecode6 = 0 ;
14085  PyObject * obj0 = 0 ;
14086  PyObject * obj1 = 0 ;
14087  PyObject * obj2 = 0 ;
14088  PyObject * obj3 = 0 ;
14089  PyObject * obj4 = 0 ;
14090  PyObject * obj5 = 0 ;
14091 
14092  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14093  {
14094  // it must be a callable or none
14095  if ( obj0 == Py_None )
14096  {
14097  arg1 = NULL;
14098  }
14099  else
14100  {
14101  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14102  {
14103  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14104  return NULL;
14105  }
14106  arg1 = marshal_mapform( obj0 );
14107  }
14108  }
14109  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14110  if (!SWIG_IsOK(res2)) {
14111  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14112  }
14113  arg2 = (char *)(buf2);
14114  ecode3 = SWIG_AsVal_double(obj2, &val3);
14115  if (!SWIG_IsOK(ecode3)) {
14116  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14117  }
14118  arg3 = (PLFLT)(val3);
14119  ecode4 = SWIG_AsVal_double(obj3, &val4);
14120  if (!SWIG_IsOK(ecode4)) {
14121  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14122  }
14123  arg4 = (PLFLT)(val4);
14124  ecode5 = SWIG_AsVal_double(obj4, &val5);
14125  if (!SWIG_IsOK(ecode5)) {
14126  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14127  }
14128  arg5 = (PLFLT)(val5);
14129  ecode6 = SWIG_AsVal_double(obj5, &val6);
14130  if (!SWIG_IsOK(ecode6)) {
14131  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14132  }
14133  arg6 = (PLFLT)(val6);
14134  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14135  resultobj = SWIG_Py_Void();
14136  {
14137  cleanup_mapform();
14138  }
14139  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14140  return resultobj;
14141 fail:
14142  {
14143  cleanup_mapform();
14144  }
14145  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14146  return NULL;
14147 }
14148 
14149 
14150 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14151  PyObject *resultobj = 0;
14152  mapform_func arg1 = (mapform_func) 0 ;
14153  char *arg2 = (char *) 0 ;
14154  PLFLT arg3 ;
14155  PLFLT arg4 ;
14156  PLFLT arg5 ;
14157  PLFLT arg6 ;
14158  PLINT *arg7 = (PLINT *) 0 ;
14159  PLINT arg8 ;
14160  int res2 ;
14161  char *buf2 = 0 ;
14162  int alloc2 = 0 ;
14163  double val3 ;
14164  int ecode3 = 0 ;
14165  double val4 ;
14166  int ecode4 = 0 ;
14167  double val5 ;
14168  int ecode5 = 0 ;
14169  double val6 ;
14170  int ecode6 = 0 ;
14171  PyArrayObject *tmp7 = NULL ;
14172  PyObject * obj0 = 0 ;
14173  PyObject * obj1 = 0 ;
14174  PyObject * obj2 = 0 ;
14175  PyObject * obj3 = 0 ;
14176  PyObject * obj4 = 0 ;
14177  PyObject * obj5 = 0 ;
14178  PyObject * obj6 = 0 ;
14179 
14180  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapline",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14181  {
14182  // it must be a callable or none
14183  if ( obj0 == Py_None )
14184  {
14185  arg1 = NULL;
14186  }
14187  else
14188  {
14189  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14190  {
14191  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14192  return NULL;
14193  }
14194  arg1 = marshal_mapform( obj0 );
14195  }
14196  }
14197  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14198  if (!SWIG_IsOK(res2)) {
14199  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14200  }
14201  arg2 = (char *)(buf2);
14202  ecode3 = SWIG_AsVal_double(obj2, &val3);
14203  if (!SWIG_IsOK(ecode3)) {
14204  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14205  }
14206  arg3 = (PLFLT)(val3);
14207  ecode4 = SWIG_AsVal_double(obj3, &val4);
14208  if (!SWIG_IsOK(ecode4)) {
14209  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14210  }
14211  arg4 = (PLFLT)(val4);
14212  ecode5 = SWIG_AsVal_double(obj4, &val5);
14213  if (!SWIG_IsOK(ecode5)) {
14214  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14215  }
14216  arg5 = (PLFLT)(val5);
14217  ecode6 = SWIG_AsVal_double(obj5, &val6);
14218  if (!SWIG_IsOK(ecode6)) {
14219  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14220  }
14221  arg6 = (PLFLT)(val6);
14222  {
14223  if ( obj6 != Py_None )
14224  {
14225  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14226  if ( tmp7 == NULL )
14227  return NULL;
14228  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14229  arg8 = PyArray_DIMS( tmp7 )[0];
14230  }
14231  else
14232  {
14233  arg7 = NULL;
14234  arg8 = 0;
14235  }
14236  }
14237  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14238  resultobj = SWIG_Py_Void();
14239  {
14240  cleanup_mapform();
14241  }
14242  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14243  {
14244  Py_CLEAR( tmp7 );
14245  }
14246  return resultobj;
14247 fail:
14248  {
14249  cleanup_mapform();
14250  }
14251  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14252  {
14253  Py_CLEAR( tmp7 );
14254  }
14255  return NULL;
14256 }
14257 
14258 
14259 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14260  PyObject *resultobj = 0;
14261  mapform_func arg1 = (mapform_func) 0 ;
14262  char *arg2 = (char *) 0 ;
14263  char *arg3 = (char *) 0 ;
14264  PLFLT arg4 ;
14265  PLFLT arg5 ;
14266  PLFLT arg6 ;
14267  PLFLT arg7 ;
14268  PLINT *arg8 = (PLINT *) 0 ;
14269  PLINT arg9 ;
14270  int res2 ;
14271  char *buf2 = 0 ;
14272  int alloc2 = 0 ;
14273  int res3 ;
14274  char *buf3 = 0 ;
14275  int alloc3 = 0 ;
14276  double val4 ;
14277  int ecode4 = 0 ;
14278  double val5 ;
14279  int ecode5 = 0 ;
14280  double val6 ;
14281  int ecode6 = 0 ;
14282  double val7 ;
14283  int ecode7 = 0 ;
14284  PyArrayObject *tmp8 = NULL ;
14285  PyObject * obj0 = 0 ;
14286  PyObject * obj1 = 0 ;
14287  PyObject * obj2 = 0 ;
14288  PyObject * obj3 = 0 ;
14289  PyObject * obj4 = 0 ;
14290  PyObject * obj5 = 0 ;
14291  PyObject * obj6 = 0 ;
14292  PyObject * obj7 = 0 ;
14293 
14294  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plmapstring",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
14295  {
14296  // it must be a callable or none
14297  if ( obj0 == Py_None )
14298  {
14299  arg1 = NULL;
14300  }
14301  else
14302  {
14303  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14304  {
14305  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14306  return NULL;
14307  }
14308  arg1 = marshal_mapform( obj0 );
14309  }
14310  }
14311  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14312  if (!SWIG_IsOK(res2)) {
14313  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14314  }
14315  arg2 = (char *)(buf2);
14316  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
14317  if (!SWIG_IsOK(res3)) {
14318  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14319  }
14320  arg3 = (char *)(buf3);
14321  ecode4 = SWIG_AsVal_double(obj3, &val4);
14322  if (!SWIG_IsOK(ecode4)) {
14323  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14324  }
14325  arg4 = (PLFLT)(val4);
14326  ecode5 = SWIG_AsVal_double(obj4, &val5);
14327  if (!SWIG_IsOK(ecode5)) {
14328  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14329  }
14330  arg5 = (PLFLT)(val5);
14331  ecode6 = SWIG_AsVal_double(obj5, &val6);
14332  if (!SWIG_IsOK(ecode6)) {
14333  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14334  }
14335  arg6 = (PLFLT)(val6);
14336  ecode7 = SWIG_AsVal_double(obj6, &val7);
14337  if (!SWIG_IsOK(ecode7)) {
14338  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14339  }
14340  arg7 = (PLFLT)(val7);
14341  {
14342  if ( obj7 != Py_None )
14343  {
14344  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
14345  if ( tmp8 == NULL )
14346  return NULL;
14347  arg8 = (PLINT *) PyArray_DATA( tmp8 );
14348  arg9 = PyArray_DIMS( tmp8 )[0];
14349  }
14350  else
14351  {
14352  arg8 = NULL;
14353  arg9 = 0;
14354  }
14355  }
14356  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14357  resultobj = SWIG_Py_Void();
14358  {
14359  cleanup_mapform();
14360  }
14361  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14362  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14363  {
14364  Py_CLEAR( tmp8 );
14365  }
14366  return resultobj;
14367 fail:
14368  {
14369  cleanup_mapform();
14370  }
14371  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14372  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14373  {
14374  Py_CLEAR( tmp8 );
14375  }
14376  return NULL;
14377 }
14378 
14379 
14380 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14381  PyObject *resultobj = 0;
14382  mapform_func arg1 = (mapform_func) 0 ;
14383  char *arg2 = (char *) 0 ;
14384  PLFLT arg3 ;
14385  PLFLT arg4 ;
14386  PLFLT arg5 ;
14387  char *arg6 = (char *) 0 ;
14388  PLFLT arg7 ;
14389  PLFLT arg8 ;
14390  PLFLT arg9 ;
14391  PLFLT arg10 ;
14392  PLINT arg11 ;
14393  int res2 ;
14394  char *buf2 = 0 ;
14395  int alloc2 = 0 ;
14396  double val3 ;
14397  int ecode3 = 0 ;
14398  double val4 ;
14399  int ecode4 = 0 ;
14400  double val5 ;
14401  int ecode5 = 0 ;
14402  int res6 ;
14403  char *buf6 = 0 ;
14404  int alloc6 = 0 ;
14405  double val7 ;
14406  int ecode7 = 0 ;
14407  double val8 ;
14408  int ecode8 = 0 ;
14409  double val9 ;
14410  int ecode9 = 0 ;
14411  double val10 ;
14412  int ecode10 = 0 ;
14413  int val11 ;
14414  int ecode11 = 0 ;
14415  PyObject * obj0 = 0 ;
14416  PyObject * obj1 = 0 ;
14417  PyObject * obj2 = 0 ;
14418  PyObject * obj3 = 0 ;
14419  PyObject * obj4 = 0 ;
14420  PyObject * obj5 = 0 ;
14421  PyObject * obj6 = 0 ;
14422  PyObject * obj7 = 0 ;
14423  PyObject * obj8 = 0 ;
14424  PyObject * obj9 = 0 ;
14425  PyObject * obj10 = 0 ;
14426 
14427  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plmaptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14428  {
14429  // it must be a callable or none
14430  if ( obj0 == Py_None )
14431  {
14432  arg1 = NULL;
14433  }
14434  else
14435  {
14436  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14437  {
14438  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14439  return NULL;
14440  }
14441  arg1 = marshal_mapform( obj0 );
14442  }
14443  }
14444  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14445  if (!SWIG_IsOK(res2)) {
14446  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14447  }
14448  arg2 = (char *)(buf2);
14449  ecode3 = SWIG_AsVal_double(obj2, &val3);
14450  if (!SWIG_IsOK(ecode3)) {
14451  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14452  }
14453  arg3 = (PLFLT)(val3);
14454  ecode4 = SWIG_AsVal_double(obj3, &val4);
14455  if (!SWIG_IsOK(ecode4)) {
14456  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14457  }
14458  arg4 = (PLFLT)(val4);
14459  ecode5 = SWIG_AsVal_double(obj4, &val5);
14460  if (!SWIG_IsOK(ecode5)) {
14461  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14462  }
14463  arg5 = (PLFLT)(val5);
14464  res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
14465  if (!SWIG_IsOK(res6)) {
14466  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14467  }
14468  arg6 = (char *)(buf6);
14469  ecode7 = SWIG_AsVal_double(obj6, &val7);
14470  if (!SWIG_IsOK(ecode7)) {
14471  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14472  }
14473  arg7 = (PLFLT)(val7);
14474  ecode8 = SWIG_AsVal_double(obj7, &val8);
14475  if (!SWIG_IsOK(ecode8)) {
14476  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14477  }
14478  arg8 = (PLFLT)(val8);
14479  ecode9 = SWIG_AsVal_double(obj8, &val9);
14480  if (!SWIG_IsOK(ecode9)) {
14481  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14482  }
14483  arg9 = (PLFLT)(val9);
14484  ecode10 = SWIG_AsVal_double(obj9, &val10);
14485  if (!SWIG_IsOK(ecode10)) {
14486  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14487  }
14488  arg10 = (PLFLT)(val10);
14489  ecode11 = SWIG_AsVal_int(obj10, &val11);
14490  if (!SWIG_IsOK(ecode11)) {
14491  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14492  }
14493  arg11 = (PLINT)(val11);
14494  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14495  resultobj = SWIG_Py_Void();
14496  {
14497  cleanup_mapform();
14498  }
14499  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14500  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14501  return resultobj;
14502 fail:
14503  {
14504  cleanup_mapform();
14505  }
14506  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14507  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14508  return NULL;
14509 }
14510 
14511 
14512 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14513  PyObject *resultobj = 0;
14514  mapform_func arg1 = (mapform_func) 0 ;
14515  char *arg2 = (char *) 0 ;
14516  PLFLT arg3 ;
14517  PLFLT arg4 ;
14518  PLFLT arg5 ;
14519  PLFLT arg6 ;
14520  PLINT *arg7 = (PLINT *) 0 ;
14521  PLINT arg8 ;
14522  int res2 ;
14523  char *buf2 = 0 ;
14524  int alloc2 = 0 ;
14525  double val3 ;
14526  int ecode3 = 0 ;
14527  double val4 ;
14528  int ecode4 = 0 ;
14529  double val5 ;
14530  int ecode5 = 0 ;
14531  double val6 ;
14532  int ecode6 = 0 ;
14533  PyArrayObject *tmp7 = NULL ;
14534  PyObject * obj0 = 0 ;
14535  PyObject * obj1 = 0 ;
14536  PyObject * obj2 = 0 ;
14537  PyObject * obj3 = 0 ;
14538  PyObject * obj4 = 0 ;
14539  PyObject * obj5 = 0 ;
14540  PyObject * obj6 = 0 ;
14541 
14542  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmapfill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14543  {
14544  // it must be a callable or none
14545  if ( obj0 == Py_None )
14546  {
14547  arg1 = NULL;
14548  }
14549  else
14550  {
14551  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14552  {
14553  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14554  return NULL;
14555  }
14556  arg1 = marshal_mapform( obj0 );
14557  }
14558  }
14559  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14560  if (!SWIG_IsOK(res2)) {
14561  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14562  }
14563  arg2 = (char *)(buf2);
14564  ecode3 = SWIG_AsVal_double(obj2, &val3);
14565  if (!SWIG_IsOK(ecode3)) {
14566  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14567  }
14568  arg3 = (PLFLT)(val3);
14569  ecode4 = SWIG_AsVal_double(obj3, &val4);
14570  if (!SWIG_IsOK(ecode4)) {
14571  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14572  }
14573  arg4 = (PLFLT)(val4);
14574  ecode5 = SWIG_AsVal_double(obj4, &val5);
14575  if (!SWIG_IsOK(ecode5)) {
14576  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14577  }
14578  arg5 = (PLFLT)(val5);
14579  ecode6 = SWIG_AsVal_double(obj5, &val6);
14580  if (!SWIG_IsOK(ecode6)) {
14581  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14582  }
14583  arg6 = (PLFLT)(val6);
14584  {
14585  if ( obj6 != Py_None )
14586  {
14587  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
14588  if ( tmp7 == NULL )
14589  return NULL;
14590  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14591  arg8 = PyArray_DIMS( tmp7 )[0];
14592  }
14593  else
14594  {
14595  arg7 = NULL;
14596  arg8 = 0;
14597  }
14598  }
14599  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14600  resultobj = SWIG_Py_Void();
14601  {
14602  cleanup_mapform();
14603  }
14604  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14605  {
14606  Py_CLEAR( tmp7 );
14607  }
14608  return resultobj;
14609 fail:
14610  {
14611  cleanup_mapform();
14612  }
14613  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14614  {
14615  Py_CLEAR( tmp7 );
14616  }
14617  return NULL;
14618 }
14619 
14620 
14621 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14622  PyObject *resultobj = 0;
14623  mapform_func arg1 = (mapform_func) 0 ;
14624  PLFLT arg2 ;
14625  PLFLT arg3 ;
14626  PLFLT arg4 ;
14627  PLFLT arg5 ;
14628  PLFLT arg6 ;
14629  PLFLT arg7 ;
14630  double val2 ;
14631  int ecode2 = 0 ;
14632  double val3 ;
14633  int ecode3 = 0 ;
14634  double val4 ;
14635  int ecode4 = 0 ;
14636  double val5 ;
14637  int ecode5 = 0 ;
14638  double val6 ;
14639  int ecode6 = 0 ;
14640  double val7 ;
14641  int ecode7 = 0 ;
14642  PyObject * obj0 = 0 ;
14643  PyObject * obj1 = 0 ;
14644  PyObject * obj2 = 0 ;
14645  PyObject * obj3 = 0 ;
14646  PyObject * obj4 = 0 ;
14647  PyObject * obj5 = 0 ;
14648  PyObject * obj6 = 0 ;
14649 
14650  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14651  {
14652  // it must be a callable or none
14653  if ( obj0 == Py_None )
14654  {
14655  arg1 = NULL;
14656  }
14657  else
14658  {
14659  if ( !PyCallable_Check( (PyObject *) obj0 ) )
14660  {
14661  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14662  return NULL;
14663  }
14664  arg1 = marshal_mapform( obj0 );
14665  }
14666  }
14667  ecode2 = SWIG_AsVal_double(obj1, &val2);
14668  if (!SWIG_IsOK(ecode2)) {
14669  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14670  }
14671  arg2 = (PLFLT)(val2);
14672  ecode3 = SWIG_AsVal_double(obj2, &val3);
14673  if (!SWIG_IsOK(ecode3)) {
14674  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14675  }
14676  arg3 = (PLFLT)(val3);
14677  ecode4 = SWIG_AsVal_double(obj3, &val4);
14678  if (!SWIG_IsOK(ecode4)) {
14679  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14680  }
14681  arg4 = (PLFLT)(val4);
14682  ecode5 = SWIG_AsVal_double(obj4, &val5);
14683  if (!SWIG_IsOK(ecode5)) {
14684  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14685  }
14686  arg5 = (PLFLT)(val5);
14687  ecode6 = SWIG_AsVal_double(obj5, &val6);
14688  if (!SWIG_IsOK(ecode6)) {
14689  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14690  }
14691  arg6 = (PLFLT)(val6);
14692  ecode7 = SWIG_AsVal_double(obj6, &val7);
14693  if (!SWIG_IsOK(ecode7)) {
14694  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14695  }
14696  arg7 = (PLFLT)(val7);
14697  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14698  resultobj = SWIG_Py_Void();
14699  {
14700  cleanup_mapform();
14701  }
14702  return resultobj;
14703 fail:
14704  {
14705  cleanup_mapform();
14706  }
14707  return NULL;
14708 }
14709 
14710 
14711 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14712  PyObject *resultobj = 0;
14713  PLFLT **arg1 = (PLFLT **) 0 ;
14714  PLINT arg2 ;
14715  PLINT arg3 ;
14716  PLFLT arg4 ;
14717  PLFLT arg5 ;
14718  PLFLT arg6 ;
14719  PLFLT arg7 ;
14720  PLFLT arg8 ;
14721  PLFLT arg9 ;
14722  PLFLT arg10 ;
14723  PLFLT arg11 ;
14724  PLFLT arg12 ;
14725  PLFLT arg13 ;
14726  PyArrayObject *tmp1 = NULL ;
14727  double val4 ;
14728  int ecode4 = 0 ;
14729  double val5 ;
14730  int ecode5 = 0 ;
14731  double val6 ;
14732  int ecode6 = 0 ;
14733  double val7 ;
14734  int ecode7 = 0 ;
14735  double val8 ;
14736  int ecode8 = 0 ;
14737  double val9 ;
14738  int ecode9 = 0 ;
14739  double val10 ;
14740  int ecode10 = 0 ;
14741  double val11 ;
14742  int ecode11 = 0 ;
14743  double val12 ;
14744  int ecode12 = 0 ;
14745  double val13 ;
14746  int ecode13 = 0 ;
14747  PyObject * obj0 = 0 ;
14748  PyObject * obj1 = 0 ;
14749  PyObject * obj2 = 0 ;
14750  PyObject * obj3 = 0 ;
14751  PyObject * obj4 = 0 ;
14752  PyObject * obj5 = 0 ;
14753  PyObject * obj6 = 0 ;
14754  PyObject * obj7 = 0 ;
14755  PyObject * obj8 = 0 ;
14756  PyObject * obj9 = 0 ;
14757  PyObject * obj10 = 0 ;
14758 
14759  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14760  {
14761  int i, size;
14762  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14763  if ( tmp1 == NULL )
14764  return NULL;
14765  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14766  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14767  size = arg3;
14768  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14769  for ( i = 0; i < arg2; i++ )
14770  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14771  }
14772  ecode4 = SWIG_AsVal_double(obj1, &val4);
14773  if (!SWIG_IsOK(ecode4)) {
14774  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14775  }
14776  arg4 = (PLFLT)(val4);
14777  ecode5 = SWIG_AsVal_double(obj2, &val5);
14778  if (!SWIG_IsOK(ecode5)) {
14779  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14780  }
14781  arg5 = (PLFLT)(val5);
14782  ecode6 = SWIG_AsVal_double(obj3, &val6);
14783  if (!SWIG_IsOK(ecode6)) {
14784  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14785  }
14786  arg6 = (PLFLT)(val6);
14787  ecode7 = SWIG_AsVal_double(obj4, &val7);
14788  if (!SWIG_IsOK(ecode7)) {
14789  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14790  }
14791  arg7 = (PLFLT)(val7);
14792  ecode8 = SWIG_AsVal_double(obj5, &val8);
14793  if (!SWIG_IsOK(ecode8)) {
14794  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14795  }
14796  arg8 = (PLFLT)(val8);
14797  ecode9 = SWIG_AsVal_double(obj6, &val9);
14798  if (!SWIG_IsOK(ecode9)) {
14799  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14800  }
14801  arg9 = (PLFLT)(val9);
14802  ecode10 = SWIG_AsVal_double(obj7, &val10);
14803  if (!SWIG_IsOK(ecode10)) {
14804  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14805  }
14806  arg10 = (PLFLT)(val10);
14807  ecode11 = SWIG_AsVal_double(obj8, &val11);
14808  if (!SWIG_IsOK(ecode11)) {
14809  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14810  }
14811  arg11 = (PLFLT)(val11);
14812  ecode12 = SWIG_AsVal_double(obj9, &val12);
14813  if (!SWIG_IsOK(ecode12)) {
14814  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14815  }
14816  arg12 = (PLFLT)(val12);
14817  ecode13 = SWIG_AsVal_double(obj10, &val13);
14818  if (!SWIG_IsOK(ecode13)) {
14819  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14820  }
14821  arg13 = (PLFLT)(val13);
14822  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14823  resultobj = SWIG_Py_Void();
14824  {
14825  Py_CLEAR( tmp1 );
14826  free( arg1 );
14827  }
14828  return resultobj;
14829 fail:
14830  {
14831  Py_CLEAR( tmp1 );
14832  free( arg1 );
14833  }
14834  return NULL;
14835 }
14836 
14837 
14838 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14839  PyObject *resultobj = 0;
14840  PLFLT **arg1 = (PLFLT **) 0 ;
14841  PLINT arg2 ;
14842  PLINT arg3 ;
14843  PLFLT arg4 ;
14844  PLFLT arg5 ;
14845  PLFLT arg6 ;
14846  PLFLT arg7 ;
14847  PLFLT arg8 ;
14848  PLFLT arg9 ;
14849  PLFLT arg10 ;
14850  PLFLT arg11 ;
14851  pltr_func arg12 = (pltr_func) 0 ;
14852  PLPointer arg13 = (PLPointer) 0 ;
14853  PyArrayObject *tmp1 = NULL ;
14854  double val4 ;
14855  int ecode4 = 0 ;
14856  double val5 ;
14857  int ecode5 = 0 ;
14858  double val6 ;
14859  int ecode6 = 0 ;
14860  double val7 ;
14861  int ecode7 = 0 ;
14862  double val8 ;
14863  int ecode8 = 0 ;
14864  double val9 ;
14865  int ecode9 = 0 ;
14866  double val10 ;
14867  int ecode10 = 0 ;
14868  double val11 ;
14869  int ecode11 = 0 ;
14870  PyObject * obj0 = 0 ;
14871  PyObject * obj1 = 0 ;
14872  PyObject * obj2 = 0 ;
14873  PyObject * obj3 = 0 ;
14874  PyObject * obj4 = 0 ;
14875  PyObject * obj5 = 0 ;
14876  PyObject * obj6 = 0 ;
14877  PyObject * obj7 = 0 ;
14878  PyObject * obj8 = 0 ;
14879  PyObject * obj9 = 0 ;
14880  PyObject * obj10 = 0 ;
14881 
14882  {
14883  python_pltr = 0;
14884  arg12 = NULL;
14885  }
14886  {
14887  arg13 = NULL;
14888  }
14889  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14890  {
14891  int i, size;
14892  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14893  if ( tmp1 == NULL )
14894  return NULL;
14895  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14896  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14897  size = arg3;
14898  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14899  for ( i = 0; i < arg2; i++ )
14900  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14901  }
14902  ecode4 = SWIG_AsVal_double(obj1, &val4);
14903  if (!SWIG_IsOK(ecode4)) {
14904  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14905  }
14906  arg4 = (PLFLT)(val4);
14907  ecode5 = SWIG_AsVal_double(obj2, &val5);
14908  if (!SWIG_IsOK(ecode5)) {
14909  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14910  }
14911  arg5 = (PLFLT)(val5);
14912  ecode6 = SWIG_AsVal_double(obj3, &val6);
14913  if (!SWIG_IsOK(ecode6)) {
14914  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14915  }
14916  arg6 = (PLFLT)(val6);
14917  ecode7 = SWIG_AsVal_double(obj4, &val7);
14918  if (!SWIG_IsOK(ecode7)) {
14919  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14920  }
14921  arg7 = (PLFLT)(val7);
14922  ecode8 = SWIG_AsVal_double(obj5, &val8);
14923  if (!SWIG_IsOK(ecode8)) {
14924  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14925  }
14926  arg8 = (PLFLT)(val8);
14927  ecode9 = SWIG_AsVal_double(obj6, &val9);
14928  if (!SWIG_IsOK(ecode9)) {
14929  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14930  }
14931  arg9 = (PLFLT)(val9);
14932  ecode10 = SWIG_AsVal_double(obj7, &val10);
14933  if (!SWIG_IsOK(ecode10)) {
14934  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14935  }
14936  arg10 = (PLFLT)(val10);
14937  ecode11 = SWIG_AsVal_double(obj8, &val11);
14938  if (!SWIG_IsOK(ecode11)) {
14939  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14940  }
14941  arg11 = (PLFLT)(val11);
14942  if (obj9) {
14943  {
14944  // it must be a callable or None
14945  if ( obj9 == Py_None )
14946  {
14947  arg12 = NULL;
14948  }
14949  else
14950  {
14951  if ( !PyCallable_Check( (PyObject *) obj9 ) )
14952  {
14953  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14954  return NULL;
14955  }
14956  arg12 = marshal_pltr( obj9 );
14957  }
14958  }
14959  }
14960  if (obj10) {
14961  {
14962  if ( obj10 == Py_None )
14963  arg13 = NULL;
14964  else
14965  {
14966  arg13 = marshal_PLPointer( obj10, 1 );
14967  }
14968  }
14969  }
14970  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14971  resultobj = SWIG_Py_Void();
14972  {
14973  Py_CLEAR( tmp1 );
14974  free( arg1 );
14975  }
14976  {
14977  cleanup_pltr();
14978  }
14979  {
14981  }
14982  return resultobj;
14983 fail:
14984  {
14985  Py_CLEAR( tmp1 );
14986  free( arg1 );
14987  }
14988  {
14989  cleanup_pltr();
14990  }
14991  {
14993  }
14994  return NULL;
14995 }
14996 
14997 
14998 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14999  PyObject *resultobj = 0;
15000 
15001  if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
15002  plClearOpts();
15003  resultobj = SWIG_Py_Void();
15004  return resultobj;
15005 fail:
15006  return NULL;
15007 }
15008 
15009 
15010 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15011  PyObject *resultobj = 0;
15012 
15013  if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
15014  plResetOpts();
15015  resultobj = SWIG_Py_Void();
15016  return resultobj;
15017 fail:
15018  return NULL;
15019 }
15020 
15021 
15022 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15023  PyObject *resultobj = 0;
15024  char *arg1 = (char *) 0 ;
15025  char *arg2 = (char *) 0 ;
15026  int res1 ;
15027  char *buf1 = 0 ;
15028  int alloc1 = 0 ;
15029  int res2 ;
15030  char *buf2 = 0 ;
15031  int alloc2 = 0 ;
15032  PyObject * obj0 = 0 ;
15033  PyObject * obj1 = 0 ;
15034 
15035  if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
15036  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
15037  if (!SWIG_IsOK(res1)) {
15038  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15039  }
15040  arg1 = (char *)(buf1);
15041  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15042  if (!SWIG_IsOK(res2)) {
15043  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15044  }
15045  arg2 = (char *)(buf2);
15046  plSetUsage((char const *)arg1,(char const *)arg2);
15047  resultobj = SWIG_Py_Void();
15048  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15049  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15050  return resultobj;
15051 fail:
15052  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15053  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15054  return NULL;
15055 }
15056 
15057 
15058 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059  PyObject *resultobj = 0;
15060 
15061  if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
15062  plOptUsage();
15063  resultobj = SWIG_Py_Void();
15064  return resultobj;
15065 fail:
15066  return NULL;
15067 }
15068 
15069 
15070 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15071  PyObject *resultobj = 0;
15072  PLFLT **arg1 = (PLFLT **) 0 ;
15073  PLINT arg2 ;
15074  PLINT arg3 ;
15075  PLFLT *arg4 = (PLFLT *) 0 ;
15076  PLFLT *arg5 = (PLFLT *) 0 ;
15077  PyArrayObject *tmp1 = NULL ;
15078  PLFLT temp4 ;
15079  int res4 = SWIG_TMPOBJ ;
15080  PLFLT temp5 ;
15081  int res5 = SWIG_TMPOBJ ;
15082  PyObject * obj0 = 0 ;
15083 
15084  arg4 = &temp4;
15085  arg5 = &temp5;
15086  if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
15087  {
15088  int i, size;
15089  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
15090  if ( tmp1 == NULL )
15091  return NULL;
15092  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15093  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15094  size = arg3;
15095  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15096  for ( i = 0; i < arg2; i++ )
15097  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15098  }
15099  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15100  resultobj = SWIG_Py_Void();
15101  if (SWIG_IsTmpObj(res4)) {
15102  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15103  } else {
15104  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15105  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15106  }
15107  if (SWIG_IsTmpObj(res5)) {
15108  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15109  } else {
15110  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15111  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15112  }
15113  {
15114  Py_CLEAR( tmp1 );
15115  free( arg1 );
15116  }
15117  return resultobj;
15118 fail:
15119  {
15120  Py_CLEAR( tmp1 );
15121  free( arg1 );
15122  }
15123  return NULL;
15124 }
15125 
15126 
15127 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128  PyObject *resultobj = 0;
15129  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15130  void *argp1 = 0 ;
15131  int res1 = 0 ;
15132  PyObject * obj0 = 0 ;
15133  PLINT result;
15134 
15135  if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
15136  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15137  if (!SWIG_IsOK(res1)) {
15138  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15139  }
15140  arg1 = (PLGraphicsIn *)(argp1);
15141  result = (PLINT)plGetCursor(arg1);
15142  resultobj = SWIG_From_int((int)(result));
15143  return resultobj;
15144 fail:
15145  return NULL;
15146 }
15147 
15148 
15149 static PyMethodDef SwigMethods[] = {
15150  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
15151  { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15152  { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15153  { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15154  { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15155  { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
15156  { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15157  { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
15158  { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15159  { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
15160  { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15161  { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
15162  { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15163  { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
15164  { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15165  { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
15166  { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15167  { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
15168  { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15169  { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
15170  { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15171  { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
15172  { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15173  { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
15174  { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15175  { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
15176  { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15177  { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
15178  { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
15179  { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
15180  { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
15181  { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
15182  { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
15183  "Set format of numerical label for contours\n"
15184  "\n"
15185  "DESCRIPTION:\n"
15186  "\n"
15187  " Set format of numerical label for contours. \n"
15188  "\n"
15189  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15190  "\n"
15191  " This function is used example 9. \n"
15192  "\n"
15193  "\n"
15194  "\n"
15195  "SYNOPSIS:\n"
15196  "\n"
15197  "pl_setcontlabelformat(lexp, sigdig)\n"
15198  "\n"
15199  "ARGUMENTS:\n"
15200  "\n"
15201  " lexp (PLINT, input) : If the contour numerical label is greater\n"
15202  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15203  " format is used. Default value of lexp is 4. \n"
15204  "\n"
15205  " sigdig (PLINT, input) : Number of significant digits. Default\n"
15206  " value is 2. \n"
15207  "\n"
15208  ""},
15209  { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
15210  "Set parameters of contour labelling other than format of numerical label\n"
15211  "\n"
15212  "DESCRIPTION:\n"
15213  "\n"
15214  " Set parameters of contour labelling other than those handled by\n"
15215  " pl_setcontlabelformat. \n"
15216  "\n"
15217  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15218  "\n"
15219  " This function is used in example 9. \n"
15220  "\n"
15221  "\n"
15222  "\n"
15223  "SYNOPSIS:\n"
15224  "\n"
15225  "pl_setcontlabelparam(offset, size, spacing, active)\n"
15226  "\n"
15227  "ARGUMENTS:\n"
15228  "\n"
15229  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15230  " to 0.0, labels are printed on the lines). Default value is 0.006. \n"
15231  "\n"
15232  " size (PLFLT, input) : Font height for contour labels (normalized). \n"
15233  " Default value is 0.3. \n"
15234  "\n"
15235  " spacing (PLFLT, input) : Spacing parameter for contour labels. \n"
15236  " Default value is 0.1. \n"
15237  "\n"
15238  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15239  " contour labels on. Default is off (0). \n"
15240  "\n"
15241  ""},
15242  { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
15243  "Advance the (sub-)page\n"
15244  "\n"
15245  "DESCRIPTION:\n"
15246  "\n"
15247  " Advances to the next subpage if sub=0, performing a page advance if\n"
15248  " there are no remaining subpages on the current page. If subpages\n"
15249  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15250  " PLplot switches to the specified subpage. Note that this allows you\n"
15251  " to overwrite a plot on the specified subpage; if this is not what you\n"
15252  " intended, use pleop followed by plbop to first advance the page. This\n"
15253  " routine is called automatically (with page=0) by plenv, but if plenv\n"
15254  " is not used, pladv must be called after initializing PLplot but before\n"
15255  " defining the viewport. \n"
15256  "\n"
15257  " Redacted form: pladv(page)\n"
15258  "\n"
15259  " This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
15260  "\n"
15261  "\n"
15262  "\n"
15263  "SYNOPSIS:\n"
15264  "\n"
15265  "pladv(page)\n"
15266  "\n"
15267  "ARGUMENTS:\n"
15268  "\n"
15269  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15270  " in the top left corner and increasing along the rows) to which to\n"
15271  " advance. Set to zero to advance to the next subpage (or to the\n"
15272  " next page if subpages are not being used). \n"
15273  "\n"
15274  ""},
15275  { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
15276  "Draw a circular or elliptical arc \n"
15277  "\n"
15278  "DESCRIPTION:\n"
15279  "\n"
15280  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15281  " semiminor axis b, starting at angle1 and ending at angle2. \n"
15282  "\n"
15283  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15284  " fill)\n"
15285  "\n"
15286  "\n"
15287  " This function is used in examples 3 and 27. \n"
15288  "\n"
15289  "\n"
15290  "\n"
15291  "SYNOPSIS:\n"
15292  "\n"
15293  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15294  "\n"
15295  "ARGUMENTS:\n"
15296  "\n"
15297  " x (PLFLT, input) : X coordinate of arc center. \n"
15298  "\n"
15299  " y (PLFLT, input) : Y coordinate of arc center. \n"
15300  "\n"
15301  " a (PLFLT, input) : Length of the semimajor axis of the arc. \n"
15302  "\n"
15303  " b (PLFLT, input) : Length of the semiminor axis of the arc. \n"
15304  "\n"
15305  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15306  " semimajor axis. \n"
15307  "\n"
15308  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15309  " semimajor axis. \n"
15310  "\n"
15311  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15312  " X-axis. \n"
15313  "\n"
15314  " fill (PLBOOL, input) : Draw a filled arc. \n"
15315  "\n"
15316  ""},
15317  { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
15318  "Draw a box with axes, etc. with arbitrary origin \n"
15319  "\n"
15320  "DESCRIPTION:\n"
15321  "\n"
15322  " Draws a box around the currently defined viewport with arbitrary\n"
15323  " world-coordinate origin specified by x0 and y0 and labels it with\n"
15324  " world coordinate values appropriate to the window. Thus plaxes should\n"
15325  " only be called after defining both viewport and window. The character\n"
15326  " strings xopt and yopt specify how the box should be drawn as described\n"
15327  " below. If ticks and/or subticks are to be drawn for a particular\n"
15328  " axis, the tick intervals and number of subintervals may be specified\n"
15329  " explicitly, or they may be defaulted by setting the appropriate\n"
15330  " arguments to zero. \n"
15331  "\n"
15332  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15333  " ytick, nysub)\n"
15334  " Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
15335  " yopt)\n"
15336  "\n"
15337  "\n"
15338  " This function is not used in any examples. \n"
15339  "\n"
15340  "\n"
15341  "\n"
15342  "SYNOPSIS:\n"
15343  "\n"
15344  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15345  "\n"
15346  "ARGUMENTS:\n"
15347  "\n"
15348  " x0 (PLFLT, input) : World X coordinate of origin. \n"
15349  "\n"
15350  " y0 (PLFLT, input) : World Y coordinate of origin. \n"
15351  "\n"
15352  " xopt (const char *, input) : Pointer to character string specifying\n"
15353  " options for horizontal axis. The string can include any\n"
15354  " combination of the following letters (upper or lower case) in any\n"
15355  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15356  " is vertical line (x=0). \n"
15357  " b: Draws bottom (X) or left (Y) edge of frame. \n"
15358  " c: Draws top (X) or right (Y) edge of frame. \n"
15359  " d: Plot labels as date / time. Values are assumed to be\n"
15360  " seconds since the epoch (as used by gmtime). \n"
15361  " f: Always use fixed point numeric labels. \n"
15362  " g: Draws a grid at the major tick interval. \n"
15363  " h: Draws a grid at the minor tick interval. \n"
15364  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15365  " inwards. \n"
15366  " l: Labels axis logarithmically. This only affects the labels,\n"
15367  " not the data, and so it is necessary to compute the logarithms\n"
15368  " of data points before passing them to any of the drawing\n"
15369  " routines. \n"
15370  " m: Writes numeric labels at major tick intervals in the\n"
15371  " unconventional location (above box for X, right of box for Y). \n"
15372  " n: Writes numeric labels at major tick intervals in the\n"
15373  " conventional location (below box for X, left of box for Y). \n"
15374  " o: Use custom labelling function to generate axis label text. \n"
15375  " The custom labelling function can be defined with the\n"
15376  " plslabelfunc command. \n"
15377  " s: Enables subticks between major ticks, only valid if t is\n"
15378  " also specified. \n"
15379  " t: Draws major ticks. \n"
15380  " u: Exactly like \"b\" except don't draw edge line. \n"
15381  " w: Exactly like \"c\" except don't draw edge line. \n"
15382  " x: Exactly like \"t\" (including the side effect of the\n"
15383  " numerical labels for the major ticks) except exclude drawing\n"
15384  " the major and minor tick marks. \n"
15385  "\n"
15386  "\n"
15387  " xtick (PLFLT, input) : World coordinate interval between major\n"
15388  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15389  " generates a suitable tick interval. \n"
15390  "\n"
15391  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15392  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15393  " generates a suitable minor tick interval. \n"
15394  "\n"
15395  " yopt (const char *, input) : Pointer to character string specifying\n"
15396  " options for vertical axis. The string can include any combination\n"
15397  " of the letters defined above for xopt, and in addition may\n"
15398  " contain: v: Write numeric labels for vertical axis parallel to the\n"
15399  " base of the graph, rather than parallel to the axis. \n"
15400  "\n"
15401  "\n"
15402  " ytick (PLFLT, input) : World coordinate interval between major\n"
15403  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15404  " generates a suitable tick interval. \n"
15405  "\n"
15406  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15407  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15408  " generates a suitable minor tick interval. \n"
15409  "\n"
15410  ""},
15411  { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
15412  "Plot a histogram from binned data \n"
15413  "\n"
15414  "DESCRIPTION:\n"
15415  "\n"
15416  " Plots a histogram consisting of nbin bins. The value associated with\n"
15417  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15418  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15419  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15420  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15421  " placed midway between the values in the x array. Also see plhist for\n"
15422  " drawing histograms from unbinned data. \n"
15423  "\n"
15424  " Redacted form: General: plbin(x, y, opt)\n"
15425  " Perl/PDL: plbin(nbin, x, y, opt)\n"
15426  " Python: plbin(nbin, x, y, opt)\n"
15427  "\n"
15428  "\n"
15429  " This function is not used in any examples. \n"
15430  "\n"
15431  "\n"
15432  "\n"
15433  "SYNOPSIS:\n"
15434  "\n"
15435  "plbin(nbin, x, y, opt)\n"
15436  "\n"
15437  "ARGUMENTS:\n"
15438  "\n"
15439  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15440  " and y arrays.) \n"
15441  "\n"
15442  " x (const PLFLT *, input) : Pointer to array containing values\n"
15443  " associated with bins. These must form a strictly increasing\n"
15444  " sequence. \n"
15445  "\n"
15446  " y (const PLFLT *, input) : Pointer to array containing number of\n"
15447  " points in bin. This is a PLFLT (instead of PLINT) array so as to\n"
15448  " allow histograms of probabilities, etc. \n"
15449  "\n"
15450  " opt (PLINT, input) : Is a combination of several flags:\n"
15451  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15452  " outer bins are expanded to fill up the entire x-axis and bins of\n"
15453  " zero height are simply drawn. \n"
15454  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15455  " between the x values. If the values in x are equally spaced,\n"
15456  " the values are the center values of the bins. \n"
15457  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15458  " size as the ones inside. \n"
15459  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15460  " (there is a gap for such bins). \n"
15461  "\n"
15462  ""},
15463  { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15464  "Calculate broken-down time from continuous time for the current stream \n"
15465  "\n"
15466  "DESCRIPTION:\n"
15467  "\n"
15468  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15469  " continuous time, ctime for the current stream. This function is the\n"
15470  " inverse of plctime. \n"
15471  "\n"
15472  " The PLplot definition of broken-down time is a calendar time that\n"
15473  " completely ignores all time zone offsets, i.e., it is the user's\n"
15474  " responsibility to apply those offsets (if so desired) before using the\n"
15475  " PLplot time API. By default broken-down time is defined using the\n"
15476  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15477  " continuous time is defined as the number of seconds since the Unix\n"
15478  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15479  " broken-down and continuous time are possible, see plconfigtime. \n"
15480  "\n"
15481  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15482  " ctime)\n"
15483  " Perl/PDL: Not available? \n"
15484  "\n"
15485  "\n"
15486  " This function is used in example 29. \n"
15487  "\n"
15488  "\n"
15489  "\n"
15490  "SYNOPSIS:\n"
15491  "\n"
15492  "plbtime(year, month, day, hour, min, sec, ctime)\n"
15493  "\n"
15494  "ARGUMENTS:\n"
15495  "\n"
15496  " year (PLINT *, output) : Output year. \n"
15497  "\n"
15498  " month (PLINT *, output) : Output month in range from 0 (January) to\n"
15499  " 11 (December). \n"
15500  "\n"
15501  " day (PLINT *, output) : Output day in range from 1 to 31. \n"
15502  "\n"
15503  " hour (PLINT *, output) : Output hour in range from 0 to 23. \n"
15504  "\n"
15505  " min (PLINT *, output) : Output minute in range from 0 to 59 \n"
15506  "\n"
15507  " sec (PLFLT *, output) : Output second in floating range from 0. to\n"
15508  " 60. \n"
15509  "\n"
15510  " ctime (PLFLT, input) : Continous time from which the broken-down\n"
15511  " time is calculated. \n"
15512  "\n"
15513  ""},
15514  { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15515  "Begin a new page\n"
15516  "\n"
15517  "DESCRIPTION:\n"
15518  "\n"
15519  " Begins a new page. For a file driver, the output file is opened if\n"
15520  " necessary. Advancing the page via pleop and plbop is useful when a\n"
15521  " page break is desired at a particular point when plotting to subpages.\n"
15522  " Another use for pleop and plbop is when plotting pages to different\n"
15523  " files, since you can manually set the file name by calling plsfnam\n"
15524  " after the call to pleop. (In fact some drivers may only support a\n"
15525  " single page per file, making this a necessity.) One way to handle\n"
15526  " this case automatically is to page advance via pladv, but enable\n"
15527  " familying (see plsfam) with a small limit on the file size so that a\n"
15528  " new family member file will be created on each page break. \n"
15529  "\n"
15530  " Redacted form: plbop()\n"
15531  "\n"
15532  " This function is used in examples 2,20. \n"
15533  "\n"
15534  "\n"
15535  "\n"
15536  "SYNOPSIS:\n"
15537  "\n"
15538  "plbop()\n"
15539  "\n"
15540  ""},
15541  { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15542  "Draw a box with axes, etc\n"
15543  "\n"
15544  "DESCRIPTION:\n"
15545  "\n"
15546  " Draws a box around the currently defined viewport, and labels it with\n"
15547  " world coordinate values appropriate to the window. Thus plbox should\n"
15548  " only be called after defining both viewport and window. The character\n"
15549  " strings xopt and yopt specify how the box should be drawn as described\n"
15550  " below. If ticks and/or subticks are to be drawn for a particular\n"
15551  " axis, the tick intervals and number of subintervals may be specified\n"
15552  " explicitly, or they may be defaulted by setting the appropriate\n"
15553  " arguments to zero. \n"
15554  "\n"
15555  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15556  " Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15557  "\n"
15558  "\n"
15559  " This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
15560  "\n"
15561  "\n"
15562  "\n"
15563  "SYNOPSIS:\n"
15564  "\n"
15565  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15566  "\n"
15567  "ARGUMENTS:\n"
15568  "\n"
15569  " xopt (const char *, input) : Pointer to character string specifying\n"
15570  " options for horizontal axis. The string can include any\n"
15571  " combination of the following letters (upper or lower case) in any\n"
15572  " order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15573  " is vertical line (x=0). \n"
15574  " b: Draws bottom (X) or left (Y) edge of frame. \n"
15575  " c: Draws top (X) or right (Y) edge of frame. \n"
15576  " d: Plot labels as date / time. Values are assumed to be\n"
15577  " seconds since the epoch (as used by gmtime). \n"
15578  " f: Always use fixed point numeric labels. \n"
15579  " g: Draws a grid at the major tick interval. \n"
15580  " h: Draws a grid at the minor tick interval. \n"
15581  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15582  " inwards. \n"
15583  " l: Labels axis logarithmically. This only affects the labels,\n"
15584  " not the data, and so it is necessary to compute the logarithms\n"
15585  " of data points before passing them to any of the drawing\n"
15586  " routines. \n"
15587  " m: Writes numeric labels at major tick intervals in the\n"
15588  " unconventional location (above box for X, right of box for Y). \n"
15589  " n: Writes numeric labels at major tick intervals in the\n"
15590  " conventional location (below box for X, left of box for Y). \n"
15591  " o: Use custom labelling function to generate axis label text. \n"
15592  " The custom labelling function can be defined with the\n"
15593  " plslabelfunc command. \n"
15594  " s: Enables subticks between major ticks, only valid if t is\n"
15595  " also specified. \n"
15596  " t: Draws major ticks. \n"
15597  " u: Exactly like \"b\" except don't draw edge line. \n"
15598  " w: Exactly like \"c\" except don't draw edge line. \n"
15599  " x: Exactly like \"t\" (including the side effect of the\n"
15600  " numerical labels for the major ticks) except exclude drawing\n"
15601  " the major and minor tick marks. \n"
15602  "\n"
15603  "\n"
15604  " xtick (PLFLT, input) : World coordinate interval between major\n"
15605  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15606  " generates a suitable tick interval. \n"
15607  "\n"
15608  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15609  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15610  " generates a suitable minor tick interval. \n"
15611  "\n"
15612  " yopt (const char *, input) : Pointer to character string specifying\n"
15613  " options for vertical axis. The string can include any combination\n"
15614  " of the letters defined above for xopt, and in addition may\n"
15615  " contain: v: Write numeric labels for vertical axis parallel to the\n"
15616  " base of the graph, rather than parallel to the axis. \n"
15617  "\n"
15618  "\n"
15619  " ytick (PLFLT, input) : World coordinate interval between major\n"
15620  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15621  " generates a suitable tick interval. \n"
15622  "\n"
15623  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15624  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15625  " generates a suitable minor tick interval. \n"
15626  "\n"
15627  ""},
15628  { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15629  "Draw a box with axes, etc, in 3-d \n"
15630  "\n"
15631  "DESCRIPTION:\n"
15632  "\n"
15633  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15634  " plot. For a more complete description of three-dimensional plotting\n"
15635  " see the PLplot documentation. \n"
15636  "\n"
15637  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15638  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15639  " Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15640  " xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15641  "\n"
15642  "\n"
15643  " This function is used in examples 8,11,18,21. \n"
15644  "\n"
15645  "\n"
15646  "\n"
15647  "SYNOPSIS:\n"
15648  "\n"
15649  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15650  "\n"
15651  "ARGUMENTS:\n"
15652  "\n"
15653  " xopt (const char *, input) : Pointer to character string specifying\n"
15654  " options for the x axis. The string can include any combination of\n"
15655  " the following letters (upper or lower case) in any order: b: Draws\n"
15656  " axis at base, at height z=\n"
15657  " zmin where zmin is defined by call to plw3d. This character must be\n"
15658  " specified in order to use any of the other options. \n"
15659  " f: Always use fixed point numeric labels. \n"
15660  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15661  " than upwards. \n"
15662  " l: Labels axis logarithmically. This only affects the labels,\n"
15663  " not the data, and so it is necessary to compute the logarithms\n"
15664  " of data points before passing them to any of the drawing\n"
15665  " routines. \n"
15666  " n: Writes numeric labels at major tick intervals. \n"
15667  " o: Use custom labelling function to generate axis label text. \n"
15668  " The custom labelling function can be defined with the\n"
15669  " plslabelfunc command. \n"
15670  " s: Enables subticks between major ticks, only valid if t is\n"
15671  " also specified. \n"
15672  " t: Draws major ticks. \n"
15673  " u: If this is specified, the text label for the axis is\n"
15674  " written under the axis. \n"
15675  "\n"
15676  "\n"
15677  " xlabel (const char *, input) : Pointer to character string\n"
15678  " specifying text label for the x axis. It is only drawn if u is in\n"
15679  " the xopt string. \n"
15680  "\n"
15681  " xtick (PLFLT, input) : World coordinate interval between major\n"
15682  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15683  " generates a suitable tick interval. \n"
15684  "\n"
15685  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15686  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15687  " generates a suitable minor tick interval. \n"
15688  "\n"
15689  " yopt (const char *, input) : Pointer to character string specifying\n"
15690  " options for the y axis. The string is interpreted in the same way\n"
15691  " as xopt. \n"
15692  "\n"
15693  " ylabel (const char *, input) : Pointer to character string\n"
15694  " specifying text label for the y axis. It is only drawn if u is in\n"
15695  " the yopt string. \n"
15696  "\n"
15697  " ytick (PLFLT, input) : World coordinate interval between major\n"
15698  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15699  " generates a suitable tick interval. \n"
15700  "\n"
15701  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15702  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15703  " generates a suitable minor tick interval. \n"
15704  "\n"
15705  " zopt (const char *, input) : Pointer to character string specifying\n"
15706  " options for the z axis. The string can include any combination of\n"
15707  " the following letters (upper or lower case) in any order: b: Draws\n"
15708  " z axis to the left of the surface plot. \n"
15709  " c: Draws z axis to the right of the surface plot. \n"
15710  " d: Draws grid lines parallel to the x-y plane behind the\n"
15711  " figure. These lines are not drawn until after plot3d or\n"
15712  " plmesh are called because of the need for hidden line removal. \n"
15713  " f: Always use fixed point numeric labels. \n"
15714  " i: Inverts tick marks, so they are drawn away from the center. \n"
15715  " l: Labels axis logarithmically. This only affects the labels,\n"
15716  " not the data, and so it is necessary to compute the logarithms\n"
15717  " of data points before passing them to any of the drawing\n"
15718  " routines. \n"
15719  " m: Writes numeric labels at major tick intervals on the\n"
15720  " right-hand vertical axis. \n"
15721  " n: Writes numeric labels at major tick intervals on the\n"
15722  " left-hand vertical axis. \n"
15723  " o: Use custom labelling function to generate axis label text. \n"
15724  " The custom labelling function can be defined with the\n"
15725  " plslabelfunc command. \n"
15726  " s: Enables subticks between major ticks, only valid if t is\n"
15727  " also specified. \n"
15728  " t: Draws major ticks. \n"
15729  " u: If this is specified, the text label is written beside the\n"
15730  " left-hand axis. \n"
15731  " v: If this is specified, the text label is written beside the\n"
15732  " right-hand axis. \n"
15733  "\n"
15734  "\n"
15735  " zlabel (const char *, input) : Pointer to character string\n"
15736  " specifying text label for the z axis. It is only drawn if u or v\n"
15737  " are in the zopt string. \n"
15738  "\n"
15739  " ztick (PLFLT, input) : World coordinate interval between major\n"
15740  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15741  " generates a suitable tick interval. \n"
15742  "\n"
15743  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15744  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15745  " generates a suitable minor tick interval. \n"
15746  "\n"
15747  ""},
15748  { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15749  "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15750  "\n"
15751  "DESCRIPTION:\n"
15752  "\n"
15753  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15754  " from relative device coordinates, rx and ry. \n"
15755  "\n"
15756  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15757  " Perl/PDL: Not available? \n"
15758  "\n"
15759  "\n"
15760  " This function is used in example 31. \n"
15761  "\n"
15762  "\n"
15763  "\n"
15764  "SYNOPSIS:\n"
15765  "\n"
15766  "plcalc_world(rx, ry, wx, wy, window)\n"
15767  "\n"
15768  "ARGUMENTS:\n"
15769  "\n"
15770  " rx (PLFLT, input) : Input relative device coordinate (ranging from\n"
15771  " 0. to 1.) for the x coordinate. \n"
15772  "\n"
15773  " ry (PLFLT, input) : Input relative device coordinate (ranging from\n"
15774  " 0. to 1.) for the y coordinate. \n"
15775  "\n"
15776  " wx (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15777  " x corresponding to the relative device coordinates rx and ry. \n"
15778  "\n"
15779  " wy (PLFLT *, output) : Pointer to the returned world coordinate for\n"
15780  " y corresponding to the relative device coordinates rx and ry. \n"
15781  "\n"
15782  " window (PLINT *, output) : Pointer to the returned last defined\n"
15783  " window index that corresponds to the input relative device\n"
15784  " coordinates (and the returned world coordinates). To give some\n"
15785  " background on the window index, for each page the initial window\n"
15786  " index is set to zero, and each time plwind is called within the\n"
15787  " page, world and device coordinates are stored for the window and\n"
15788  " the window index is incremented. Thus, for a simple page layout\n"
15789  " with non-overlapping viewports and one window per viewport, window\n"
15790  " corresponds to the viewport index (in the order which the\n"
15791  " viewport/windows were created) of the only viewport/window\n"
15792  " corresponding to rx and ry. However, for more complicated layouts\n"
15793  " with potentially overlapping viewports and possibly more than one\n"
15794  " window (set of world coordinates) per viewport, window and the\n"
15795  " corresponding output world coordinates corresponds to the last\n"
15796  " window created that fulfills the criterion that the relative\n"
15797  " device coordinates are inside it. Finally, in all cases where the\n"
15798  " input relative device coordinates are not inside any\n"
15799  " viewport/window, then window is set to -1. \n"
15800  "\n"
15801  ""},
15802  { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15803  "Clear current (sub)page \n"
15804  "\n"
15805  "DESCRIPTION:\n"
15806  "\n"
15807  " Clears the current page, effectively erasing everything that have been\n"
15808  " drawn. This command only works with interactive drivers; if the\n"
15809  " driver does not support this, the page is filled with the background\n"
15810  " color in use. If the current page is divided into subpages, only the\n"
15811  " current subpage is erased. The nth subpage can be selected with\n"
15812  " pladv(n). \n"
15813  "\n"
15814  " Redacted form: General: plclear()\n"
15815  " Perl/PDL: Not available? \n"
15816  "\n"
15817  "\n"
15818  " This function is not used in any examples. \n"
15819  "\n"
15820  "\n"
15821  "\n"
15822  "SYNOPSIS:\n"
15823  "\n"
15824  "plclear()\n"
15825  "\n"
15826  ""},
15827  { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15828  "Set color, cmap0 \n"
15829  "\n"
15830  "DESCRIPTION:\n"
15831  "\n"
15832  " Sets the color index for cmap0 (see the PLplot documentation). \n"
15833  "\n"
15834  " Redacted form: plcol0(icol0)\n"
15835  "\n"
15836  " This function is used in examples 1-9,11-16,18-27,29. \n"
15837  "\n"
15838  "\n"
15839  "\n"
15840  "SYNOPSIS:\n"
15841  "\n"
15842  "plcol0(icol0)\n"
15843  "\n"
15844  "ARGUMENTS:\n"
15845  "\n"
15846  " icol0 (PLINT, input) : Integer representing the color. The\n"
15847  " defaults at present are (these may change): \n"
15848  " 0 black (default background) \n"
15849  " 1 red (default foreground) \n"
15850  " 2 yellow \n"
15851  " 3 green \n"
15852  " 4 aquamarine \n"
15853  " 5 pink \n"
15854  " 6 wheat \n"
15855  " 7 grey \n"
15856  " 8 brown \n"
15857  " 9 blue \n"
15858  " 10 BlueViolet \n"
15859  " 11 cyan \n"
15860  " 12 turquoise \n"
15861  " 13 magenta \n"
15862  " 14 salmon \n"
15863  " 15 white \n"
15864  "\n"
15865  " Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15866  " change an individual color in the map0 color palette. \n"
15867  "\n"
15868  ""},
15869  { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15870  "Set color, cmap1 \n"
15871  "\n"
15872  "DESCRIPTION:\n"
15873  "\n"
15874  " Sets the color for cmap1 (see the PLplot documentation). \n"
15875  "\n"
15876  " Redacted form: plcol1(col1)\n"
15877  "\n"
15878  " This function is used in examples 12 and 21. \n"
15879  "\n"
15880  "\n"
15881  "\n"
15882  "SYNOPSIS:\n"
15883  "\n"
15884  "plcol1(col1)\n"
15885  "\n"
15886  "ARGUMENTS:\n"
15887  "\n"
15888  " col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n"
15889  " and is mapped to color using the continuous map1 color palette\n"
15890  " which by default ranges from blue to the background color to red. \n"
15891  " The map1 palette can also be straightforwardly changed by the user\n"
15892  " with plscmap1 or plscmap1l. \n"
15893  "\n"
15894  ""},
15895  { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
15896  "Configure the transformation between continuous and broken-down time for the current stream \n"
15897  "\n"
15898  "DESCRIPTION:\n"
15899  "\n"
15900  " Configure the transformation between continuous and broken-down time\n"
15901  " for the current stream. This transformation is used by both plbtime\n"
15902  " and plctime. \n"
15903  "\n"
15904  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15905  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15906  " Perl/PDL: Not available? \n"
15907  "\n"
15908  "\n"
15909  " This function is used in example 29. \n"
15910  "\n"
15911  "\n"
15912  "\n"
15913  "SYNOPSIS:\n"
15914  "\n"
15915  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15916  "\n"
15917  "ARGUMENTS:\n"
15918  "\n"
15919  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15920  " As a special case, if \n"
15921  " scale is 0., then all other arguments are ignored, and the result (the\n"
15922  " default used by PLplot) is the equivalent of a call to\n"
15923  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15924  " That is, for this special case broken-down time is calculated with\n"
15925  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15926  " and the continuous time is defined as the number of seconds since\n"
15927  " the Unix epoch of 1970-01-01T00:00:00Z. \n"
15928  "\n"
15929  " offset1 (PLFLT, input) : If \n"
15930  " ifbtime_offset is true, the parameters \n"
15931  " offset1 and \n"
15932  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15933  " (with units in days) specify the epoch of the continuous time\n"
15934  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15935  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15936  " are used to specify the origin to allow users (by specifying \n"
15937  " offset1 as an integer that can be exactly represented by a\n"
15938  " floating-point variable and specifying \n"
15939  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15940  " the numerical errors of the continuous time representation. \n"
15941  "\n"
15942  " offset2 (PLFLT, input) : See documentation of \n"
15943  " offset1. \n"
15944  "\n"
15945  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15946  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15947  " calendar is used for broken-down time rather than the proleptic\n"
15948  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15949  " have been historically used to define UTC are inserted into the\n"
15950  " broken-down time. Other possibilities for additional control bits\n"
15951  " for ccontrol exist such as making the historical time corrections\n"
15952  " in the broken-down time corresponding to ET (ephemeris time) or\n"
15953  " making the (slightly non-constant) corrections from international\n"
15954  " atomic time (TAI) to what astronomers define as terrestrial time\n"
15955  " (TT). But those additional possibilities have not been\n"
15956  " implemented yet in the qsastime library (one of the PLplot utility\n"
15957  " libraries). \n"
15958  "\n"
15959  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15960  " epoch of the continuous time scale is specified by the user. If \n"
15961  " ifbtime_offset is false, then \n"
15962  " offset1 and \n"
15963  " offset2 are used to specify the epoch, and the following broken-down\n"
15964  " time parameters are completely ignored. If \n"
15965  " ifbtime_offset is true, then \n"
15966  " offset1 and \n"
15967  " offset2 are completely ignored, and the following broken-down time\n"
15968  " parameters are used to specify the epoch. \n"
15969  "\n"
15970  " year (PLINT, input) : Year of epoch. \n"
15971  "\n"
15972  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15973  " 11 (December). \n"
15974  "\n"
15975  " day (PLINT, input) : Day of epoch in range from 1 to 31. \n"
15976  "\n"
15977  " hour (PLINT, input) : Hour of epoch in range from 0 to 23 \n"
15978  "\n"
15979  " min (PLINT, input) : Minute of epoch in range from 0 to 59. \n"
15980  "\n"
15981  " sec (PLFLT, input) : Second of epoch in floating range from 0. to\n"
15982  " 60. \n"
15983  "\n"
15984  ""},
15985  { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
15986  "Contour plot \n"
15987  "\n"
15988  "DESCRIPTION:\n"
15989  "\n"
15990  " Draws a contour plot of the data in f[\n"
15991  " nx][\n"
15992  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15993  " region of the array from kx to lx and from ky to ly is plotted out. A\n"
15994  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
15995  " additional data required by the transformation routine is used to map\n"
15996  " indices within the array to the world coordinates. See the following\n"
15997  " discussion of the arguments and the PLplot documentation for more\n"
15998  " information. \n"
15999  "\n"
16000  " Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
16001  " plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n"
16002  " clevel, xgrid, ygrid)\n"
16003  " Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
16004  " Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16005  " Python: plcont2(f, kx, lx, ky, ly, clevel)\n"
16006  "\n"
16007  "\n"
16008  " This function is used in examples 9,14,16,22. \n"
16009  "\n"
16010  "\n"
16011  "\n"
16012  "SYNOPSIS:\n"
16013  "\n"
16014  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16015  "\n"
16016  "ARGUMENTS:\n"
16017  "\n"
16018  " f (const PLFLT * const *, input) : Pointer to a vectored\n"
16019  " two-dimensional array containing data to be contoured. \n"
16020  "\n"
16021  " nx, ny (PLINT, input) : Physical dimensions of array f. \n"
16022  "\n"
16023  " kx, lx (PLINT, input) : Range of x indices to consider. \n"
16024  "\n"
16025  " ky, ly (PLINT, input) : Range of y indices to consider. \n"
16026  "\n"
16027  " clevel (const PLFLT *, input) : Pointer to array specifying levels\n"
16028  " at which to draw contours. \n"
16029  "\n"
16030  " nlevel (PLINT, input) : Number of contour levels to draw. \n"
16031  "\n"
16032  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
16033  " Pointer to function that defines transformation between indices\n"
16034  " in array f and the world coordinates (C only). Transformation\n"
16035  " functions are provided in the PLplot library: pltr0 for identity\n"
16036  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
16037  " defined by one- and two-dimensional arrays. In addition,\n"
16038  " user-supplied routines for the transformation can be used as well.\n"
16039  " Examples of all of these approaches are given in the PLplot\n"
16040  " documentation. The transformation function should have the form\n"
16041  " given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
16042  " and similar PLplot functions which have a pltr argument, plcont\n"
16043  " requires that a transformation function be provided in the C\n"
16044  " interface. Leaving pltr NULL will result in an error. \n"
16045  "\n"
16046  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16047  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
16048  " externally supplied. \n"
16049  "\n"
16050  ""},
16051  { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
16052  "Calculate continuous time from broken-down time for the current stream \n"
16053  "\n"
16054  "DESCRIPTION:\n"
16055  "\n"
16056  " Calculate continuous time, ctime, from broken-down time for the\n"
16057  " current stream. The broken-down\n"
16058  " time is specified by the following parameters: year, month, day, hour,\n"
16059  " min, and sec. This function is the inverse of plbtime. \n"
16060  "\n"
16061  " The PLplot definition of broken-down time is a calendar time that\n"
16062  " completely ignores all time zone offsets, i.e., it is the user's\n"
16063  " responsibility to apply those offsets (if so desired) before using the\n"
16064  " PLplot time API. By default broken-down time is defined using the\n"
16065  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16066  " continuous time is defined as the number of seconds since the Unix\n"
16067  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16068  " broken-down and continuous time are possible, see plconfigtime which\n"
16069  " specifies that transformation for the current stream. \n"
16070  "\n"
16071  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16072  " ctime)\n"
16073  " Perl/PDL: Not available? \n"
16074  "\n"
16075  "\n"
16076  " This function is used in example 29. \n"
16077  "\n"
16078  "\n"
16079  "\n"
16080  "SYNOPSIS:\n"
16081  "\n"
16082  "plctime(year, month, day, hour, min, sec, ctime)\n"
16083  "\n"
16084  "ARGUMENTS:\n"
16085  "\n"
16086  " year (PLINT, input) : Input year. \n"
16087  "\n"
16088  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16089  " (December). \n"
16090  "\n"
16091  " day (PLINT, input) : Input day in range from 1 to 31. \n"
16092  "\n"
16093  " hour (PLINT, input) : Input hour in range from 0 to 23 \n"
16094  "\n"
16095  " min (PLINT, input) : Input minute in range from 0 to 59. \n"
16096  "\n"
16097  " sec (PLFLT, input) : Input second in floating range from 0. to 60. \n"
16098  "\n"
16099  " ctime (PLFLT *, output) : Continous time calculated from the\n"
16100  " broken-down time specified by the previous parameters. \n"
16101  "\n"
16102  ""},
16103  { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
16104  "Copy state parameters from the reference stream to the current stream \n"
16105  "\n"
16106  "DESCRIPTION:\n"
16107  "\n"
16108  " Copies state parameters from the reference stream to the current\n"
16109  " stream. Tell driver interface to map device coordinates unless flags\n"
16110  " == 1. \n"
16111  "\n"
16112  " This function is used for making save files of selected plots (e.g.\n"
16113  " from the TK driver). After initializing, you can get a copy of the\n"
16114  " current plot to the specified device by switching to this stream and\n"
16115  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16116  " appropriate. The plot buffer must have previously been enabled (done\n"
16117  " automatically by some display drivers, such as X). \n"
16118  "\n"
16119  " Redacted form: plcpstrm(iplsr, flags)\n"
16120  "\n"
16121  " This function is used in example 1,20. \n"
16122  "\n"
16123  "\n"
16124  "\n"
16125  "SYNOPSIS:\n"
16126  "\n"
16127  "plcpstrm(iplsr, flags)\n"
16128  "\n"
16129  "ARGUMENTS:\n"
16130  "\n"
16131  " iplsr (PLINT, input) : Number of reference stream. \n"
16132  "\n"
16133  " flags (PLBOOL, input) : If flags is set to true the device\n"
16134  " coordinates are not copied from the reference to current stream. \n"
16135  "\n"
16136  ""},
16137  { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
16138  "End plotting session \n"
16139  "\n"
16140  "DESCRIPTION:\n"
16141  "\n"
16142  " Ends a plotting session, tidies up all the output files, switches\n"
16143  " interactive devices back into text mode and frees up any memory that\n"
16144  " was allocated. Must be called before end of program. \n"
16145  "\n"
16146  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16147  " wait state after a call to plend or other functions which trigger the\n"
16148  " end of a plot page. To avoid this, use the plspause function. \n"
16149  "\n"
16150  " Redacted form: plend()\n"
16151  "\n"
16152  " This function is used in all of the examples. \n"
16153  "\n"
16154  "\n"
16155  "\n"
16156  "SYNOPSIS:\n"
16157  "\n"
16158  "plend()\n"
16159  "\n"
16160  ""},
16161  { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
16162  "End plotting session for current stream \n"
16163  "\n"
16164  "DESCRIPTION:\n"
16165  "\n"
16166  " Ends a plotting session for the current output stream only. See\n"
16167  " plsstrm for more info. \n"
16168  "\n"
16169  " Redacted form: plend1()\n"
16170  "\n"
16171  " This function is used in examples 1,20. \n"
16172  "\n"
16173  "\n"
16174  "\n"
16175  "SYNOPSIS:\n"
16176  "\n"
16177  "plend1()\n"
16178  "\n"
16179  ""},
16180  { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
16181  "Set up standard window and draw box \n"
16182  "\n"
16183  "DESCRIPTION:\n"
16184  "\n"
16185  " Sets up plotter environment for simple graphs by calling pladv and\n"
16186  " setting up viewport and window to sensible default values. plenv\n"
16187  " leaves enough room around most graphs for axis labels and a title.\n"
16188  " When these defaults are not suitable, use the individual routines\n"
16189  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
16190  " defining the window, and plbox for drawing the box. \n"
16191  "\n"
16192  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16193  "\n"
16194  " This function is used in example 1,3,9,13,14,19-22,29. \n"
16195  "\n"
16196  "\n"
16197  "\n"
16198  "SYNOPSIS:\n"
16199  "\n"
16200  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16201  "\n"
16202  "ARGUMENTS:\n"
16203  "\n"
16204  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16205  " world coordinates). \n"
16206  "\n"
16207  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16208  " world coordinates). \n"
16209  "\n"
16210  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16211  " coordinates). \n"
16212  "\n"
16213  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16214  " coordinates). \n"
16215  "\n"
16216  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16217  " scales will not be set, the user must set up the scale before\n"
16218  " calling plenv using plsvpa, plvasp or other. \n"
16219  " 0: the x and y axes are scaled independently to use as much of\n"
16220  " the screen as possible. \n"
16221  " 1: the scales of the x and y axes are made equal. \n"
16222  " 2: the axis of the x and y axes are made equal, and the plot\n"
16223  " box will be square. \n"
16224  "\n"
16225  "\n"
16226  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16227  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
16228  " -1: draw box only. \n"
16229  " 0: draw box, ticks, and numeric tick labels. \n"
16230  " 1: also draw coordinate axes at x=0 and y=0. \n"
16231  " 2: also draw a grid at major tick positions in both\n"
16232  " coordinates. \n"
16233  " 3: also draw a grid at minor tick positions in both\n"
16234  " coordinates. \n"
16235  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16236  " have to be converted to logarithms separately.) \n"
16237  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16238  " have to be converted to logarithms separately.) \n"
16239  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16240  " have to be converted to logarithms separately.) \n"
16241  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16242  " have to be converted to logarithms separately.) \n"
16243  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16244  " have to be converted to logarithms separately.) \n"
16245  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16246  " have to be converted to logarithms separately.) \n"
16247  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16248  " have to be converted to logarithms separately.) \n"
16249  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16250  " have to be converted to logarithms separately.) \n"
16251  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16252  " and y data have to be converted to logarithms separately.) \n"
16253  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16254  " and y data have to be converted to logarithms separately.) \n"
16255  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16256  " and y data have to be converted to logarithms separately.) \n"
16257  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16258  " and y data have to be converted to logarithms separately.) \n"
16259  " 40: same as 0 except date / time x labels. \n"
16260  " 41: same as 1 except date / time x labels. \n"
16261  " 42: same as 2 except date / time x labels. \n"
16262  " 43: same as 3 except date / time x labels. \n"
16263  " 50: same as 0 except date / time y labels. \n"
16264  " 51: same as 1 except date / time y labels. \n"
16265  " 52: same as 2 except date / time y labels. \n"
16266  " 53: same as 3 except date / time y labels. \n"
16267  " 60: same as 0 except date / time x and y labels. \n"
16268  " 61: same as 1 except date / time x and y labels. \n"
16269  " 62: same as 2 except date / time x and y labels. \n"
16270  " 63: same as 3 except date / time x and y labels. \n"
16271  " 70: same as 0 except custom x and y labels. \n"
16272  " 71: same as 1 except custom x and y labels. \n"
16273  " 72: same as 2 except custom x and y labels. \n"
16274  " 73: same as 3 except custom x and y labels. \n"
16275  "\n"
16276  ""},
16277  { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
16278  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n"
16279  "\n"
16280  "DESCRIPTION:\n"
16281  "\n"
16282  " Sets up plotter environment for simple graphs by calling pladv and\n"
16283  " setting up viewport and window to sensible default values. plenv0\n"
16284  " leaves enough room around most graphs for axis labels and a title.\n"
16285  " When these defaults are not suitable, use the individual routines\n"
16286  " plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
16287  " defining the window, and plbox for drawing the box. \n"
16288  "\n"
16289  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16290  "\n"
16291  " This function is used in example 21. \n"
16292  "\n"
16293  "\n"
16294  "\n"
16295  "SYNOPSIS:\n"
16296  "\n"
16297  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16298  "\n"
16299  "ARGUMENTS:\n"
16300  "\n"
16301  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16302  " world coordinates). \n"
16303  "\n"
16304  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16305  " world coordinates). \n"
16306  "\n"
16307  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16308  " coordinates). \n"
16309  "\n"
16310  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16311  " coordinates). \n"
16312  "\n"
16313  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16314  " scales will not be set, the user must set up the scale before\n"
16315  " calling plenv0 using plsvpa, plvasp or other. \n"
16316  " 0: the x and y axes are scaled independently to use as much of\n"
16317  " the screen as possible. \n"
16318  " 1: the scales of the x and y axes are made equal. \n"
16319  " 2: the axis of the x and y axes are made equal, and the plot\n"
16320  " box will be square. \n"
16321  "\n"
16322  "\n"
16323  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16324  " -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
16325  " -1: draw box only. \n"
16326  " 0: draw box, ticks, and numeric tick labels. \n"
16327  " 1: also draw coordinate axes at x=0 and y=0. \n"
16328  " 2: also draw a grid at major tick positions in both\n"
16329  " coordinates. \n"
16330  " 3: also draw a grid at minor tick positions in both\n"
16331  " coordinates. \n"
16332  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16333  " have to be converted to logarithms separately.) \n"
16334  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16335  " have to be converted to logarithms separately.) \n"
16336  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16337  " have to be converted to logarithms separately.) \n"
16338  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16339  " have to be converted to logarithms separately.) \n"
16340  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16341  " have to be converted to logarithms separately.) \n"
16342  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16343  " have to be converted to logarithms separately.) \n"
16344  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16345  " have to be converted to logarithms separately.) \n"
16346  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16347  " have to be converted to logarithms separately.) \n"
16348  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16349  " and y data have to be converted to logarithms separately.) \n"
16350  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16351  " and y data have to be converted to logarithms separately.) \n"
16352  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16353  " and y data have to be converted to logarithms separately.) \n"
16354  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16355  " and y data have to be converted to logarithms separately.) \n"
16356  " 40: same as 0 except date / time x labels. \n"
16357  " 41: same as 1 except date / time x labels. \n"
16358  " 42: same as 2 except date / time x labels. \n"
16359  " 43: same as 3 except date / time x labels. \n"
16360  " 50: same as 0 except date / time y labels. \n"
16361  " 51: same as 1 except date / time y labels. \n"
16362  " 52: same as 2 except date / time y labels. \n"
16363  " 53: same as 3 except date / time y labels. \n"
16364  " 60: same as 0 except date / time x and y labels. \n"
16365  " 61: same as 1 except date / time x and y labels. \n"
16366  " 62: same as 2 except date / time x and y labels. \n"
16367  " 63: same as 3 except date / time x and y labels. \n"
16368  " 70: same as 0 except custom x and y labels. \n"
16369  " 71: same as 1 except custom x and y labels. \n"
16370  " 72: same as 2 except custom x and y labels. \n"
16371  " 73: same as 3 except custom x and y labels. \n"
16372  "\n"
16373  ""},
16374  { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
16375  "Eject current page \n"
16376  "\n"
16377  "DESCRIPTION:\n"
16378  "\n"
16379  " Clears the graphics screen of an interactive device, or ejects a page\n"
16380  " on a plotter. See plbop for more information. \n"
16381  "\n"
16382  " Redacted form: pleop()\n"
16383  "\n"
16384  " This function is used in example 2,14. \n"
16385  "\n"
16386  "\n"
16387  "\n"
16388  "SYNOPSIS:\n"
16389  "\n"
16390  "pleop()\n"
16391  "\n"
16392  ""},
16393  { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
16394  "Draw x error bar \n"
16395  "\n"
16396  "DESCRIPTION:\n"
16397  "\n"
16398  " Draws a set of n horizontal error bars, the i'th error bar extending\n"
16399  " from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n"
16400  " error bar are of length equal to the minor tick length (settable using\n"
16401  " plsmin). \n"
16402  "\n"
16403  " Redacted form: General: plerrx(xmin, ymax, y)\n"
16404  " Perl/PDL: plerrx(n, xmin, xmax, y)\n"
16405  "\n"
16406  "\n"
16407  " This function is used in example 29. \n"
16408  "\n"
16409  "\n"
16410  "\n"
16411  "SYNOPSIS:\n"
16412  "\n"
16413  "plerrx(n, xmin, xmax, y)\n"
16414  "\n"
16415  "ARGUMENTS:\n"
16416  "\n"
16417  " n (PLINT, input) : Number of error bars to draw. \n"
16418  "\n"
16419  " xmin (const PLFLT *, input) : Pointer to array with x coordinates\n"
16420  " of left-hand endpoint of error bars. \n"
16421  "\n"
16422  " xmax (const PLFLT *, input) : Pointer to array with x coordinates\n"
16423  " of right-hand endpoint of error bars. \n"
16424  "\n"
16425  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16426  " error bar. \n"
16427  "\n"
16428  ""},
16429  { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
16430  "Draw y error bar \n"
16431  "\n"
16432  "DESCRIPTION:\n"
16433  "\n"
16434  " Draws a set of n vertical error bars, the i'th error bar extending\n"
16435  " from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n"
16436  " error bar are of length equal to the minor tick length (settable using\n"
16437  " plsmin). \n"
16438  "\n"
16439  " Redacted form: General: plerry(x, ymin, ymax)\n"
16440  " Perl/PDL: plerry(n, x, ymin, ymax)\n"
16441  "\n"
16442  "\n"
16443  " This function is used in example 29. \n"
16444  "\n"
16445  "\n"
16446  "\n"
16447  "SYNOPSIS:\n"
16448  "\n"
16449  "plerry(n, x, ymin, ymax)\n"
16450  "\n"
16451  "ARGUMENTS:\n"
16452  "\n"
16453  " n (PLINT, input) : Number of error bars to draw. \n"
16454  "\n"
16455  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16456  " error bars. \n"
16457  "\n"
16458  " ymin (const PLFLT *, input) : Pointer to array with y coordinates\n"
16459  " of lower endpoint of error bars. \n"
16460  "\n"
16461  " ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n"
16462  " upper endpoint of error bar. \n"
16463  "\n"
16464  ""},
16465  { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16466  "Advance to the next family file on the next new page \n"
16467  "\n"
16468  "DESCRIPTION:\n"
16469  "\n"
16470  " Advance to the next family file on the next new page. \n"
16471  "\n"
16472  " Redacted form: plfamadv()\n"
16473  "\n"
16474  " This function is not used in any examples. \n"
16475  "\n"
16476  "\n"
16477  "\n"
16478  "SYNOPSIS:\n"
16479  "\n"
16480  "plfamadv()\n"
16481  "\n"
16482  ""},
16483  { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16484  "Draw filled polygon \n"
16485  "\n"
16486  "DESCRIPTION:\n"
16487  "\n"
16488  " Fills the polygon defined by the n points (\n"
16489  " x[i], \n"
16490  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16491  " style is a solid fill. The routine will automatically close the\n"
16492  " polygon between the last and first vertices. If multiple closed\n"
16493  " polygons are passed in x and y then plfill will fill in between them. \n"
16494  "\n"
16495  " Redacted form: plfill(x,y)\n"
16496  "\n"
16497  " This function is used in examples 12,13,15,16,21,24,25. \n"
16498  "\n"
16499  "\n"
16500  "\n"
16501  "SYNOPSIS:\n"
16502  "\n"
16503  "plfill(n, x, y)\n"
16504  "\n"
16505  "ARGUMENTS:\n"
16506  "\n"
16507  " n (PLINT, input) : Number of vertices in polygon. \n"
16508  "\n"
16509  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16510  " vertices. \n"
16511  "\n"
16512  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16513  " vertices. \n"
16514  "\n"
16515  ""},
16516  { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16517  "Draw filled polygon in 3D \n"
16518  "\n"
16519  "DESCRIPTION:\n"
16520  "\n"
16521  " Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
16522  " using the pattern defined by plpsty or plpat. The routine will\n"
16523  " automatically close the polygon between the last and first vertices. \n"
16524  " If multiple closed polygons are passed in x, y, and z then plfill3\n"
16525  " will fill in between them. \n"
16526  "\n"
16527  " Redacted form: General: plfill3(x, y, z)\n"
16528  " Perl/PDL: plfill3(n, x, y, z)\n"
16529  "\n"
16530  "\n"
16531  " This function is used in example 15. \n"
16532  "\n"
16533  "\n"
16534  "\n"
16535  "SYNOPSIS:\n"
16536  "\n"
16537  "plfill3(n, x, y, z)\n"
16538  "\n"
16539  "ARGUMENTS:\n"
16540  "\n"
16541  " n (PLINT, input) : Number of vertices in polygon. \n"
16542  "\n"
16543  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16544  " vertices. \n"
16545  "\n"
16546  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16547  " vertices. \n"
16548  "\n"
16549  " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
16550  " vertices. \n"
16551  "\n"
16552  ""},
16553  { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16554  "Draw linear gradient inside polygon \n"
16555  "\n"
16556  "DESCRIPTION:\n"
16557  "\n"
16558  " Draw a linear gradient using colour map 1 inside the polygon defined\n"
16559  " by the n points (\n"
16560  " x[i], \n"
16561  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16562  " polygon coordinates and the gradient angle are all expressed in world\n"
16563  " coordinates. The angle from the x axis for both the rotated\n"
16564  " coordinate system and the gradient vector is specified by angle. The\n"
16565  " magnitude of the gradient vector is the difference between the maximum\n"
16566  " and minimum values of x for the vertices in the rotated coordinate\n"
16567  " system. The origin of the gradient vector can be interpreted as being\n"
16568  " anywhere on the line corresponding to the minimum x value for the\n"
16569  " vertices in the rotated coordinate system. The distance along the\n"
16570  " gradient vector is linearly transformed to the independent variable of\n"
16571  " colour map 1 which ranges from 0. at the tail of the gradient vector\n"
16572  " to 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16573  " colour corresponding to the independent variable of colour map 1. For\n"
16574  " more information about colour map 1 (see the PLplot documentation). \n"
16575  "\n"
16576  " Redacted form: plgradient(x,y,angle)\n"
16577  "\n"
16578  " This function is used in examples 25,30. \n"
16579  "\n"
16580  "\n"
16581  "\n"
16582  "SYNOPSIS:\n"
16583  "\n"
16584  "plgradient(n, x, y, angle)\n"
16585  "\n"
16586  "ARGUMENTS:\n"
16587  "\n"
16588  " n (PLINT, input) : Number of vertices in polygon. \n"
16589  "\n"
16590  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
16591  " vertices. \n"
16592  "\n"
16593  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
16594  " vertices. \n"
16595  "\n"
16596  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16597  " axis. \n"
16598  "\n"
16599  ""},
16600  { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16601  "Flushes the output stream \n"
16602  "\n"
16603  "DESCRIPTION:\n"
16604  "\n"
16605  " Flushes the output stream. Use sparingly, if at all. \n"
16606  "\n"
16607  " Redacted form: plflush()\n"
16608  "\n"
16609  " This function is used in examples 1,14. \n"
16610  "\n"
16611  "\n"
16612  "\n"
16613  "SYNOPSIS:\n"
16614  "\n"
16615  "plflush()\n"
16616  "\n"
16617  ""},
16618  { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16619  "Set character font \n"
16620  "\n"
16621  "DESCRIPTION:\n"
16622  "\n"
16623  " Sets the default character font for subsequent character drawing. Also\n"
16624  " affects symbols produced by plpoin. This routine has no effect unless\n"
16625  " the extended character set is loaded (see plfontld). \n"
16626  "\n"
16627  " Redacted form: plfont(ifont)\n"
16628  "\n"
16629  " This function is used in examples 1,2,4,7,13,24,26. \n"
16630  "\n"
16631  "\n"
16632  "\n"
16633  "SYNOPSIS:\n"
16634  "\n"
16635  "plfont(ifont)\n"
16636  "\n"
16637  "ARGUMENTS:\n"
16638  "\n"
16639  " ifont (PLINT, input) : Specifies the font: 1: Normal font (simplest\n"
16640  " and fastest) \n"
16641  " 2: Roman font \n"
16642  " 3: Italic font \n"
16643  " 4: Script font \n"
16644  "\n"
16645  ""},
16646  { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16647  "Load character font \n"
16648  "\n"
16649  "DESCRIPTION:\n"
16650  "\n"
16651  " Sets the character set to use for subsequent character drawing. May\n"
16652  " be called before initializing PLplot. \n"
16653  "\n"
16654  " Redacted form: plfontld(fnt)\n"
16655  "\n"
16656  " This function is used in examples 1,7. \n"
16657  "\n"
16658  "\n"
16659  "\n"
16660  "SYNOPSIS:\n"
16661  "\n"
16662  "plfontld(fnt)\n"
16663  "\n"
16664  "ARGUMENTS:\n"
16665  "\n"
16666  " fnt (PLINT, input) : Specifies the character set to load: 0:\n"
16667  " Standard character set \n"
16668  " 1: Extended character set \n"
16669  "\n"
16670  ""},
16671  { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16672  "Get character default height and current (scaled) height \n"
16673  "\n"
16674  "DESCRIPTION:\n"
16675  "\n"
16676  " Get character default height and current (scaled) height. \n"
16677  "\n"
16678  " Redacted form: plgchr(p_def, p_ht)\n"
16679  "\n"
16680  " This function is used in example 23. \n"
16681  "\n"
16682  "\n"
16683  "\n"
16684  "SYNOPSIS:\n"
16685  "\n"
16686  "plgchr(p_def, p_ht)\n"
16687  "\n"
16688  "ARGUMENTS:\n"
16689  "\n"
16690  " p_def (PLFLT *, output) : Pointer to default character height (mm). \n"
16691  "\n"
16692  " p_ht (PLFLT *, output) : Pointer to current (scaled) character\n"
16693  " height (mm). \n"
16694  "\n"
16695  ""},
16696  { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16697  "Returns 8-bit RGB values for given color index from cmap0 \n"
16698  "\n"
16699  "DESCRIPTION:\n"
16700  "\n"
16701  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16702  " PLplot documentation). Values are negative if an invalid color id is\n"
16703  " given. \n"
16704  "\n"
16705  " Redacted form: plgcol0(icol0, r, g, b)\n"
16706  "\n"
16707  " This function is used in example 2. \n"
16708  "\n"
16709  "\n"
16710  "\n"
16711  "SYNOPSIS:\n"
16712  "\n"
16713  "plgcol0(icol0, r, g, b)\n"
16714  "\n"
16715  "ARGUMENTS:\n"
16716  "\n"
16717  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16718  "\n"
16719  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16720  "\n"
16721  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16722  "\n"
16723  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16724  "\n"
16725  ""},
16726  { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16727  "Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n"
16728  "\n"
16729  "DESCRIPTION:\n"
16730  "\n"
16731  " Returns 8-bit RGB values (0-255) and double alpha transparency value\n"
16732  " (0.0 - 1.0) for given color from cmap0 (see the PLplot\n"
16733  " documentation). Values are negative if an invalid color id is given. \n"
16734  "\n"
16735  " This function is used in example 30. \n"
16736  "\n"
16737  "\n"
16738  "\n"
16739  "SYNOPSIS:\n"
16740  "\n"
16741  "plgcol0a(icol0, r, g, b, alpha)\n"
16742  "\n"
16743  "ARGUMENTS:\n"
16744  "\n"
16745  " icol0 (PLINT, input) : Index of desired cmap0 color. \n"
16746  "\n"
16747  " r (PLINT *, output) : Pointer to 8-bit red value. \n"
16748  "\n"
16749  " g (PLINT *, output) : Pointer to 8-bit green value. \n"
16750  "\n"
16751  " b (PLINT *, output) : Pointer to 8-bit blue value. \n"
16752  "\n"
16753  " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n"
16754  " value. \n"
16755  "\n"
16756  ""},
16757  { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16758  "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16759  "\n"
16760  "ESCRIPTION:\n"
16761  "\n"
16762  " Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16763  "\n"
16764  " Redacted form: plgcolbg(r, g, b)\n"
16765  "\n"
16766  " This function is used in example 31. \n"
16767  "\n"
16768  "\n"
16769  "\n"
16770  "YNOPSIS:\n"
16771  "\n"
16772  "lgcolbg(r, g, b)\n"
16773  "\n"
16774  "RGUMENTS:\n"
16775  "\n"
16776  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16777  " representing the degree of red in the color. \n"
16778  "\n"
16779  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16780  " representing the degree of green in the color. \n"
16781  "\n"
16782  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16783  " representing the degree of blue in the color. \n"
16784  "\n"
16785  ""},
16786  { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16787  "Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n"
16788  "\n"
16789  "ESCRIPTION:\n"
16790  "\n"
16791  " Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16792  " alpha transparency value. \n"
16793  "\n"
16794  " This function is used in example 31. \n"
16795  "\n"
16796  "\n"
16797  "\n"
16798  "YNOPSIS:\n"
16799  "\n"
16800  "lgcolbga(r, g, b, alpha)\n"
16801  "\n"
16802  "RGUMENTS:\n"
16803  "\n"
16804  " r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16805  " representing the degree of red in the color. \n"
16806  "\n"
16807  " g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16808  " representing the degree of green in the color. \n"
16809  "\n"
16810  " b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n"
16811  " representing the degree of blue in the color. \n"
16812  "\n"
16813  " alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n"
16814  " value. \n"
16815  "\n"
16816  ""},
16817  { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16818  "Get the current device-compression setting \n"
16819  "\n"
16820  "DESCRIPTION:\n"
16821  "\n"
16822  " Get the current device-compression setting. This parameter is only\n"
16823  " used for drivers that provide compression. \n"
16824  "\n"
16825  " Redacted form: plgcompression(compression)\n"
16826  "\n"
16827  " This function is used in example 31. \n"
16828  "\n"
16829  "\n"
16830  "\n"
16831  "SYNOPSIS:\n"
16832  "\n"
16833  "plgcompression(compression)\n"
16834  "\n"
16835  "ARGUMENTS:\n"
16836  "\n"
16837  " compression (PLINT *, output) : Pointer to a variable to be filled\n"
16838  " with the current device-compression setting. \n"
16839  "\n"
16840  ""},
16841  { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16842  "Get the current device (keyword) name \n"
16843  "\n"
16844  "DESCRIPTION:\n"
16845  "\n"
16846  " Get the current device (keyword) name. Note: you must have allocated\n"
16847  " space for this (80 characters is safe). \n"
16848  "\n"
16849  " Redacted form: plgdev(p_dev)\n"
16850  "\n"
16851  " This function is used in example 14. \n"
16852  "\n"
16853  "\n"
16854  "\n"
16855  "SYNOPSIS:\n"
16856  "\n"
16857  "plgdev(p_dev)\n"
16858  "\n"
16859  "ARGUMENTS:\n"
16860  "\n"
16861  " p_dev (char *, output) : Pointer to device (keyword) name string. \n"
16862  "\n"
16863  ""},
16864  { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16865  "Get parameters that define current device-space window \n"
16866  "\n"
16867  "DESCRIPTION:\n"
16868  "\n"
16869  " Get relative margin width, aspect ratio, and relative justification\n"
16870  " that define current device-space window. If plsdidev has not been\n"
16871  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16872  " p_jy will all be 0. \n"
16873  "\n"
16874  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16875  "\n"
16876  " This function is used in example 31. \n"
16877  "\n"
16878  "\n"
16879  "\n"
16880  "SYNOPSIS:\n"
16881  "\n"
16882  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16883  "\n"
16884  "ARGUMENTS:\n"
16885  "\n"
16886  " p_mar (PLFLT *, output) : Pointer to relative margin width. \n"
16887  "\n"
16888  " p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n"
16889  "\n"
16890  " p_jx (PLFLT *, output) : Pointer to relative justification in x. \n"
16891  "\n"
16892  " p_jy (PLFLT *, output) : Pointer to relative justification in y. \n"
16893  "\n"
16894  ""},
16895  { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16896  "Get plot orientation \n"
16897  "\n"
16898  "DESCRIPTION:\n"
16899  "\n"
16900  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16901  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16902  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16903  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16904  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16905  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16906  " not been called the default value pointed to by p_rot will be 0. \n"
16907  "\n"
16908  " Redacted form: plgdiori(p_rot)\n"
16909  "\n"
16910  " This function is not used in any examples. \n"
16911  "\n"
16912  "\n"
16913  "\n"
16914  "SYNOPSIS:\n"
16915  "\n"
16916  "plgdiori(p_rot)\n"
16917  "\n"
16918  "ARGUMENTS:\n"
16919  "\n"
16920  " p_rot (PLFLT *, output) : Pointer to orientation parameter. \n"
16921  "\n"
16922  ""},
16923  { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16924  "Get parameters that define current plot-space window \n"
16925  "\n"
16926  "DESCRIPTION:\n"
16927  "\n"
16928  " Get relative minima and maxima that define current plot-space window.\n"
16929  " If plsdiplt has not been called the default values pointed to by\n"
16930  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16931  "\n"
16932  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16933  "\n"
16934  " This function is used in example 31. \n"
16935  "\n"
16936  "\n"
16937  "\n"
16938  "SYNOPSIS:\n"
16939  "\n"
16940  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16941  "\n"
16942  "ARGUMENTS:\n"
16943  "\n"
16944  " p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n"
16945  "\n"
16946  " p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n"
16947  "\n"
16948  " p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n"
16949  "\n"
16950  " p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n"
16951  "\n"
16952  ""},
16953  { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
16954  "Get family file parameters \n"
16955  "\n"
16956  "DESCRIPTION:\n"
16957  "\n"
16958  " Gets information about current family file, if familying is enabled. \n"
16959  " See the PLplot documentation for more information. \n"
16960  "\n"
16961  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16962  "\n"
16963  " This function is used in examples 14,31. \n"
16964  "\n"
16965  "\n"
16966  "\n"
16967  "SYNOPSIS:\n"
16968  "\n"
16969  "plgfam(p_fam, p_num, p_bmax)\n"
16970  "\n"
16971  "ARGUMENTS:\n"
16972  "\n"
16973  " p_fam (PLINT *, output) : Pointer to variable with the Boolean\n"
16974  " family flag value. If nonzero, familying is enabled. \n"
16975  "\n"
16976  " p_num (PLINT *, output) : Pointer to variable with the current\n"
16977  " family file number. \n"
16978  "\n"
16979  " p_bmax (PLINT *, output) : Pointer to variable with the maximum\n"
16980  " file size (in bytes) for a family file. \n"
16981  "\n"
16982  ""},
16983  { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
16984  "Get FCI (font characterization integer) \n"
16985  "\n"
16986  "DESCRIPTION:\n"
16987  "\n"
16988  " Gets information about the current font using the FCI approach. See\n"
16989  " the PLplot documentation for more information. \n"
16990  "\n"
16991  " Redacted form: plgfci(p_fci)\n"
16992  "\n"
16993  " This function is used in example 23. \n"
16994  "\n"
16995  "\n"
16996  "\n"
16997  "SYNOPSIS:\n"
16998  "\n"
16999  "plgfci(p_fci)\n"
17000  "\n"
17001  "ARGUMENTS:\n"
17002  "\n"
17003  " p_fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n"
17004  " integer) variable which is updated with current FCI value. \n"
17005  "\n"
17006  ""},
17007  { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
17008  "Get output file name \n"
17009  "\n"
17010  "DESCRIPTION:\n"
17011  "\n"
17012  " Gets the current output file name, if applicable. \n"
17013  "\n"
17014  " Redacted form: plgfnam(fnam)\n"
17015  "\n"
17016  " This function is used in example 31. \n"
17017  "\n"
17018  "\n"
17019  "\n"
17020  "SYNOPSIS:\n"
17021  "\n"
17022  "plgfnam(fnam)\n"
17023  "\n"
17024  "ARGUMENTS:\n"
17025  "\n"
17026  " fnam (char *, output) : Pointer to file name string (a preallocated\n"
17027  " string of 80 characters or more). \n"
17028  "\n"
17029  ""},
17030  { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
17031  "Get family, style and weight of the current font \n"
17032  "\n"
17033  "DESCRIPTION:\n"
17034  "\n"
17035  " Gets information about current font. See the PLplot documentation for\n"
17036  " more information on font selection. \n"
17037  "\n"
17038  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17039  "\n"
17040  " This function is used in example 23. \n"
17041  "\n"
17042  "\n"
17043  "\n"
17044  "SYNOPSIS:\n"
17045  "\n"
17046  "plgfont(p_family, p_style, p_weight)\n"
17047  "\n"
17048  "ARGUMENTS:\n"
17049  "\n"
17050  " p_family (PLINT *, output) : Pointer to variable with the current\n"
17051  " font family. The available values are given by the PL_FCI_*\n"
17052  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17053  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17054  " p_family is NULL then the font family is not returned. \n"
17055  "\n"
17056  " p_style (PLINT *, output) : Pointer to variable with the current\n"
17057  " font style. The available values are given by the PL_FCI_*\n"
17058  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17059  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
17060  " font style is not returned. \n"
17061  "\n"
17062  " p_weight (PLINT *, output) : Pointer to variable with the current\n"
17063  " font weight. The available values are given by the PL_FCI_*\n"
17064  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17065  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17066  " returned. \n"
17067  "\n"
17068  ""},
17069  { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
17070  "Get the (current) run level \n"
17071  "\n"
17072  "DESCRIPTION:\n"
17073  "\n"
17074  " Get the (current) run level. Valid settings are: 0, uninitialized \n"
17075  " 1, initialized \n"
17076  " 2, viewport defined \n"
17077  " 3, world coordinates defined \n"
17078  "\n"
17079  "\n"
17080  " Redacted form: plglevel(p_level)\n"
17081  "\n"
17082  " This function is used in example 31. \n"
17083  "\n"
17084  "\n"
17085  "\n"
17086  "SYNOPSIS:\n"
17087  "\n"
17088  "plglevel(p_level)\n"
17089  "\n"
17090  "ARGUMENTS:\n"
17091  "\n"
17092  " p_level (PLINT *, output) : Pointer to the run level. \n"
17093  "\n"
17094  ""},
17095  { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
17096  "Get page parameters \n"
17097  "\n"
17098  "DESCRIPTION:\n"
17099  "\n"
17100  " Gets the current page configuration. The length and offset values are\n"
17101  " expressed in units that are specific to the current driver. For\n"
17102  " instance: screen drivers will usually interpret them as number of\n"
17103  " pixels, whereas printer drivers will usually use mm. \n"
17104  "\n"
17105  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17106  "\n"
17107  " This function is used in examples 14 and 31. \n"
17108  "\n"
17109  "\n"
17110  "\n"
17111  "SYNOPSIS:\n"
17112  "\n"
17113  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17114  "\n"
17115  "ARGUMENTS:\n"
17116  "\n"
17117  " p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n"
17118  "\n"
17119  " p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n"
17120  " y. \n"
17121  "\n"
17122  " p_xleng (PLINT *, output) : Pointer to x page length value. \n"
17123  "\n"
17124  " p_yleng (PLINT *, output) : Pointer to y page length value. \n"
17125  "\n"
17126  " p_xoff (PLINT *, output) : Pointer to x page offset. \n"
17127  "\n"
17128  " p_yoff (PLINT *, output) : Pointer to y page offset. \n"
17129  "\n"
17130  ""},
17131  { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
17132  "Switch to graphics screen \n"
17133  "\n"
17134  "DESCRIPTION:\n"
17135  "\n"
17136  " Sets an interactive device to graphics mode, used in conjunction with\n"
17137  " pltext to allow graphics and text to be interspersed. On a device\n"
17138  " which supports separate text and graphics windows, this command causes\n"
17139  " control to be switched to the graphics window. If already in graphics\n"
17140  " mode, this command is ignored. It is also ignored on devices which\n"
17141  " only support a single window or use a different method for shifting\n"
17142  " focus. See also pltext. \n"
17143  "\n"
17144  " Redacted form: plgra()\n"
17145  "\n"
17146  " This function is used in example 1. \n"
17147  "\n"
17148  "\n"
17149  "\n"
17150  "SYNOPSIS:\n"
17151  "\n"
17152  "plgra()\n"
17153  "\n"
17154  ""},
17155  { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
17156  "Grid data from irregularly sampled data \n"
17157  "\n"
17158  "DESCRIPTION:\n"
17159  "\n"
17160  " Real world data is frequently irregularly sampled, but all PLplot 3D\n"
17161  " plots require data placed in a uniform grid. This function takes\n"
17162  " irregularly sampled data from three input arrays x[npts], y[npts], and\n"
17163  " z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
17164  " and yg[nptsy], and returns the gridded data into output array\n"
17165  " zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n"
17166  " with the argument type which can have one parameter specified in\n"
17167  " argument data. \n"
17168  "\n"
17169  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17170  " Perl/PDL: Not available? \n"
17171  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17172  "\n"
17173  "\n"
17174  " This function is used in example 21. \n"
17175  "\n"
17176  "\n"
17177  "\n"
17178  "SYNOPSIS:\n"
17179  "\n"
17180  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17181  "\n"
17182  "ARGUMENTS:\n"
17183  "\n"
17184  " x (const PLFLT *, input) : The input x array. \n"
17185  "\n"
17186  " y (const PLFLT *, input) : The input y array. \n"
17187  "\n"
17188  " z (const PLFLT *, input) : The input z array. Each triple x[i],\n"
17189  " y[i], z[i] represents one data sample coordinate. \n"
17190  "\n"
17191  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17192  " arrays. \n"
17193  "\n"
17194  " xg (const PLFLT *, input) : The input array that specifies the grid\n"
17195  " spacing in the x direction. Usually xg has nptsx equally spaced\n"
17196  " values from the minimum to the maximum values of the x input\n"
17197  " array. \n"
17198  "\n"
17199  " nptsx (PLINT, input) : The number of points in the xg array. \n"
17200  "\n"
17201  " yg (const PLFLT *, input) : The input array that specifies the grid\n"
17202  " spacing in the y direction. Similar to the xg parameter. \n"
17203  "\n"
17204  " nptsy (PLINT, input) : The number of points in the yg array. \n"
17205  "\n"
17206  " zg (PLFLT **, output) : The output array, where data lies in the\n"
17207  " regular grid specified by xg and yg. the zg array must exist or be\n"
17208  " allocated by the user prior to the call, and must have dimension\n"
17209  " zg[nptsx][nptsy]. \n"
17210  "\n"
17211  " type (PLINT, input) : The type of gridding algorithm to use, which\n"
17212  " can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
17213  " GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
17214  " GRID_NNI: Natural Neighbors Interpolation \n"
17215  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
17216  " GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
17217  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17218  " Weighted \n"
17219  " For details of the algorithms read the source file plgridd.c. \n"
17220  "\n"
17221  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17222  " which can be specified through this argument. Currently, for\n"
17223  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17224  " use, the lower the value, the noisier (more local) the\n"
17225  " approximation is. \n"
17226  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17227  " range [1. .. 2.]. High values enable the usage of very thin\n"
17228  " triangles for interpolation, possibly resulting in error in\n"
17229  " the approximation. \n"
17230  " GRID_NNI, only weights greater than data will be accepted. If\n"
17231  " 0, all weights will be accepted. \n"
17232  "\n"
17233  ""},
17234  { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
17235  "Get current subpage parameters \n"
17236  "\n"
17237  "DESCRIPTION:\n"
17238  "\n"
17239  " Gets the size of the current subpage in millimeters measured from the\n"
17240  " bottom left hand corner of the output device page or screen. Can be\n"
17241  " used in conjunction with plsvpa for setting the size of a viewport in\n"
17242  " absolute coordinates (millimeters). \n"
17243  "\n"
17244  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17245  "\n"
17246  " This function is used in example 23. \n"
17247  "\n"
17248  "\n"
17249  "\n"
17250  "SYNOPSIS:\n"
17251  "\n"
17252  "plgspa(xmin, xmax, ymin, ymax)\n"
17253  "\n"
17254  "ARGUMENTS:\n"
17255  "\n"
17256  " xmin (PLFLT *, output) : Pointer to variable with position of left\n"
17257  " hand edge of subpage in millimeters. \n"
17258  "\n"
17259  " xmax (PLFLT *, output) : Pointer to variable with position of right\n"
17260  " hand edge of subpage in millimeters. \n"
17261  "\n"
17262  " ymin (PLFLT *, output) : Pointer to variable with position of\n"
17263  " bottom edge of subpage in millimeters. \n"
17264  "\n"
17265  " ymax (PLFLT *, output) : Pointer to variable with position of top\n"
17266  " edge of subpage in millimeters. \n"
17267  "\n"
17268  ""},
17269  { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
17270  "Get current stream number \n"
17271  "\n"
17272  "DESCRIPTION:\n"
17273  "\n"
17274  " Gets the number of the current output stream. See also plsstrm. \n"
17275  "\n"
17276  " Redacted form: plgstrm(p_strm)\n"
17277  "\n"
17278  " This function is used in example 1,20. \n"
17279  "\n"
17280  "\n"
17281  "\n"
17282  "SYNOPSIS:\n"
17283  "\n"
17284  "plgstrm(p_strm)\n"
17285  "\n"
17286  "ARGUMENTS:\n"
17287  "\n"
17288  " p_strm (PLINT *, output) : Pointer to current stream value. \n"
17289  "\n"
17290  ""},
17291  { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
17292  "Get the current library version number \n"
17293  "\n"
17294  "DESCRIPTION:\n"
17295  "\n"
17296  " Get the current library version number. Note: you must have allocated\n"
17297  " space for this (80 characters is safe). \n"
17298  "\n"
17299  " Redacted form: plgver(p_ver)\n"
17300  "\n"
17301  " This function is used in example 1. \n"
17302  "\n"
17303  "\n"
17304  "\n"
17305  "SYNOPSIS:\n"
17306  "\n"
17307  "plgver(p_ver)\n"
17308  "\n"
17309  "ARGUMENTS:\n"
17310  "\n"
17311  " p_ver (char *, output) : Pointer to the current library version\n"
17312  " number. \n"
17313  "\n"
17314  ""},
17315  { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
17316  "Get viewport limits in normalized device coordinates \n"
17317  "\n"
17318  "DESCRIPTION:\n"
17319  "\n"
17320  " Get viewport limits in normalized device coordinates. \n"
17321  "\n"
17322  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17323  " Perl/PDL: Not available? \n"
17324  "\n"
17325  "\n"
17326  " This function is used in example 31. \n"
17327  "\n"
17328  "\n"
17329  "\n"
17330  "SYNOPSIS:\n"
17331  "\n"
17332  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17333  "\n"
17334  "ARGUMENTS:\n"
17335  "\n"
17336  " p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n"
17337  " device coordinate in x. \n"
17338  "\n"
17339  " p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n"
17340  " device coordinate in x. \n"
17341  "\n"
17342  " p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n"
17343  " device coordinate in y. \n"
17344  "\n"
17345  " p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n"
17346  " device coordinate in y. \n"
17347  "\n"
17348  ""},
17349  { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
17350  "Get viewport limits in world coordinates \n"
17351  "\n"
17352  "DESCRIPTION:\n"
17353  "\n"
17354  " Get viewport limits in world coordinates. \n"
17355  "\n"
17356  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17357  " Perl/PDL: Not available? \n"
17358  "\n"
17359  "\n"
17360  " This function is used in example 31. \n"
17361  "\n"
17362  "\n"
17363  "\n"
17364  "SYNOPSIS:\n"
17365  "\n"
17366  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17367  "\n"
17368  "ARGUMENTS:\n"
17369  "\n"
17370  " p_xmin (PLFLT *, output) : Lower viewport limit of the world\n"
17371  " coordinate in x. \n"
17372  "\n"
17373  " p_xmax (PLFLT *, output) : Upper viewport limit of the world\n"
17374  " coordinate in x. \n"
17375  "\n"
17376  " p_ymin (PLFLT *, output) : Lower viewport limit of the world\n"
17377  " coordinate in y. \n"
17378  "\n"
17379  " p_ymax (PLFLT *, output) : Upper viewport limit of the world\n"
17380  " coordinate in y. \n"
17381  "\n"
17382  ""},
17383  { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
17384  "Get x axis parameters \n"
17385  "\n"
17386  "DESCRIPTION:\n"
17387  "\n"
17388  " Returns current values of the p_digmax and p_digits flags for the x\n"
17389  " axis. p_digits is updated after the plot is drawn, so this routine\n"
17390  " should only be called after the call to plbox (or plbox3) is complete.\n"
17391  " See the PLplot documentation for more information. \n"
17392  "\n"
17393  " Redacted form: plgxax(p_digmax, p_digits)\n"
17394  "\n"
17395  " This function is used in example 31. \n"
17396  "\n"
17397  "\n"
17398  "\n"
17399  "SYNOPSIS:\n"
17400  "\n"
17401  "plgxax(p_digmax, p_digits)\n"
17402  "\n"
17403  "ARGUMENTS:\n"
17404  "\n"
17405  " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17406  " number of digits for the x axis. If nonzero, the printed label\n"
17407  " has been switched to a floating point representation when the\n"
17408  " number of digits exceeds p_digmax. \n"
17409  "\n"
17410  " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17411  " number of digits for the numeric labels (x axis) from the last\n"
17412  " plot. \n"
17413  "\n"
17414  ""},
17415  { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
17416  "Get y axis parameters \n"
17417  "\n"
17418  "DESCRIPTION:\n"
17419  "\n"
17420  " Identical to plgxax, except that arguments are flags for y axis. See\n"
17421  " the description of plgxax for more detail. \n"
17422  "\n"
17423  " Redacted form: plgyax(p_digmax, p_digits)\n"
17424  "\n"
17425  " This function is used in example 31. \n"
17426  "\n"
17427  "\n"
17428  "\n"
17429  "SYNOPSIS:\n"
17430  "\n"
17431  "plgyax(p_digmax, p_digits)\n"
17432  "\n"
17433  "ARGUMENTS:\n"
17434  "\n"
17435  " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17436  " number of digits for the y axis. If nonzero, the printed label\n"
17437  " has been switched to a floating point representation when the\n"
17438  " number of digits exceeds p_digmax. \n"
17439  "\n"
17440  " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17441  " number of digits for the numeric labels (y axis) from the last\n"
17442  " plot. \n"
17443  "\n"
17444  ""},
17445  { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
17446  "Get z axis parameters \n"
17447  "\n"
17448  "DESCRIPTION:\n"
17449  "\n"
17450  " Identical to plgxax, except that arguments are flags for z axis. See\n"
17451  " the description of plgxax for more detail. \n"
17452  "\n"
17453  " Redacted form: plgzax(p_digmax, p_digits)\n"
17454  "\n"
17455  " This function is used in example 31. \n"
17456  "\n"
17457  "\n"
17458  "\n"
17459  "SYNOPSIS:\n"
17460  "\n"
17461  "plgzax(p_digmax, p_digits)\n"
17462  "\n"
17463  "ARGUMENTS:\n"
17464  "\n"
17465  " p_digmax (PLINT *, output) : Pointer to variable with the maximum\n"
17466  " number of digits for the z axis. If nonzero, the printed label\n"
17467  " has been switched to a floating point representation when the\n"
17468  " number of digits exceeds p_digmax. \n"
17469  "\n"
17470  " p_digits (PLINT *, output) : Pointer to variable with the actual\n"
17471  " number of digits for the numeric labels (z axis) from the last\n"
17472  " plot. \n"
17473  "\n"
17474  ""},
17475  { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17476  "Plot a histogram from unbinned data \n"
17477  "\n"
17478  "DESCRIPTION:\n"
17479  "\n"
17480  " Plots a histogram from n data points stored in the array data. This\n"
17481  " routine bins the data into nbin bins equally spaced between datmin and\n"
17482  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17483  " opt allows, among other things, the histogram either to be plotted in\n"
17484  " an existing window or causes plhist to call plenv with suitable limits\n"
17485  " before plotting the histogram. \n"
17486  "\n"
17487  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17488  "\n"
17489  " This function is used in example 5. \n"
17490  "\n"
17491  "\n"
17492  "\n"
17493  "SYNOPSIS:\n"
17494  "\n"
17495  "plhist(n, data, datmin, datmax, nbin, opt)\n"
17496  "\n"
17497  "ARGUMENTS:\n"
17498  "\n"
17499  " n (PLINT, input) : Number of data points. \n"
17500  "\n"
17501  " data (const PLFLT *, input) : Pointer to array with values of the n\n"
17502  " data points. \n"
17503  "\n"
17504  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n"
17505  "\n"
17506  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n"
17507  "\n"
17508  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17509  " divide the interval xmin to xmax. \n"
17510  "\n"
17511  " opt (PLINT, input) : Is a combination of several flags:\n"
17512  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17513  " the histogram data, the outer bins are expanded to fill up the\n"
17514  " entire x-axis, data outside the given extremes are assigned to the\n"
17515  " outer bins and bins of zero height are simply drawn. \n"
17516  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17517  " to fit the histogram data, without this flag, plenv is called\n"
17518  " to set the world coordinates. \n"
17519  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17520  " extremes are not taken into account. This option should\n"
17521  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17522  " properly present the data. \n"
17523  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17524  " size as the ones inside. \n"
17525  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17526  " (there is a gap for such bins). \n"
17527  "\n"
17528  ""},
17529  { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17530  "Convert HLS color to RGB \n"
17531  "\n"
17532  "DESCRIPTION:\n"
17533  "\n"
17534  " Convert HLS color coordinates to RGB. \n"
17535  "\n"
17536  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17537  " Perl/PDL: Not available? Implemented as plhls? \n"
17538  "\n"
17539  "\n"
17540  " This function is used in example 2. \n"
17541  "\n"
17542  "\n"
17543  "\n"
17544  "SYNOPSIS:\n"
17545  "\n"
17546  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17547  "\n"
17548  "ARGUMENTS:\n"
17549  "\n"
17550  " h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n"
17551  "\n"
17552  " l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n"
17553  " of the colour cone (0.0-1.0) \n"
17554  "\n"
17555  " s (PLFLT, input) : Saturation, expressed as a fraction of the\n"
17556  " radius of the colour cone (0.0-1.0) \n"
17557  "\n"
17558  " p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n"
17559  " colour \n"
17560  "\n"
17561  " p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n"
17562  " colour \n"
17563  "\n"
17564  " p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n"
17565  " colour \n"
17566  "\n"
17567  ""},
17568  { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17569  "Initialize PLplot \n"
17570  "\n"
17571  "DESCRIPTION:\n"
17572  "\n"
17573  " Initializing the plotting package. The program prompts for the device\n"
17574  " keyword or number of the desired output device. Hitting a RETURN in\n"
17575  " response to the prompt is the same as selecting the first device. \n"
17576  " plinit will issue no prompt if either the device was specified\n"
17577  " previously (via command line flag, the plsetopt function, or the\n"
17578  " plsdev function), or if only one device is enabled when PLplot is\n"
17579  " installed. If subpages have been specified, the output device is\n"
17580  " divided into nx by ny subpages, each of which may be used\n"
17581  " independently. If plinit is called again during a program, the\n"
17582  " previously opened file will be closed. The subroutine pladv is used\n"
17583  " to advance from one subpage to the next. \n"
17584  "\n"
17585  " Redacted form: plinit()\n"
17586  "\n"
17587  " This function is used in all of the examples. \n"
17588  "\n"
17589  "\n"
17590  "\n"
17591  "SYNOPSIS:\n"
17592  "\n"
17593  "plinit()\n"
17594  "\n"
17595  ""},
17596  { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17597  "Draw a line between two points \n"
17598  "\n"
17599  "DESCRIPTION:\n"
17600  "\n"
17601  " Joins the point (\n"
17602  " x1, \n"
17603  " y1) to (\n"
17604  " x2, \n"
17605  " y2). \n"
17606  "\n"
17607  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17608  "\n"
17609  " This function is used in examples 3,14. \n"
17610  "\n"
17611  "\n"
17612  "\n"
17613  "SYNOPSIS:\n"
17614  "\n"
17615  "pljoin(x1, y1, x2, y2)\n"
17616  "\n"
17617  "ARGUMENTS:\n"
17618  "\n"
17619  " x1 (PLFLT, input) : x coordinate of first point. \n"
17620  "\n"
17621  " y1 (PLFLT, input) : y coordinate of first point. \n"
17622  "\n"
17623  " x2 (PLFLT, input) : x coordinate of second point. \n"
17624  "\n"
17625  " y2 (PLFLT, input) : y coordinate of second point. \n"
17626  "\n"
17627  ""},
17628  { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17629  "Simple routine to write labels \n"
17630  "\n"
17631  "DESCRIPTION:\n"
17632  "\n"
17633  " Routine for writing simple labels. Use plmtex for more complex labels. \n"
17634  "\n"
17635  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17636  "\n"
17637  " This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
17638  "\n"
17639  "\n"
17640  "\n"
17641  "SYNOPSIS:\n"
17642  "\n"
17643  "pllab(xlabel, ylabel, tlabel)\n"
17644  "\n"
17645  "ARGUMENTS:\n"
17646  "\n"
17647  " xlabel (const char *, input) : Label for horizontal axis. \n"
17648  "\n"
17649  " ylabel (const char *, input) : Label for vertical axis. \n"
17650  "\n"
17651  " tlabel (const char *, input) : Title of graph. \n"
17652  "\n"
17653  ""},
17654  { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17655  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
17656  "\n"
17657  "DESCRIPTION:\n"
17658  "\n"
17659  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17660  " line, and/or line of symbols for each annotated legend entry. (See\n"
17661  " plcolorbar for similar functionality for creating continuous color\n"
17662  " bars.) The arguments of pllegend provide control over the location\n"
17663  " and size of the legend as well as the location and characteristics of\n"
17664  " the elements (most of which are optional) within that legend. The\n"
17665  " resulting legend is clipped at the boundaries of the current subpage. \n"
17666  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17667  " defined in the documentation of the position parameter.) \n"
17668  "\n"
17669  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17670  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17671  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17672  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17673  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17674  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17675  "\n"
17676  " This function is used in examples 4, 26, and 33. \n"
17677  "\n"
17678  "\n"
17679  "\n"
17680  "SYNOPSIS:\n"
17681  "\n"
17682  "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"
17683  "\n"
17684  "ARGUMENTS:\n"
17685  "\n"
17686  " p_legend_width (PLFLT *, output) : Pointer to a location which\n"
17687  " contains (after the call) the legend width in adopted coordinates.\n"
17688  " This quantity is calculated from plot_width, text_offset, ncolumn\n"
17689  " (possibly modified inside the routine depending on nlegend and\n"
17690  " nrow), and the length (calculated internally) of the longest text\n"
17691  " string. \n"
17692  "\n"
17693  " p_legend_height (PLFLT *, output) : Pointer to a location which\n"
17694  " contains (after the call) the legend height in adopted\n"
17695  " coordinates. This quantity is calculated from text_scale,\n"
17696  " text_spacing, and nrow (possibly modified inside the routine\n"
17697  " depending on nlegend and nrow). \n"
17698  "\n"
17699  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17700  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17701  " on the left of the legend and the plotted area on the right.\n"
17702  " Otherwise, put the text area on the right of the legend and the\n"
17703  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17704  " plot a (semi-transparent) background for the legend. If the\n"
17705  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17706  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17707  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17708  " plot the resulting array of legend entries in row-major order.\n"
17709  " Otherwise, plot the legend entries in column-major order. \n"
17710  "\n"
17711  " position (PLINT, input) : position contains bits which control the\n"
17712  " overall position of the legend and the definition of the adopted\n"
17713  " coordinates used for positions just like what is done for the\n"
17714  " position argument for plcolorbar. However, note that the defaults\n"
17715  " for the position bits (see below) are different than the\n"
17716  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17717  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17718  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17719  " the 16 possible standard positions (the 4 corners and centers of\n"
17720  " the 4 sides for both the inside and outside cases) of the legend\n"
17721  " relative to the adopted coordinate system. The corner positions\n"
17722  " are specified by the appropriate combination of two of the\n"
17723  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17724  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17725  " value of one of those bits. The adopted coordinates are\n"
17726  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17727  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17728  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17729  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17730  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17731  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17732  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17733  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
17734  "\n"
17735  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17736  " coordinates from the specified standard position of the legend.\n"
17737  " For positive x, the direction of motion away from the standard\n"
17738  " position is inward/outward from the standard corner positions or\n"
17739  " standard left or right positions if the\n"
17740  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17741  " For the standard top or bottom positions, the direction of motion\n"
17742  " is toward positive X. \n"
17743  "\n"
17744  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17745  " coordinates from the specified standard position of the legend.\n"
17746  " For positive y, the direction of motion away from the standard\n"
17747  " position is inward/outward from the standard corner positions or\n"
17748  " standard top or bottom positions if the\n"
17749  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17750  " For the standard left or right positions, the direction of motion\n"
17751  " is toward positive Y. \n"
17752  "\n"
17753  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17754  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17755  " symbols are drawn) of the legend. \n"
17756  "\n"
17757  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17758  " legend (PL_LEGEND_BACKGROUND). \n"
17759  "\n"
17760  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17761  " for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17762  "\n"
17763  " bb_style (PLINT, input) : The pllsty style number for the\n"
17764  " bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n"
17765  "\n"
17766  " nrow (PLINT, input) : The cmap0 index of the background color for\n"
17767  " the legend (PL_LEGEND_BACKGROUND). \n"
17768  "\n"
17769  " ncolumn (PLINT, input) : The cmap0 index of the background color\n"
17770  " for the legend (PL_LEGEND_BACKGROUND). \n"
17771  "\n"
17772  " nlegend (PLINT, input) : Number of legend entries. N.B. The total\n"
17773  " vertical height of the legend in adopted coordinates is calculated\n"
17774  " internally from nlegend, text_scale (see below), and text_spacing\n"
17775  " (see below). \n"
17776  "\n"
17777  " opt_array (const PLINT *, input) : Array of nlegend values of\n"
17778  " options to control each individual plotted area corresponding to a\n"
17779  " legend entry. If the \n"
17780  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17781  " area. If the \n"
17782  " PL_LEGEND_COLOR_BOX, \n"
17783  " PL_LEGEND_LINE, and/or \n"
17784  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17785  " entry is plotted with a colored box; a line; and/or a line of\n"
17786  " symbols. \n"
17787  "\n"
17788  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17789  " area in units of character width. N.B. The total horizontal\n"
17790  " width of the legend in adopted coordinates is calculated\n"
17791  " internally from \n"
17792  " plot_width (see above), \n"
17793  " text_offset, and length (calculated internally) of the longest text\n"
17794  " string. \n"
17795  "\n"
17796  " text_scale (PLFLT, input) : Character height scale for text\n"
17797  " annotations. N.B. The total vertical height of the legend in\n"
17798  " adopted coordinates is calculated internally from \n"
17799  " nlegend (see above), \n"
17800  " text_scale, and \n"
17801  " text_spacing (see below). \n"
17802  "\n"
17803  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17804  " character height from one legend entry to the next. N.B. The\n"
17805  " total vertical height of the legend in adopted coordinates is\n"
17806  " calculated internally from \n"
17807  " nlegend (see above), \n"
17808  " text_scale (see above), and \n"
17809  " text_spacing. \n"
17810  "\n"
17811  " text_justification (PLFLT, input) : Justification parameter used\n"
17812  " for text justification. The most common values of\n"
17813  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17814  " is left justified, centred, or right justified within the text\n"
17815  " area, but other values are allowed as well. \n"
17816  "\n"
17817  " text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n"
17818  " colors. \n"
17819  "\n"
17820  " text (const char * const *, input) : Array of nlegend text string\n"
17821  " annotations. \n"
17822  "\n"
17823  " box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n"
17824  " for the discrete colored boxes (\n"
17825  " PL_LEGEND_COLOR_BOX). \n"
17826  "\n"
17827  " box_patterns (const PLINT *, input) : Array of nlegend patterns\n"
17828  " (plpsty indices) for the discrete colored boxes (\n"
17829  " PL_LEGEND_COLOR_BOX). \n"
17830  "\n"
17831  " box_scales (const PLFLT *, input) : Array of nlegend scales (units\n"
17832  " of fraction of character height) for the height of the discrete\n"
17833  " colored boxes (\n"
17834  " PL_LEGEND_COLOR_BOX). \n"
17835  "\n"
17836  " box_line_widths (const PLFLT *, input) : Array of nlegend line\n"
17837  " widths for the patterns specified by box_patterns (\n"
17838  " PL_LEGEND_COLOR_BOX). \n"
17839  "\n"
17840  " line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n"
17841  " colors (\n"
17842  " PL_LEGEND_LINE). \n"
17843  "\n"
17844  " line_styles (const PLINT *, input) : Array of nlegend line styles\n"
17845  " (plsty indices) (\n"
17846  " PL_LEGEND_LINE). \n"
17847  "\n"
17848  " line_widths (const PLFLT *, input) : Array of nlegend line widths (\n"
17849  " PL_LEGEND_LINE). \n"
17850  "\n"
17851  " symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n"
17852  " symbol colors (\n"
17853  " PL_LEGEND_SYMBOL). \n"
17854  "\n"
17855  " symbol_scales (const PLFLT *, input) : Array of nlegend scale\n"
17856  " values for the symbol height (\n"
17857  " PL_LEGEND_SYMBOL). \n"
17858  "\n"
17859  " symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n"
17860  " symbols to be drawn across the width of the plotted area (\n"
17861  " PL_LEGEND_SYMBOL). \n"
17862  "\n"
17863  " symbols (const char * const *, input) : Array of nlegend symbols\n"
17864  " (plpoin indices) (\n"
17865  " PL_LEGEND_SYMBOL). \n"
17866  "\n"
17867  ""},
17868  { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
17869  "Plot color bar for image, shade or gradient plots \n"
17870  "\n"
17871  "DESCRIPTION:\n"
17872  "\n"
17873  " Routine for creating a continuous color bar for image, shade, or\n"
17874  " gradient plots. (See pllegend for similar functionality for creating\n"
17875  " legends with discrete elements). The arguments of plcolorbar provide\n"
17876  " control over the location and size of the color bar as well as the\n"
17877  " location and characteristics of the elements (most of which are\n"
17878  " optional) within that color bar. The resulting color bar is clipped\n"
17879  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17880  " system used for some of the parameters is defined in the documentation\n"
17881  " of the position parameter.) \n"
17882  "\n"
17883  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17884  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17885  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17886  " labels, axis_opts, ticks, sub_ticks, values)\n"
17887  "\n"
17888  " This function is used in examples 16 and 33. \n"
17889  "\n"
17890  "\n"
17891  "\n"
17892  "SYNOPSIS:\n"
17893  "\n"
17894  "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"
17895  "\n"
17896  "ARGUMENTS:\n"
17897  "\n"
17898  " p_colorbar_width (PLFLT *, output) : Pointer to a location which\n"
17899  " contains (after the call) the labelled and decorated color bar\n"
17900  " width in adopted coordinates. \n"
17901  "\n"
17902  " p_colorbar_height (PLFLT *, output) : Pointer to a location which\n"
17903  " contains (after the call) the labelled and decorated color bar\n"
17904  " height in adopted coordinates. \n"
17905  "\n"
17906  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17907  " color bar. The orientation (direction of the maximum value) of\n"
17908  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17909  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17910  " specified, the default orientation is toward the top if the\n"
17911  " colorbar is placed on the left or right of the viewport or toward\n"
17912  " the right if the colorbar is placed on the top or bottom of the\n"
17913  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17914  " (semi-transparent) background for the color bar. If the\n"
17915  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17916  " color bar. The type of color bar must be specified with one of\n"
17917  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17918  " more than one of those bits is set only the first one in the above\n"
17919  " list is honored. The position of the (optional) label/title can be\n"
17920  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17921  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17922  " will be drawn. If more than one of this list of bits is specified,\n"
17923  " only the first one on the list is honored. End-caps for the color\n"
17924  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17925  " If a particular color bar cap option is not specified then no cap\n"
17926  " will be drawn for that end. As a special case for\n"
17927  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17928  " specified. If this option is provided then any tick marks and tick\n"
17929  " labels will be placed at the breaks between shaded segments. TODO:\n"
17930  " This should be expanded to support custom placement of tick marks\n"
17931  " and tick labels at custom value locations for any color bar type. \n"
17932  "\n"
17933  " position (PLINT, input) : position contains bits which control the\n"
17934  " overall position of the color bar and the definition of the\n"
17935  " adopted coordinates used for positions just like what is done for\n"
17936  " the position argument for pllegend. However, note that the\n"
17937  " defaults for the position bits (see below) are different than the\n"
17938  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17939  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17940  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17941  " the 16 possible standard positions (the 4 corners and centers of\n"
17942  " the 4 sides for both the inside and outside cases) of the color\n"
17943  " bar relative to the adopted coordinate system. The corner\n"
17944  " positions are specified by the appropriate combination of two of\n"
17945  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17946  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17947  " value of one of those bits. The adopted coordinates are\n"
17948  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17949  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17950  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17951  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17952  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17953  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17954  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17955  " PL_POSITION_VIEWPORT. \n"
17956  "\n"
17957  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17958  " coordinates from the specified standard position of the color bar.\n"
17959  " For positive x, the direction of motion away from the standard\n"
17960  " position is inward/outward from the standard corner positions or\n"
17961  " standard left or right positions if the\n"
17962  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17963  " For the standard top or bottom positions, the direction of motion\n"
17964  " is toward positive X. \n"
17965  "\n"
17966  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17967  " coordinates from the specified standard position of the color bar.\n"
17968  " For positive y, the direction of motion away from the standard\n"
17969  " position is inward/outward from the standard corner positions or\n"
17970  " standard top or bottom positions if the\n"
17971  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17972  " For the standard left or right positions, the direction of motion\n"
17973  " is toward positive Y. \n"
17974  "\n"
17975  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17976  " the X direction in adopted coordinates. \n"
17977  "\n"
17978  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17979  " the Y direction in adopted coordinates. \n"
17980  "\n"
17981  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17982  " color bar (PL_COLORBAR_BACKGROUND). \n"
17983  "\n"
17984  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17985  " for the color bar (PL_COLORBAR_BOUNDING_BOX). \n"
17986  "\n"
17987  " bb_style (PLINT, input) : The pllsty style number for the\n"
17988  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n"
17989  "\n"
17990  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17991  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n"
17992  "\n"
17993  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17994  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n"
17995  "\n"
17996  " cont_color (PLINT, input) : The cmap0 contour color for\n"
17997  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17998  " it will be interpreted according to the design of plshades. \n"
17999  "\n"
18000  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18001  " plots. This is passed directly to plshades, so it will be\n"
18002  " interpreted according to the design of plshades. \n"
18003  "\n"
18004  " n_labels (PLINT, input) : Number of labels to place around the\n"
18005  " color bar. \n"
18006  "\n"
18007  " label_opts (const PLINT *, input) : Options for each of \n"
18008  " n_labels labels. \n"
18009  "\n"
18010  " labels (const char * const *, input) : n_labels text labels for the\n"
18011  " color bar. No label is drawn if no label position is specified\n"
18012  " with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18013  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18014  " corresponding label_opts field. \n"
18015  "\n"
18016  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18017  " value must be greater than 0. It is typically 1 (numerical axis\n"
18018  " labels are provided for one of the long edges of the color bar),\n"
18019  " but it can be larger if multiple numerical axis labels for the\n"
18020  " long edges of the color bar are desired. \n"
18021  "\n"
18022  " axis_opts (const char * const *, input) : An array of n_axes axis\n"
18023  " options (interpreted as for plbox) for the color bar's axis\n"
18024  " definitions. \n"
18025  "\n"
18026  " ticks (const PLFLT *, input) : An array of n_axes values of the\n"
18027  " spacing of the major tick marks (interpreted as for plbox) for the\n"
18028  " color bar's axis definitions. \n"
18029  "\n"
18030  " sub_ticks (const PLINT *, input) : An array of n_axes values of the\n"
18031  " number of subticks (interpreted as for plbox) for the color bar's\n"
18032  " axis definitions. \n"
18033  "\n"
18034  " n_values (const PLINT *, input) : An array containing the number of\n"
18035  " elements in each of the n_axes rows of the two-dimensional values\n"
18036  " array. \n"
18037  "\n"
18038  " values (const PLFLT * const *, input) : A two-dimensional array\n"
18039  " containing the numeric values for the data range represented by\n"
18040  " the color bar. For a row index of i_axis (where 0 < i_axis <\n"
18041  " n_axes), the number of elements in the row is specified by\n"
18042  " n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n"
18043  " the number of elements is 2, and the corresponding row elements of\n"
18044  " the values array are the minimum and maximum value represented by\n"
18045  " the colorbar. For PL_COLORBAR_SHADE, the number and values of the\n"
18046  " elements of a row of the values array is interpreted the same as\n"
18047  " the nlevel and clevel arguments of plshades. \n"
18048  "\n"
18049  ""},
18050  { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
18051  "Sets the 3D position of the light source \n"
18052  "\n"
18053  "DESCRIPTION:\n"
18054  "\n"
18055  " Sets the 3D position of the light source for use with plsurf3d. \n"
18056  "\n"
18057  " Redacted form: pllightsource(x, y, z)\n"
18058  "\n"
18059  " This function is used in example 8. \n"
18060  "\n"
18061  "\n"
18062  "\n"
18063  "SYNOPSIS:\n"
18064  "\n"
18065  "pllightsource(x, y, z)\n"
18066  "\n"
18067  "ARGUMENTS:\n"
18068  "\n"
18069  " x (PLFLT, input) : X-coordinate of the light source. \n"
18070  "\n"
18071  " y (PLFLT, input) : Y-coordinate of the light source. \n"
18072  "\n"
18073  " z (PLFLT, input) : Z-coordinate of the light source. \n"
18074  "\n"
18075  ""},
18076  { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
18077  "Draw a line \n"
18078  "\n"
18079  "DESCRIPTION:\n"
18080  "\n"
18081  " Draws line defined by n points in x and y. \n"
18082  "\n"
18083  " Redacted form: plline(x, y)\n"
18084  "\n"
18085  " This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
18086  "\n"
18087  "\n"
18088  "\n"
18089  "SYNOPSIS:\n"
18090  "\n"
18091  "plline(n, x, y)\n"
18092  "\n"
18093  "ARGUMENTS:\n"
18094  "\n"
18095  " n (PLINT, input) : Number of points defining line. \n"
18096  "\n"
18097  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
18098  " points. \n"
18099  "\n"
18100  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
18101  " points. \n"
18102  "\n"
18103  ""},
18104  { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
18105  "Draw a line in 3 space \n"
18106  "\n"
18107  "DESCRIPTION:\n"
18108  "\n"
18109  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18110  " first set up the viewport, the 2d viewing window (in world\n"
18111  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18112  " more info. \n"
18113  "\n"
18114  " Redacted form: plline3(x, y, z)\n"
18115  "\n"
18116  " This function is used in example 18. \n"
18117  "\n"
18118  "\n"
18119  "\n"
18120  "SYNOPSIS:\n"
18121  "\n"
18122  "plline3(n, x, y, z)\n"
18123  "\n"
18124  "ARGUMENTS:\n"
18125  "\n"
18126  " n (PLINT, input) : Number of points defining line. \n"
18127  "\n"
18128  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
18129  " points. \n"
18130  "\n"
18131  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
18132  " points. \n"
18133  "\n"
18134  " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
18135  " points. \n"
18136  "\n"
18137  ""},
18138  { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
18139  "Select line style \n"
18140  "\n"
18141  "DESCRIPTION:\n"
18142  "\n"
18143  " This sets the line style according to one of eight predefined patterns\n"
18144  " (also see plstyl). \n"
18145  "\n"
18146  " Redacted form: pllsty(lin)\n"
18147  "\n"
18148  " This function is used in examples 9,12,22,25. \n"
18149  "\n"
18150  "\n"
18151  "\n"
18152  "SYNOPSIS:\n"
18153  "\n"
18154  "pllsty(lin)\n"
18155  "\n"
18156  "ARGUMENTS:\n"
18157  "\n"
18158  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18159  " a continuous line, line style 2 is a line with short dashes and\n"
18160  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18161  " 4 has long dashes and short gaps and so on. \n"
18162  "\n"
18163  ""},
18164  { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
18165  "Plot surface mesh \n"
18166  "\n"
18167  "DESCRIPTION:\n"
18168  "\n"
18169  " Plots a surface mesh within the environment set up by plw3d. The\n"
18170  " surface is defined by the two-dimensional array z[\n"
18171  " nx][\n"
18172  " ny] , the point z[i][j] being the value of the function at (\n"
18173  " x[i], \n"
18174  " y[j]) . Note that the points in arrays x and y do not need to be\n"
18175  " equally spaced, but must be stored in ascending order. The parameter\n"
18176  " opt controls the way in which the surface is displayed. For further\n"
18177  " details see the PLplot documentation. \n"
18178  "\n"
18179  " Redacted form: plmesh(x, y, z, opt)\n"
18180  "\n"
18181  " This function is used in example 11. \n"
18182  "\n"
18183  "\n"
18184  "\n"
18185  "SYNOPSIS:\n"
18186  "\n"
18187  "plmesh(x, y, z, nx, ny, opt)\n"
18188  "\n"
18189  "ARGUMENTS:\n"
18190  "\n"
18191  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18192  " which the function is evaluated. \n"
18193  "\n"
18194  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18195  " which the function is evaluated. \n"
18196  "\n"
18197  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18198  " two-dimensional array with set of function values. \n"
18199  "\n"
18200  " nx (PLINT, input) : Number of x values at which function is\n"
18201  " evaluated. \n"
18202  "\n"
18203  " ny (PLINT, input) : Number of y values at which function is\n"
18204  " evaluated. \n"
18205  "\n"
18206  " opt (PLINT, input) : Determines the way in which the surface is\n"
18207  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18208  " function of x for each value of y[j] . \n"
18209  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18210  " for each value of x[i] . \n"
18211  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18212  " at which function is defined. \n"
18213  "\n"
18214  ""},
18215  { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
18216  "Magnitude colored plot surface mesh with contour \n"
18217  "\n"
18218  "DESCRIPTION:\n"
18219  "\n"
18220  " A more powerful form of plmesh: the surface mesh can be colored\n"
18221  " accordingly to the current z value being plotted, a contour plot can\n"
18222  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18223  " plotted function border and the base XY plane. \n"
18224  "\n"
18225  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18226  "\n"
18227  " This function is used in example 11. \n"
18228  "\n"
18229  "\n"
18230  "\n"
18231  "SYNOPSIS:\n"
18232  "\n"
18233  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18234  "\n"
18235  "ARGUMENTS:\n"
18236  "\n"
18237  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18238  " which the function is evaluated. \n"
18239  "\n"
18240  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18241  " which the function is evaluated. \n"
18242  "\n"
18243  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18244  " two-dimensional array with set of function values. \n"
18245  "\n"
18246  " nx (PLINT, input) : Number of x values at which function is\n"
18247  " evaluated. \n"
18248  "\n"
18249  " ny (PLINT, input) : Number of y values at which function is\n"
18250  " evaluated. \n"
18251  "\n"
18252  " opt (PLINT, input) : Determines the way in which the surface is\n"
18253  " represented. To specify more than one option just add the options,\n"
18254  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18255  " showing z as a function of x for each value of y[j] . \n"
18256  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18257  " for each value of x[i] . \n"
18258  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18259  " at which function is defined. \n"
18260  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18261  " the z value being plotted. The color is used from the current\n"
18262  " color map 1. \n"
18263  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18264  " using parameters \n"
18265  " nlevel and \n"
18266  " clevel. \n"
18267  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18268  " the borders of the plotted function. \n"
18269  "\n"
18270  "\n"
18271  " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18272  " the contour level spacing. \n"
18273  "\n"
18274  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18275  "\n"
18276  ""},
18277  { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
18278  "Creates a new stream and makes it the default \n"
18279  "\n"
18280  "DESCRIPTION:\n"
18281  "\n"
18282  " Creates a new stream and makes it the default. Differs from using\n"
18283  " plsstrm, in that a free stream number is found, and returned.\n"
18284  " Unfortunately, I have to start at stream 1 and work upward, since\n"
18285  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18286  " that no initial, library-opening call is required. So stream 0 must\n"
18287  " be preallocated, and there is no simple way of determining whether it\n"
18288  " is already in use or not. \n"
18289  "\n"
18290  " Redacted form: plmkstrm(p_strm)\n"
18291  "\n"
18292  " This function is used in examples 1,20. \n"
18293  "\n"
18294  "\n"
18295  "\n"
18296  "SYNOPSIS:\n"
18297  "\n"
18298  "plmkstrm(p_strm)\n"
18299  "\n"
18300  "ARGUMENTS:\n"
18301  "\n"
18302  " p_strm (PLINT *, output) : Pointer to stream number of the created\n"
18303  " stream. \n"
18304  "\n"
18305  ""},
18306  { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
18307  "Write text relative to viewport boundaries \n"
18308  "\n"
18309  "DESCRIPTION:\n"
18310  "\n"
18311  " Writes text at a specified position relative to the viewport\n"
18312  " boundaries. Text may be written inside or outside the viewport, but\n"
18313  " is clipped at the subpage boundaries. The reference point of a string\n"
18314  " lies along a line passing through the string at half the height of a\n"
18315  " capital letter. The position of the reference point along this line\n"
18316  " is determined by just, and the position of the reference point\n"
18317  " relative to the viewport is set by disp and pos. \n"
18318  "\n"
18319  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18320  " Perl/PDL: plmtex(disp, pos, just, side, text)\n"
18321  "\n"
18322  "\n"
18323  " This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
18324  "\n"
18325  "\n"
18326  "\n"
18327  "SYNOPSIS:\n"
18328  "\n"
18329  "plmtex(side, disp, pos, just, text)\n"
18330  "\n"
18331  "ARGUMENTS:\n"
18332  "\n"
18333  " side (const char *, input) : Specifies the side of the viewport\n"
18334  " along which the text is to be written. The string must be one of:\n"
18335  " b: Bottom of viewport, text written parallel to edge. \n"
18336  " bv: Bottom of viewport, text written at right angles to edge. \n"
18337  " l: Left of viewport, text written parallel to edge. \n"
18338  " lv: Left of viewport, text written at right angles to edge. \n"
18339  " r: Right of viewport, text written parallel to edge. \n"
18340  " rv: Right of viewport, text written at right angles to edge. \n"
18341  " t: Top of viewport, text written parallel to edge. \n"
18342  " tv: Top of viewport, text written at right angles to edge. \n"
18343  "\n"
18344  "\n"
18345  " disp (PLFLT, input) : Position of the reference point of string,\n"
18346  " measured outwards from the specified viewport edge in units of the\n"
18347  " current character height. Use negative disp to write within the\n"
18348  " viewport. \n"
18349  "\n"
18350  " pos (PLFLT, input) : Position of the reference point of string\n"
18351  " along the specified edge, expressed as a fraction of the length of\n"
18352  " the edge. \n"
18353  "\n"
18354  " just (PLFLT, input) : Specifies the position of the string relative\n"
18355  " to its reference point. If just=0. , the reference point is at\n"
18356  " the left and if just=1. , it is at the right of the string. Other\n"
18357  " values of just give intermediate justifications. \n"
18358  "\n"
18359  " text (const char *, input) : The string to be written out. \n"
18360  "\n"
18361  ""},
18362  { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
18363  "Write text relative to viewport boundaries in 3D plots \n"
18364  "\n"
18365  "DESCRIPTION:\n"
18366  "\n"
18367  " Writes text at a specified position relative to the viewport\n"
18368  " boundaries. Text may be written inside or outside the viewport, but\n"
18369  " is clipped at the subpage boundaries. The reference point of a string\n"
18370  " lies along a line passing through the string at half the height of a\n"
18371  " capital letter. The position of the reference point along this line\n"
18372  " is determined by just, and the position of the reference point\n"
18373  " relative to the viewport is set by disp and pos. \n"
18374  "\n"
18375  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18376  "\n"
18377  " This function is used in example 28. \n"
18378  "\n"
18379  "\n"
18380  "\n"
18381  "SYNOPSIS:\n"
18382  "\n"
18383  "plmtex3(side, disp, pos, just, text)\n"
18384  "\n"
18385  "ARGUMENTS:\n"
18386  "\n"
18387  " side (const char *, input) : Specifies the side of the viewport\n"
18388  " along which the text is to be written. The string should contain\n"
18389  " one or more of the following characters: [xyz][ps][v]. Only one\n"
18390  " label is drawn at a time, i.e. xyp will only label the X axis, not\n"
18391  " both the X and Y axes. x: Label the X axis. \n"
18392  " y: Label the Y axis. \n"
18393  " z: Label the Z axis. \n"
18394  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18395  " For X it is the axis that starts at y-min. For Y it is the\n"
18396  " axis that starts at x-min. \n"
18397  " s: Label the secondary axis. \n"
18398  " v: Draw the text perpendicular to the axis. \n"
18399  "\n"
18400  "\n"
18401  " disp (PLFLT, input) : Position of the reference point of string,\n"
18402  " measured outwards from the specified viewport edge in units of the\n"
18403  " current character height. Use negative disp to write within the\n"
18404  " viewport. \n"
18405  "\n"
18406  " pos (PLFLT, input) : Position of the reference point of string\n"
18407  " along the specified edge, expressed as a fraction of the length of\n"
18408  " the edge. \n"
18409  "\n"
18410  " just (PLFLT, input) : Specifies the position of the string relative\n"
18411  " to its reference point. If just=0. , the reference point is at\n"
18412  " the left and if just=1. , it is at the right of the string. Other\n"
18413  " values of just give intermediate justifications. \n"
18414  "\n"
18415  " text (const char *, input) : The string to be written out. \n"
18416  "\n"
18417  ""},
18418  { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
18419  "Plot 3-d surface plot \n"
18420  "\n"
18421  "DESCRIPTION:\n"
18422  "\n"
18423  " Plots a three dimensional surface plot within the environment set up\n"
18424  " by plw3d. The surface is defined by the two-dimensional array z[\n"
18425  " nx][\n"
18426  " ny] , the point z[i][j] being the value of the function at (\n"
18427  " x[i], \n"
18428  " y[j]) . Note that the points in arrays x and y do not need to be\n"
18429  " equally spaced, but must be stored in ascending order. The parameter\n"
18430  " opt controls the way in which the surface is displayed. For further\n"
18431  " details see the PLplot documentation. The only difference between\n"
18432  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18433  " while plot3d only draws the surface as viewed from the top. \n"
18434  "\n"
18435  " Redacted form: plot3d(x, y, z, opt, side)\n"
18436  "\n"
18437  " This function is used in examples 11,21. \n"
18438  "\n"
18439  "\n"
18440  "\n"
18441  "SYNOPSIS:\n"
18442  "\n"
18443  "plot3d(x, y, z, nx, ny, opt, side)\n"
18444  "\n"
18445  "ARGUMENTS:\n"
18446  "\n"
18447  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18448  " which the function is evaluated. \n"
18449  "\n"
18450  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18451  " which the function is evaluated. \n"
18452  "\n"
18453  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18454  " two-dimensional array with set of function values. \n"
18455  "\n"
18456  " nx (PLINT, input) : Number of x values at which function is\n"
18457  " evaluated. \n"
18458  "\n"
18459  " ny (PLINT, input) : Number of y values at which function is\n"
18460  " evaluated. \n"
18461  "\n"
18462  " opt (PLINT, input) : Determines the way in which the surface is\n"
18463  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18464  " function of x for each value of y[j] . \n"
18465  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18466  " for each value of x[i] . \n"
18467  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18468  " at which function is defined. \n"
18469  "\n"
18470  "\n"
18471  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18472  " should be draw on the figure. If side is true sides are drawn,\n"
18473  " otherwise no sides are drawn. \n"
18474  "\n"
18475  ""},
18476  { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18477  "Magnitude colored plot surface with contour \n"
18478  "\n"
18479  "DESCRIPTION:\n"
18480  "\n"
18481  " Aside from dropping the \n"
18482  " side functionality this is a more powerful form of plot3d: the surface\n"
18483  " mesh can be colored accordingly to the current z value being plotted,\n"
18484  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18485  " drawn between the plotted function border and the base XY plane. The\n"
18486  " arguments are identical to those of plmeshc. The only difference\n"
18487  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18488  " the surface, while plot3dc only draws the surface as viewed from the\n"
18489  " top. \n"
18490  "\n"
18491  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18492  " Perl/PDL: Not available? \n"
18493  "\n"
18494  "\n"
18495  " This function is used in example 21. \n"
18496  "\n"
18497  "\n"
18498  "\n"
18499  "SYNOPSIS:\n"
18500  "\n"
18501  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18502  "\n"
18503  "ARGUMENTS:\n"
18504  "\n"
18505  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18506  " which the function is evaluated. \n"
18507  "\n"
18508  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18509  " which the function is evaluated. \n"
18510  "\n"
18511  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18512  " two-dimensional array with set of function values. \n"
18513  "\n"
18514  " nx (PLINT, input) : Number of x values at which function is\n"
18515  " evaluated. \n"
18516  "\n"
18517  " ny (PLINT, input) : Number of y values at which function is\n"
18518  " evaluated. \n"
18519  "\n"
18520  " opt (PLINT, input) : Determines the way in which the surface is\n"
18521  " represented. To specify more than one option just add the options,\n"
18522  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18523  " showing z as a function of x for each value of y[j] . \n"
18524  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18525  " for each value of x[i] . \n"
18526  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18527  " at which function is defined. \n"
18528  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18529  " the z value being plotted. The color is used from the current\n"
18530  " color map 1. \n"
18531  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18532  " using parameters \n"
18533  " nlevel and \n"
18534  " clevel. \n"
18535  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18536  " the borders of the plotted function. \n"
18537  "\n"
18538  "\n"
18539  " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18540  " the contour level spacing. \n"
18541  "\n"
18542  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18543  "\n"
18544  ""},
18545  { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18546  "Magnitude colored plot surface with contour for z[x][y] with y index limits \n"
18547  "\n"
18548  "DESCRIPTION:\n"
18549  "\n"
18550  " When the implementation is completed this variant of plot3dc (see that\n"
18551  " function's documentation for more details) should be suitable for the\n"
18552  " case where the area of the x, y coordinate grid where z is defined can\n"
18553  " be non-rectangular. The implementation is incomplete so the last 4\n"
18554  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18555  " indexymax; are currently ignored and the functionality is otherwise\n"
18556  " identical to that of plot3dc. \n"
18557  "\n"
18558  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18559  " indexymin, indexymax) \n"
18560  " Perl/PDL: Not available? \n"
18561  "\n"
18562  "\n"
18563  " This function is not used in any example. \n"
18564  "\n"
18565  "\n"
18566  "\n"
18567  "SYNOPSIS:\n"
18568  "\n"
18569  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18570  "\n"
18571  "ARGUMENTS:\n"
18572  "\n"
18573  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18574  " which the function is evaluated. \n"
18575  "\n"
18576  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18577  " which the function is evaluated. \n"
18578  "\n"
18579  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18580  " two-dimensional array with set of function values. \n"
18581  "\n"
18582  " nx (PLINT, input) : Number of x values at which the function is\n"
18583  " evaluated. \n"
18584  "\n"
18585  " ny (PLINT, input) : Number of y values at which the function is\n"
18586  " evaluated. \n"
18587  "\n"
18588  " opt (PLINT, input) : Determines the way in which the surface is\n"
18589  " represented. To specify more than one option just add the options,\n"
18590  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18591  " showing z as a function of x for each value of y[j] . \n"
18592  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18593  " for each value of x[i] . \n"
18594  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18595  " at which function is defined. \n"
18596  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18597  " the z value being plotted. The color is used from the current\n"
18598  " color map 1. \n"
18599  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18600  " using parameters \n"
18601  " nlevel and \n"
18602  " clevel. \n"
18603  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18604  " the borders of the plotted function. \n"
18605  "\n"
18606  "\n"
18607  " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18608  " the contour level spacing. \n"
18609  "\n"
18610  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18611  "\n"
18612  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18613  " corresponds to the first x index where z is defined. \n"
18614  "\n"
18615  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18616  " which corresponds (by convention) to one more than the last x\n"
18617  " index value where z is defined. \n"
18618  "\n"
18619  " indexymin (const PLINT *, input) : Array of y index values which\n"
18620  " all must be ≥ 0. These values are the first y index where z is\n"
18621  " defined for a particular x index in the range from indexxmin to\n"
18622  " indexxmax - 1. The dimension of indexymin is indexxmax. \n"
18623  "\n"
18624  " indexymax (const PLINT *, input) : Array of y index values which\n"
18625  " all must be ≤ ny. These values correspond (by convention) to one\n"
18626  " more than the last y index where z is defined for a particular x\n"
18627  " index in the range from indexxmin to indexxmax - 1. The dimension\n"
18628  " of indexymax is indexxmax. \n"
18629  "\n"
18630  ""},
18631  { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18632  "Plot shaded 3-d surface plot \n"
18633  "\n"
18634  "DESCRIPTION:\n"
18635  "\n"
18636  " Plots a three dimensional shaded surface plot within the environment\n"
18637  " set up by plw3d. The surface is defined by the two-dimensional array\n"
18638  " z[\n"
18639  " nx][\n"
18640  " ny] , the point z[i][j] being the value of the function at (\n"
18641  " x[i], \n"
18642  " y[j]) . Note that the points in arrays x and y do not need to be\n"
18643  " equally spaced, but must be stored in ascending order. For further\n"
18644  " details see the PLplot documentation. \n"
18645  "\n"
18646  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18647  "\n"
18648  " This function is not used in any examples. \n"
18649  "\n"
18650  "\n"
18651  "\n"
18652  "SYNOPSIS:\n"
18653  "\n"
18654  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18655  "\n"
18656  "ARGUMENTS:\n"
18657  "\n"
18658  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18659  " which the function is evaluated. \n"
18660  "\n"
18661  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18662  " which the function is evaluated. \n"
18663  "\n"
18664  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18665  " two-dimensional array with set of function values. \n"
18666  "\n"
18667  " nx (PLINT, input) : Number of x values at which function is\n"
18668  " evaluated. \n"
18669  "\n"
18670  " ny (PLINT, input) : Number of y values at which function is\n"
18671  " evaluated. \n"
18672  "\n"
18673  " opt (PLINT, input) : Determines the way in which the surface is\n"
18674  " represented. To specify more than one option just add the options,\n"
18675  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18676  " connecting points at which function is defined. \n"
18677  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18678  " using parameters \n"
18679  " nlevel and \n"
18680  " clevel. \n"
18681  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18682  " using parameters \n"
18683  " nlevel and \n"
18684  " clevel. \n"
18685  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18686  " the borders of the plotted function. \n"
18687  " opt=MAG_COLOR : the surface is colored according to the value\n"
18688  " of Z; if MAG_COLOR is not used, then the default the surface\n"
18689  " is colored according to the intensity of the reflected light\n"
18690  " in the surface from a light source whose position is set using\n"
18691  " pllightsource. \n"
18692  "\n"
18693  "\n"
18694  " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18695  " the contour level spacing. \n"
18696  "\n"
18697  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18698  "\n"
18699  ""},
18700  { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18701  "Plot shaded 3-d surface plot for z[x][y] with y index limits \n"
18702  "\n"
18703  "DESCRIPTION:\n"
18704  "\n"
18705  " This variant of plsurf3d (see that function's documentation for more\n"
18706  " details) should be suitable for the case where the area of the x, y\n"
18707  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18708  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18709  " indexymin, and indexymax. \n"
18710  "\n"
18711  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18712  " indexymax) \n"
18713  "\n"
18714  " This function is used in example 8. \n"
18715  "\n"
18716  "\n"
18717  "\n"
18718  "SYNOPSIS:\n"
18719  "\n"
18720  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18721  "\n"
18722  "ARGUMENTS:\n"
18723  "\n"
18724  " x (const PLFLT *, input) : Pointer to set of x coordinate values at\n"
18725  " which the function is evaluated. \n"
18726  "\n"
18727  " y (const PLFLT *, input) : Pointer to set of y coordinate values at\n"
18728  " which the function is evaluated. \n"
18729  "\n"
18730  " z (const PLFLT * const *, input) : Pointer to a vectored\n"
18731  " two-dimensional array with set of function values. \n"
18732  "\n"
18733  " nx (PLINT, input) : Number of x values at which function is\n"
18734  " evaluated. \n"
18735  "\n"
18736  " ny (PLINT, input) : Number of y values at which function is\n"
18737  " evaluated. \n"
18738  "\n"
18739  " opt (PLINT, input) : Determines the way in which the surface is\n"
18740  " represented. To specify more than one option just add the options,\n"
18741  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18742  " connecting points at which function is defined. \n"
18743  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18744  " using parameters \n"
18745  " nlevel and \n"
18746  " clevel. \n"
18747  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18748  " using parameters \n"
18749  " nlevel and \n"
18750  " clevel. \n"
18751  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18752  " the borders of the plotted function. \n"
18753  " opt=MAG_COLOR : the surface is colored according to the value\n"
18754  " of Z; if MAG_COLOR is not used, then the default the surface\n"
18755  " is colored according to the intensity of the reflected light\n"
18756  " in the surface from a light source whose position is set using\n"
18757  " pllightsource. \n"
18758  "\n"
18759  "\n"
18760  " clevel (const PLFLT *, input) : Pointer to the array that defines\n"
18761  " the contour level spacing. \n"
18762  "\n"
18763  " nlevel (PLINT, input) : Number of elements in the clevel array. \n"
18764  "\n"
18765  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18766  " corresponds to the first x index where z is defined. \n"
18767  "\n"
18768  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18769  " which corresponds (by convention) to one more than the last x\n"
18770  " index value where z is defined. \n"
18771  "\n"
18772  " indexymin (const PLINT *, input) : Array of y index values which\n"
18773  " all must be ≥ 0. These values are the first y index where z is\n"
18774  " defined for a particular x index in the range from indexxmin to\n"
18775  " indexxmax - 1. The dimension of indexymin is indexxmax. \n"
18776  "\n"
18777  " indexymax (const PLINT *, input) : Array of y index values which\n"
18778  " all must be ≤ ny. These values correspond (by convention) to one\n"
18779  " more than the last y index where z is defined for a particular x\n"
18780  " index in the range from indexxmin to indexxmax - 1. The dimension\n"
18781  " of indexymax is indexxmax. \n"
18782  "\n"
18783  ""},
18784  { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
18785  "Parse command-line arguments \n"
18786  "\n"
18787  "DESCRIPTION:\n"
18788  "\n"
18789  " Parse command-line arguments. \n"
18790  "\n"
18791  " plparseopts removes all recognized flags (decreasing argc\n"
18792  " accordingly), so that invalid input may be readily detected. It can\n"
18793  " also be used to process user command line flags. The user can merge\n"
18794  " an option table of type PLOptionTable into the internal option table\n"
18795  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18796  " the external table(s) be parsed by calling plClearOpts before\n"
18797  " plMergeOpts. \n"
18798  "\n"
18799  " The default action taken by plparseopts is as follows: \n"
18800  " Returns with an error if an unrecognized option or badly formed\n"
18801  " option-value pair are encountered. \n"
18802  " Returns immediately (return code 0) when the first non-option command\n"
18803  " line argument is found. \n"
18804  " Returns with the return code of the option handler, if one was called.\n"
18805  " \n"
18806  " Deletes command line arguments from argv list as they are found, and\n"
18807  " decrements argc accordingly. \n"
18808  " Does not show \"invisible\" options in usage or help messages. \n"
18809  " Assumes the program name is contained in argv[0]. \n"
18810  "\n"
18811  " These behaviors may be controlled through the \n"
18812  " mode argument. \n"
18813  "\n"
18814  " Redacted form: General: plparseopts(argv, mode)\n"
18815  " Perl/PDL: Not available? \n"
18816  "\n"
18817  "\n"
18818  " This function is used in all of the examples. \n"
18819  "\n"
18820  "\n"
18821  "\n"
18822  "SYNOPSIS:\n"
18823  "\n"
18824  "int plparseopts(p_argc, argv, mode)\n"
18825  "\n"
18826  "ARGUMENTS:\n"
18827  "\n"
18828  " p_argc (int *, input) : pointer to number of arguments. \n"
18829  "\n"
18830  " argv (const char **, input) : Pointer to character array containing\n"
18831  " *p_argc command-line arguments. \n"
18832  "\n"
18833  " mode (PLINT, input) : Parsing mode with the following\n"
18834  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18835  " and all error messages enabled, including program exit when an\n"
18836  " error occurs. Anything on the command line that isn't recognized\n"
18837  " as a valid option or option argument is flagged as an error. \n"
18838  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18839  " of errors. \n"
18840  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18841  " arguments. \n"
18842  " PL_PARSE_SHOWALL (8) -- Show invisible options \n"
18843  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18844  " pointer to the program name. \n"
18845  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
18846  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18847  " unrecognized arguments. \n"
18848  "\n"
18849  ""},
18850  { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
18851  "Set area fill pattern \n"
18852  "\n"
18853  "DESCRIPTION:\n"
18854  "\n"
18855  " Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n"
18856  " parallel lines with specified inclinations and spacings. The\n"
18857  " arguments to this routine are the number of sets to use (1 or 2)\n"
18858  " followed by two pointers to integer arrays (of 1 or 2 elements)\n"
18859  " specifying the inclinations in tenths of a degree and the spacing in\n"
18860  " micrometers. (also see plpsty) \n"
18861  "\n"
18862  " Redacted form: General: plpat(inc, del)\n"
18863  " Perl/PDL: plpat(nlin, inc, del)\n"
18864  "\n"
18865  "\n"
18866  " This function is used in example 15. \n"
18867  "\n"
18868  "\n"
18869  "\n"
18870  "SYNOPSIS:\n"
18871  "\n"
18872  "plpat(nlin, inc, del)\n"
18873  "\n"
18874  "ARGUMENTS:\n"
18875  "\n"
18876  " nlin (PLINT, input) : Number of sets of lines making up the\n"
18877  " pattern, either 1 or 2. \n"
18878  "\n"
18879  " inc (const PLINT *, input) : Pointer to array with nlin elements.\n"
18880  " Specifies the line inclination in tenths of a degree. (Should be\n"
18881  " between -900 and 900). \n"
18882  "\n"
18883  " del (const PLINT *, input) : Pointer to array with nlin elements.\n"
18884  " Specifies the spacing in micrometers between the lines making up\n"
18885  " the pattern. \n"
18886  "\n"
18887  ""},
18888  { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
18889  "Draw a line between two points, accounting for coordinate transforms \n"
18890  "\n"
18891  "DESCRIPTION:\n"
18892  "\n"
18893  " Joins the point (\n"
18894  " x1, \n"
18895  " y1) to (\n"
18896  " x2, \n"
18897  " y2) . If a global coordinate transform is defined then the line is\n"
18898  " broken in to n segments to approximate the path. If no transform is\n"
18899  " defined then this simply acts like a call to pljoin. \n"
18900  "\n"
18901  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18902  "\n"
18903  " This function is used in example 22. \n"
18904  "\n"
18905  "\n"
18906  "\n"
18907  "SYNOPSIS:\n"
18908  "\n"
18909  "plpath(n, x1, y1, x2, y2)\n"
18910  "\n"
18911  "ARGUMENTS:\n"
18912  "\n"
18913  " n (PLINT, input) : number of points to use to approximate the path. \n"
18914  "\n"
18915  " x1 (PLFLT, input) : x coordinate of first point. \n"
18916  "\n"
18917  " y1 (PLFLT, input) : y coordinate of first point. \n"
18918  "\n"
18919  " x2 (PLFLT, input) : x coordinate of second point. \n"
18920  "\n"
18921  " y2 (PLFLT, input) : y coordinate of second point. \n"
18922  "\n"
18923  ""},
18924  { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
18925  "Plot a glyph at the specified points \n"
18926  "\n"
18927  "DESCRIPTION:\n"
18928  "\n"
18929  " Plot a glyph at the specified points. (This function is largely\n"
18930  " superseded by plstring which gives access to many[!] more glyphs.)\n"
18931  " code=-1 means try to just draw a point. Right now it's just a move\n"
18932  " and a draw at the same place. Not ideal, since a sufficiently\n"
18933  " intelligent output device may optimize it away, or there may be faster\n"
18934  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18935  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18936  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18937  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18938  " code <= 127 the corresponding printable ASCII character is plotted. \n"
18939  "\n"
18940  " Redacted form: plpoin(x, y, code)\n"
18941  "\n"
18942  " This function is used in examples 1,6,14,29. \n"
18943  "\n"
18944  "\n"
18945  "\n"
18946  "SYNOPSIS:\n"
18947  "\n"
18948  "plpoin(n, x, y, code)\n"
18949  "\n"
18950  "ARGUMENTS:\n"
18951  "\n"
18952  " n (PLINT, input) : Number of points in the x and y arrays. \n"
18953  "\n"
18954  " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
18955  " of points. \n"
18956  "\n"
18957  " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
18958  " of points. \n"
18959  "\n"
18960  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18961  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18962  " each of the n points. \n"
18963  "\n"
18964  ""},
18965  { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
18966  "Plot a glyph at the specified 3D points \n"
18967  "\n"
18968  "DESCRIPTION:\n"
18969  "\n"
18970  " Plot a glyph at the specified 3D points. (This function is largely\n"
18971  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18972  " Set up the call to this function similar to what is done for plline3.\n"
18973  " code=-1 means try to just draw a point. Right now it's just a move\n"
18974  " and a draw at the same place. Not ideal, since a sufficiently\n"
18975  " intelligent output device may optimize it away, or there may be faster\n"
18976  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18977  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18978  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18979  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18980  " code <= 127 the corresponding printable ASCII character is plotted. \n"
18981  "\n"
18982  " Redacted form: plpoin3(x, y, z, code)\n"
18983  "\n"
18984  " This function is not used in any example. \n"
18985  "\n"
18986  "\n"
18987  "\n"
18988  "SYNOPSIS:\n"
18989  "\n"
18990  "plpoin3(n, x, y, z, code)\n"
18991  "\n"
18992  "ARGUMENTS:\n"
18993  "\n"
18994  " n (PLINT, input) : Number of points in the x and y arrays. \n"
18995  "\n"
18996  " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
18997  " of points. \n"
18998  "\n"
18999  " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
19000  " of points. \n"
19001  "\n"
19002  " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n"
19003  " of points. \n"
19004  "\n"
19005  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19006  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19007  " each of the n points. \n"
19008  "\n"
19009  ""},
19010  { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
19011  "Draw a polygon in 3 space \n"
19012  "\n"
19013  "DESCRIPTION:\n"
19014  "\n"
19015  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19016  " like plline3, but differs from that function in that plpoly3 attempts\n"
19017  " to determine if the polygon is viewable depending on the order of the\n"
19018  " points within the arrays and the value of ifcc. If the back of\n"
19019  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19020  " you want, then use plline3 instead. \n"
19021  "\n"
19022  " The points are assumed to be in a plane, and the directionality of the\n"
19023  " plane is determined from the first three points. Additional points do\n"
19024  " not have to lie on the plane defined by the first three, but if they\n"
19025  " do not, then the determination of visibility obviously can't be 100%\n"
19026  " accurate... So if you're 3 space polygons are too far from planar,\n"
19027  " consider breaking them into smaller polygons. 3 points define a plane\n"
19028  " :-). \n"
19029  "\n"
19030  " Bugs: If one of the first two segments is of zero length, or if they\n"
19031  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19032  " being correct. Avoid such situations :-). See x18c.c for an example\n"
19033  " of this problem. (Search for 20.1). \n"
19034  "\n"
19035  " Redacted form: plpoly3(x, y, z, code)\n"
19036  "\n"
19037  " This function is used in example 18. \n"
19038  "\n"
19039  "\n"
19040  "\n"
19041  "SYNOPSIS:\n"
19042  "\n"
19043  "plpoly3(n, x, y, z, draw, ifcc)\n"
19044  "\n"
19045  "ARGUMENTS:\n"
19046  "\n"
19047  " n (PLINT, input) : Number of points defining line. \n"
19048  "\n"
19049  " x (const PLFLT *, input) : Pointer to array with x coordinates of\n"
19050  " points. \n"
19051  "\n"
19052  " y (const PLFLT *, input) : Pointer to array with y coordinates of\n"
19053  " points. \n"
19054  "\n"
19055  " z (const PLFLT *, input) : Pointer to array with z coordinates of\n"
19056  " points. \n"
19057  "\n"
19058  " draw (const PLBOOL *, input) : Pointer to array which controls\n"
19059  " drawing the segments of the polygon. If draw[i] is true, then the\n"
19060  " polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n"
19061  "\n"
19062  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19063  " polygon is determined by assuming the points are laid out in a\n"
19064  " counter-clockwise order. Otherwise, the directionality of the\n"
19065  " polygon is determined by assuming the points are laid out in a\n"
19066  " clockwise order. \n"
19067  "\n"
19068  ""},
19069  { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
19070  "Set precision in numeric labels \n"
19071  "\n"
19072  "DESCRIPTION:\n"
19073  "\n"
19074  " Sets the number of places after the decimal point in numeric labels. \n"
19075  "\n"
19076  " Redacted form: plprec(setp, prec)\n"
19077  "\n"
19078  " This function is used in example 29. \n"
19079  "\n"
19080  "\n"
19081  "\n"
19082  "SYNOPSIS:\n"
19083  "\n"
19084  "plprec(setp, prec)\n"
19085  "\n"
19086  "ARGUMENTS:\n"
19087  "\n"
19088  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19089  " automatically determines the number of places to use after the\n"
19090  " decimal point in numeric labels (like those used to label axes). \n"
19091  " If setp is 1 then prec sets the number of places. \n"
19092  "\n"
19093  " prec (PLINT, input) : The number of characters to draw after the\n"
19094  " decimal point in numeric labels. \n"
19095  "\n"
19096  ""},
19097  { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
19098  "Select area fill pattern \n"
19099  "\n"
19100  "DESCRIPTION:\n"
19101  "\n"
19102  " Select one of eight predefined area fill patterns to use (also see\n"
19103  " plpat). Setting the fill style to 0 gives a solid fill. \n"
19104  "\n"
19105  " Redacted form: plpsty(patt)\n"
19106  "\n"
19107  " This function is used in examples 12,13,15,16,25. \n"
19108  "\n"
19109  "\n"
19110  "\n"
19111  "SYNOPSIS:\n"
19112  "\n"
19113  "plpsty(patt)\n"
19114  "\n"
19115  "ARGUMENTS:\n"
19116  "\n"
19117  " patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n"
19118  " horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
19119  " consists of lines at 45 degrees angle (upward), and so on. \n"
19120  "\n"
19121  ""},
19122  { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
19123  "Write text inside the viewport \n"
19124  "\n"
19125  "DESCRIPTION:\n"
19126  "\n"
19127  " Writes text at a specified position and inclination within the\n"
19128  " viewport. Text is clipped at the viewport boundaries. The reference\n"
19129  " point of a string lies along a line passing through the string at half\n"
19130  " the height of a capital letter. The position of the reference point\n"
19131  " along this line is determined by just, the reference point is placed\n"
19132  " at world coordinates (\n"
19133  " x, \n"
19134  " y) within the viewport. The inclination of the string is specified\n"
19135  " in terms of differences of world coordinates making it easy to write\n"
19136  " text parallel to a line in a graph. \n"
19137  "\n"
19138  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19139  "\n"
19140  " This function is used in example 2-4,10,12-14,20,23,24,26. \n"
19141  "\n"
19142  "\n"
19143  "\n"
19144  "SYNOPSIS:\n"
19145  "\n"
19146  "plptex(x, y, dx, dy, just, text)\n"
19147  "\n"
19148  "ARGUMENTS:\n"
19149  "\n"
19150  " x (PLFLT, input) : x coordinate of reference point of string. \n"
19151  "\n"
19152  " y (PLFLT, input) : y coordinate of reference point of string. \n"
19153  "\n"
19154  " dx (PLFLT, input) : Together with dy, this specifies the\n"
19155  " inclination of the string. The baseline of the string is parallel\n"
19156  " to a line joining (\n"
19157  " x, \n"
19158  " y) to (\n"
19159  " x+\n"
19160  " dx, \n"
19161  " y+\n"
19162  " dy) . \n"
19163  "\n"
19164  " dy (PLFLT, input) : Together with dx, this specifies the\n"
19165  " inclination of the string. \n"
19166  "\n"
19167  " just (PLFLT, input) : Specifies the position of the string relative\n"
19168  " to its reference point. If just=0. , the reference point is at\n"
19169  " the left and if just=1. , it is at the right of the string. Other\n"
19170  " values of just give intermediate justifications. \n"
19171  "\n"
19172  " text (const char *, input) : The string to be written out. \n"
19173  "\n"
19174  ""},
19175  { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
19176  "Write text inside the viewport of a 3D plot \n"
19177  "\n"
19178  "DESCRIPTION:\n"
19179  "\n"
19180  " Writes text at a specified position and inclination and with a\n"
19181  " specified shear within the viewport. Text is clipped at the viewport\n"
19182  " boundaries. The reference point of a string lies along a line passing\n"
19183  " through the string at half the height of a capital letter. The\n"
19184  " position of the reference point along this line is determined by just,\n"
19185  " and the reference point is placed at world coordinates (\n"
19186  " wx, \n"
19187  " wy, \n"
19188  " wz) within the viewport. The inclination and shear of the string is\n"
19189  " specified in terms of differences of world coordinates making it easy\n"
19190  " to write text parallel to a line in a graph. \n"
19191  "\n"
19192  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n"
19193  "\n"
19194  " This function is used in example 28. \n"
19195  "\n"
19196  "\n"
19197  "\n"
19198  "SYNOPSIS:\n"
19199  "\n"
19200  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19201  "\n"
19202  "ARGUMENTS:\n"
19203  "\n"
19204  " wx (PLFLT, input) : x world coordinate of reference point of\n"
19205  " string. \n"
19206  "\n"
19207  " wy (PLFLT, input) : y world coordinate of reference point of\n"
19208  " string. \n"
19209  "\n"
19210  " wz (PLFLT, input) : z world coordinate of reference point of\n"
19211  " string. \n"
19212  "\n"
19213  " dx (PLFLT, input) : Together with dy and \n"
19214  " dz , this specifies the inclination of the string. The baseline of\n"
19215  " the string is parallel to a line joining (\n"
19216  " x, \n"
19217  " y, \n"
19218  " z) to (\n"
19219  " x+\n"
19220  " dx, \n"
19221  " y+\n"
19222  " dy, \n"
19223  " z+\n"
19224  " dz) . \n"
19225  "\n"
19226  " dy (PLFLT, input) : Together with dx and \n"
19227  " dz, this specifies the inclination of the string. \n"
19228  "\n"
19229  " dz (PLFLT, input) : Together with dx and \n"
19230  " dy, this specifies the inclination of the string. \n"
19231  "\n"
19232  " sx (PLFLT, input) : Together with sy and \n"
19233  " sz , this specifies the shear of the string. The string is sheared so\n"
19234  " that the characters are vertically parallel to a line joining (\n"
19235  " x, \n"
19236  " y, \n"
19237  " z) to (\n"
19238  " x+\n"
19239  " sx, \n"
19240  " y+\n"
19241  " sy, \n"
19242  " z+\n"
19243  " sz) . If sx = \n"
19244  " sy = \n"
19245  " sz = 0.) then the text is not sheared. \n"
19246  "\n"
19247  " sy (PLFLT, input) : Together with sx and \n"
19248  " sz, this specifies shear of the string. \n"
19249  "\n"
19250  " sz (PLFLT, input) : Together with sx and \n"
19251  " sy, this specifies shear of the string. \n"
19252  "\n"
19253  " just (PLFLT, input) : Specifies the position of the string relative\n"
19254  " to its reference point. If just=0. , the reference point is at\n"
19255  " the left and if just=1. , it is at the right of the string. Other\n"
19256  " values of just give intermediate justifications. \n"
19257  "\n"
19258  " text (const char *, input) : The string to be written out. \n"
19259  "\n"
19260  ""},
19261  { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
19262  "Random number generator returning a real random number in the range [0,1] \n"
19263  "\n"
19264  "DESCRIPTION:\n"
19265  "\n"
19266  " Random number generator returning a real random number in the range\n"
19267  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19268  " / compilers provide their own random number generator, and so this is\n"
19269  " provided purely for convenience and to give a consistent random number\n"
19270  " generator across all languages supported by PLplot. This is\n"
19271  " particularly useful for comparing results from the test suite of\n"
19272  " examples. \n"
19273  "\n"
19274  " Redacted form: plrandd()\n"
19275  "\n"
19276  " This function is used in examples 17,21. \n"
19277  "\n"
19278  "\n"
19279  "\n"
19280  "SYNOPSIS:\n"
19281  "\n"
19282  "plrandd()\n"
19283  "\n"
19284  ""},
19285  { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
19286  "Replays contents of plot buffer to current device/file \n"
19287  "\n"
19288  "DESCRIPTION:\n"
19289  "\n"
19290  " Replays contents of plot buffer to current device/file. \n"
19291  "\n"
19292  " Redacted form: plreplot()\n"
19293  "\n"
19294  " This function is used in example 1,20. \n"
19295  "\n"
19296  "\n"
19297  "\n"
19298  "SYNOPSIS:\n"
19299  "\n"
19300  "plreplot()\n"
19301  "\n"
19302  ""},
19303  { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
19304  "Convert RGB color to HLS \n"
19305  "\n"
19306  "DESCRIPTION:\n"
19307  "\n"
19308  " Convert RGB color coordinates to HLS \n"
19309  "\n"
19310  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19311  " Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
19312  "\n"
19313  "\n"
19314  " This function is used in example 2. \n"
19315  "\n"
19316  "\n"
19317  "\n"
19318  "SYNOPSIS:\n"
19319  "\n"
19320  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19321  "\n"
19322  "ARGUMENTS:\n"
19323  "\n"
19324  " r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n"
19325  "\n"
19326  " g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n"
19327  "\n"
19328  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n"
19329  "\n"
19330  " p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n"
19331  " cone (0.0-360.0) \n"
19332  "\n"
19333  " p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n"
19334  " fraction of the axis of the colour cone (0.0-1.0) \n"
19335  "\n"
19336  " p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n"
19337  " fraction of the radius of the colour cone (0.0-1.0) \n"
19338  "\n"
19339  ""},
19340  { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
19341  "Set character size \n"
19342  "\n"
19343  "DESCRIPTION:\n"
19344  "\n"
19345  " This sets up the size of all subsequent characters drawn. The actual\n"
19346  " height of a character is the product of the default character size and\n"
19347  " a scaling factor. \n"
19348  "\n"
19349  " Redacted form: plschr(def, scale)\n"
19350  "\n"
19351  " This function is used in example 2,13,23,24. \n"
19352  "\n"
19353  "\n"
19354  "\n"
19355  "SYNOPSIS:\n"
19356  "\n"
19357  "plschr(def, scale)\n"
19358  "\n"
19359  "ARGUMENTS:\n"
19360  "\n"
19361  " def (PLFLT, input) : The default height of a character in\n"
19362  " millimeters, should be set to zero if the default height is to\n"
19363  " remain unchanged. \n"
19364  "\n"
19365  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19366  " actual character height. \n"
19367  "\n"
19368  ""},
19369  { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
19370  "Set cmap0 colors by 8-bit RGB values \n"
19371  "\n"
19372  "DESCRIPTION:\n"
19373  "\n"
19374  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19375  " documentation). This sets the entire color map -- only as many colors\n"
19376  " as specified will be allocated. \n"
19377  "\n"
19378  " Redacted form: plscmap0(r, g, b)\n"
19379  "\n"
19380  " This function is used in examples 2,24. \n"
19381  "\n"
19382  "\n"
19383  "\n"
19384  "SYNOPSIS:\n"
19385  "\n"
19386  "plscmap0(r, g, b, ncol0)\n"
19387  "\n"
19388  "ARGUMENTS:\n"
19389  "\n"
19390  " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19391  " 8-bit integers (0-255) representing the degree of red in the\n"
19392  " color. \n"
19393  "\n"
19394  " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19395  " 8-bit integers (0-255) representing the degree of green in the\n"
19396  " color. \n"
19397  "\n"
19398  " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19399  " 8-bit integers (0-255) representing the degree of blue in the\n"
19400  " color. \n"
19401  "\n"
19402  " ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
19403  "\n"
19404  ""},
19405  { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
19406  "Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n"
19407  "\n"
19408  "DESCRIPTION:\n"
19409  "\n"
19410  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19411  " and floating point alpha transparency value. This sets the entire\n"
19412  " color map -- only as many colors as specified will be allocated. \n"
19413  "\n"
19414  " Redacted form: plscmap0a(r, g, b, alpha)\n"
19415  "\n"
19416  " This function is used in examples 30. \n"
19417  "\n"
19418  "\n"
19419  "\n"
19420  "SYNOPSIS:\n"
19421  "\n"
19422  "plscmap0a(r, g, b, alpha, ncol0)\n"
19423  "\n"
19424  "ARGUMENTS:\n"
19425  "\n"
19426  " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19427  " 8-bit integers (0-255) representing the degree of red in the\n"
19428  " color. \n"
19429  "\n"
19430  " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19431  " 8-bit integers (0-255) representing the degree of green in the\n"
19432  " color. \n"
19433  "\n"
19434  " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19435  " 8-bit integers (0-255) representing the degree of blue in the\n"
19436  " color. \n"
19437  "\n"
19438  " alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n"
19439  " values (0.0 - 1.0) representing the alpha transparency of the\n"
19440  " color. \n"
19441  "\n"
19442  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19443  " arrays. \n"
19444  "\n"
19445  ""},
19446  { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
19447  "Set number of colors in cmap0 \n"
19448  "\n"
19449  "DESCRIPTION:\n"
19450  "\n"
19451  " Set number of colors in color map0 (see the PLplot documentation).\n"
19452  " Allocate (or reallocate) color map0, and fill with default values for\n"
19453  " those colors not previously allocated. The first 16 default colors are\n"
19454  " given in the plcol0 documentation. For larger indices the default\n"
19455  " color is red. \n"
19456  "\n"
19457  " The drivers are not guaranteed to support more than 16 colors. \n"
19458  "\n"
19459  " Redacted form: plscmap0n(ncol0)\n"
19460  "\n"
19461  " This function is used in examples 15,16,24. \n"
19462  "\n"
19463  "\n"
19464  "\n"
19465  "SYNOPSIS:\n"
19466  "\n"
19467  "plscmap0n(ncol0)\n"
19468  "\n"
19469  "ARGUMENTS:\n"
19470  "\n"
19471  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19472  " the map0 palette. If this number is zero or less, then the value\n"
19473  " from the previous call to plscmap0n is used and if there is no\n"
19474  " previous call, then a default value is used. \n"
19475  "\n"
19476  ""},
19477  { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19478  "Set cmap1 colors using 8-bit RGB values \n"
19479  "\n"
19480  "DESCRIPTION:\n"
19481  "\n"
19482  " Set cmap1 colors using 8-bit RGB values (see the PLplot\n"
19483  " documentation). This also sets the number of colors. \n"
19484  "\n"
19485  " Redacted form: plscmap1(r, g, b)\n"
19486  "\n"
19487  " This function is used in example 31. \n"
19488  "\n"
19489  "\n"
19490  "\n"
19491  "SYNOPSIS:\n"
19492  "\n"
19493  "plscmap1(r, g, b, ncol1)\n"
19494  "\n"
19495  "ARGUMENTS:\n"
19496  "\n"
19497  " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19498  " 8-bit integers (0-255) representing the degree of red in the\n"
19499  " color. \n"
19500  "\n"
19501  " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19502  " 8-bit integers (0-255) representing the degree of green in the\n"
19503  " color. \n"
19504  "\n"
19505  " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19506  " 8-bit integers (0-255) representing the degree of blue in the\n"
19507  " color. \n"
19508  "\n"
19509  " ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n"
19510  "\n"
19511  ""},
19512  { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19513  "Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n"
19514  "\n"
19515  "DESCRIPTION:\n"
19516  "\n"
19517  " Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n"
19518  " and double alpha transparency values. This also sets the number of\n"
19519  " colors. \n"
19520  "\n"
19521  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19522  "\n"
19523  " This function is used in example 31. \n"
19524  "\n"
19525  "\n"
19526  "\n"
19527  "SYNOPSIS:\n"
19528  "\n"
19529  "plscmap1a(r, g, b, alpha, ncol1)\n"
19530  "\n"
19531  "ARGUMENTS:\n"
19532  "\n"
19533  " r (const PLINT *, input) : Pointer to array with set of unsigned\n"
19534  " 8-bit integers (0-255) representing the degree of red in the\n"
19535  " color. \n"
19536  "\n"
19537  " g (const PLINT *, input) : Pointer to array with set of unsigned\n"
19538  " 8-bit integers (0-255) representing the degree of green in the\n"
19539  " color. \n"
19540  "\n"
19541  " b (const PLINT *, input) : Pointer to array with set of unsigned\n"
19542  " 8-bit integers (0-255) representing the degree of blue in the\n"
19543  " color. \n"
19544  "\n"
19545  " alpha (const PLFLT *, input) : Pointer to array with set of double\n"
19546  " values (0.0-1.0) representing the alpha transparency value of the\n"
19547  " color. \n"
19548  "\n"
19549  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19550  " arrays. \n"
19551  "\n"
19552  ""},
19553  { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19554  "Set cmap1 colors using a piece-wise linear relationship \n"
19555  "\n"
19556  "DESCRIPTION:\n"
19557  "\n"
19558  " Set cmap1 colors using a piece-wise linear relationship between\n"
19559  " intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n"
19560  " color space (see the PLplot documentation). May be called at any\n"
19561  " time. \n"
19562  "\n"
19563  " The idea here is to specify a number of control points that define the\n"
19564  " mapping between input cmap1 intensity indices and HLS (or RGB). \n"
19565  " Between these points, linear interpolation is used which gives a\n"
19566  " smooth variation of color with intensity index. Any number of control\n"
19567  " points may be specified, located at arbitrary positions, although\n"
19568  " typically 2 - 4 are enough. Another way of stating this is that we are\n"
19569  " traversing a given number of lines through HLS (or RGB) space as we\n"
19570  " move through cmap1 intensity indices. The control points at the\n"
19571  " minimum and maximum position (0 and 1) must always be specified. By\n"
19572  " adding more control points you can get more variation. One good\n"
19573  " technique for plotting functions that vary about some expected average\n"
19574  " is to use an additional 2 control points in the center (position ~=\n"
19575  " 0.5) that are the same lightness as the background (typically white\n"
19576  " for paper output, black for crt), and same hue as the boundary control\n"
19577  " points. This allows the highs and lows to be very easily\n"
19578  " distinguished. \n"
19579  "\n"
19580  " Each control point must specify the cmap1 intensity index and the\n"
19581  " associated three coordinates in HLS or RGB space. The first point\n"
19582  " must correspond to position = 0, and the last to position = 1. \n"
19583  "\n"
19584  " The default behaviour is for the hue to be linearly interpolated\n"
19585  " between the control points. Since the hue lies in the range [0, 360]\n"
19586  " this corresponds to interpolation around the \"front\" of the color\n"
19587  " wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19588  " alternative interpolation is used between control points i and i+1. If\n"
19589  " hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n"
19590  " - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n"
19591  " this as interpolation around the \"back\" or \"reverse\" of the color\n"
19592  " wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19593  " alt_hue_path[] = false for every control point. \n"
19594  "\n"
19595  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19596  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19597  " 240]truegreen-yellow-red-magenta-blue[240\n"
19598  " 120]trueblue-magenta-red-yellow-green\n"
19599  "\n"
19600  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19601  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19602  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19603  "\n"
19604  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19605  " alt_hue_path)\n"
19606  "\n"
19607  " This function is used in examples 8,11,12,15,20,21. \n"
19608  "\n"
19609  "\n"
19610  "\n"
19611  "SYNOPSIS:\n"
19612  "\n"
19613  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19614  "\n"
19615  "ARGUMENTS:\n"
19616  "\n"
19617  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
19618  "\n"
19619  " npts (PLINT, input) : number of control points \n"
19620  "\n"
19621  " intensity (const PLFLT *, input) : intensity index for each control\n"
19622  " point (between 0.0 and 1.0, in ascending order) \n"
19623  "\n"
19624  " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n"
19625  " control point \n"
19626  "\n"
19627  " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n"
19628  " control point \n"
19629  "\n"
19630  " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n"
19631  " control point \n"
19632  "\n"
19633  " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n"
19634  " method flag for each control point. (alt_hue_path[i] refers to the\n"
19635  " interpolation interval between the i and i + 1 control points). \n"
19636  "\n"
19637  ""},
19638  { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19639  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n"
19640  "\n"
19641  "DESCRIPTION:\n"
19642  "\n"
19643  " This is a variant of plscmap1l that supports alpha channel\n"
19644  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19645  " relationship between cmap1 intensity index (from 0. to 1.) and\n"
19646  " position in HLS or RGB color space (see the PLplot documentation) with\n"
19647  " alpha transparency value (0.0 - 1.0). It may be called at any time. \n"
19648  "\n"
19649  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19650  " alpha, alt_hue_path) \n"
19651  "\n"
19652  " This function is used in example 30. \n"
19653  "\n"
19654  "\n"
19655  "\n"
19656  "SYNOPSIS:\n"
19657  "\n"
19658  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19659  "\n"
19660  "ARGUMENTS:\n"
19661  "\n"
19662  " itype (PLBOOL, input) : true: RGB, false: HLS. \n"
19663  "\n"
19664  " npts (PLINT, input) : number of control points \n"
19665  "\n"
19666  " intensity (const PLFLT *, input) : position for each control point\n"
19667  " (between 0.0 and 1.0, in ascending order) \n"
19668  "\n"
19669  " coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n"
19670  " control point \n"
19671  "\n"
19672  " coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n"
19673  " control point \n"
19674  "\n"
19675  " coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n"
19676  " control point \n"
19677  "\n"
19678  " alpha (const PLFLT *, input) : the alpha transparency value for\n"
19679  " each control point \n"
19680  "\n"
19681  " alt_hue_path (const PLBOOL *, input) : alternative interpolation\n"
19682  " method flag for each control point. (alt_hue_path[i] refers to the\n"
19683  " interpolation interval between the i and i + 1 control points). \n"
19684  "\n"
19685  ""},
19686  { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19687  "Set number of colors in cmap1 \n"
19688  "\n"
19689  "DESCRIPTION:\n"
19690  "\n"
19691  " Set number of colors in cmap1, (re-)allocate color map1, and set\n"
19692  " default values if this is the first allocation (see the PLplot\n"
19693  " documentation). \n"
19694  "\n"
19695  " Redacted form: plscmap1n(ncol1)\n"
19696  "\n"
19697  " This function is used in examples 8,11,20,21. \n"
19698  "\n"
19699  "\n"
19700  "\n"
19701  "SYNOPSIS:\n"
19702  "\n"
19703  "plscmap1n(ncol1)\n"
19704  "\n"
19705  "ARGUMENTS:\n"
19706  "\n"
19707  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19708  " the map1 palette. If this number is zero or less, then the value\n"
19709  " from the previous call to plscmap1n is used and if there is no\n"
19710  " previous call, then a default value is used. \n"
19711  "\n"
19712  ""},
19713  { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
19714  "Set the cmap1 argument range for continuous color plots \n"
19715  "\n"
19716  "DESCRIPTION:\n"
19717  "\n"
19718  " Set the cmap1 argument range for continuous color plots. If \n"
19719  " min_color is greater than \n"
19720  " max_color or \n"
19721  " max_color is greater than 1.0 or \n"
19722  " min_color is less than 0.0 then no change is made. (Use\n"
19723  " plgcmap1_range to get the cmap1 argument range.) \n"
19724  "\n"
19725  " Redacted form: plscmap1_range(min_color, max_color)\n"
19726  "\n"
19727  " This function is currently used in example 33. \n"
19728  "\n"
19729  "\n"
19730  "\n"
19731  "SYNOPSIS:\n"
19732  "\n"
19733  "plscmap1_range(min_color, max_color)\n"
19734  "\n"
19735  "ARGUMENTS:\n"
19736  "\n"
19737  " min_color (PLFLT, input) : The minimum cmap1 floating point\n"
19738  " argument. \n"
19739  "\n"
19740  " max_color (PLFLT, input) : The maximum cmap1 floating point\n"
19741  " argument. \n"
19742  "\n"
19743  ""},
19744  { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
19745  "Get the cmap1 argument range for continuous color plots \n"
19746  "\n"
19747  "DESCRIPTION:\n"
19748  "\n"
19749  " Get the cmap1 argument range for continuous color plots. (Use\n"
19750  " plgsmap1_range to set the cmap1 argument range.) \n"
19751  "\n"
19752  " Redacted form: plgcmap1_range(min_color, max_color)\n"
19753  "\n"
19754  " This function is currently not used in any example. \n"
19755  "\n"
19756  "\n"
19757  "\n"
19758  "SYNOPSIS:\n"
19759  "\n"
19760  "plgcmap1_range(min_color, max_color)\n"
19761  "\n"
19762  "ARGUMENTS:\n"
19763  "\n"
19764  " min_color (PLFLT *, output) : Pointer to the current minimum cmap1\n"
19765  " floating point argument. \n"
19766  "\n"
19767  " max_color (PLFLT *, output) : Pointer to the current maximum cmap1\n"
19768  " floating point argument. \n"
19769  "\n"
19770  ""},
19771  { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
19772  "Set 8-bit RGB values for given cmap0 color index \n"
19773  "\n"
19774  "ESCRIPTION:\n"
19775  "\n"
19776  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19777  " index. Overwrites the previous color value for the given index and,\n"
19778  " thus, does not result in any additional allocation of space for\n"
19779  " colors. \n"
19780  "\n"
19781  " Redacted form: plscol0(icol0, r, g, b)\n"
19782  "\n"
19783  " This function is used in any example 31. \n"
19784  "\n"
19785  "\n"
19786  "\n"
19787  "YNOPSIS:\n"
19788  "\n"
19789  "lscol0(icol0, r, g, b)\n"
19790  "\n"
19791  "RGUMENTS:\n"
19792  "\n"
19793  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19794  " number of colors (which is set by default, by plscmap0n, or even\n"
19795  " by plscmap0). \n"
19796  "\n"
19797  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19798  " degree of red in the color. \n"
19799  "\n"
19800  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19801  " degree of green in the color. \n"
19802  "\n"
19803  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19804  " degree of blue in the color. \n"
19805  "\n"
19806  ""},
19807  { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
19808  "Set 8-bit RGB values and double alpha transparency value for given cmap0 color index \n"
19809  "\n"
19810  "ESCRIPTION:\n"
19811  "\n"
19812  " Set 8-bit RGB value and double alpha transparency value for given\n"
19813  " cmap0 (see the PLplot documentation) index. Overwrites the previous\n"
19814  " color value for the given index and, thus, does not result in any\n"
19815  " additional allocation of space for colors. \n"
19816  "\n"
19817  " This function is used in example 30. \n"
19818  "\n"
19819  "\n"
19820  "\n"
19821  "YNOPSIS:\n"
19822  "\n"
19823  "lscol0a(icol0, r, g, b, alpha)\n"
19824  "\n"
19825  "RGUMENTS:\n"
19826  "\n"
19827  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19828  " number of colors (which is set by default, by plscmap0n, or even\n"
19829  " by plscmap0). \n"
19830  "\n"
19831  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19832  " degree of red in the color. \n"
19833  "\n"
19834  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19835  " degree of green in the color. \n"
19836  "\n"
19837  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19838  " degree of blue in the color. \n"
19839  "\n"
19840  " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n"
19841  " alpha transparency value of the color. \n"
19842  "\n"
19843  ""},
19844  { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
19845  "Set the background color by 8-bit RGB value \n"
19846  "\n"
19847  "DESCRIPTION:\n"
19848  "\n"
19849  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19850  " (see the PLplot documentation). \n"
19851  "\n"
19852  " Redacted form: plscolbg(r, g, b)\n"
19853  "\n"
19854  " This function is used in examples 15,31. \n"
19855  "\n"
19856  "\n"
19857  "\n"
19858  "SYNOPSIS:\n"
19859  "\n"
19860  "plscolbg(r, g, b)\n"
19861  "\n"
19862  "ARGUMENTS:\n"
19863  "\n"
19864  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19865  " degree of red in the color. \n"
19866  "\n"
19867  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19868  " degree of green in the color. \n"
19869  "\n"
19870  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19871  " degree of blue in the color. \n"
19872  "\n"
19873  ""},
19874  { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
19875  "Set the background color by 8-bit RGB value and double alpha transparency value. \n"
19876  "\n"
19877  "DESCRIPTION:\n"
19878  "\n"
19879  " Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19880  " (see the PLplot documentation) and double alpha transparency value. \n"
19881  "\n"
19882  " This function is used in example 31. \n"
19883  "\n"
19884  "\n"
19885  "\n"
19886  "SYNOPSIS:\n"
19887  "\n"
19888  "plscolbga(r, g, b, alpha)\n"
19889  "\n"
19890  "ARGUMENTS:\n"
19891  "\n"
19892  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19893  " degree of red in the color. \n"
19894  "\n"
19895  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19896  " degree of green in the color. \n"
19897  "\n"
19898  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19899  " degree of blue in the color. \n"
19900  "\n"
19901  " alpha (PLFLT, input) : double value (0.0-1.0) representing the\n"
19902  " alpha transparency value of the color. \n"
19903  "\n"
19904  ""},
19905  { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
19906  "Used to globally turn color output on/off \n"
19907  "\n"
19908  "DESCRIPTION:\n"
19909  "\n"
19910  " Used to globally turn color output on/off for those drivers/devices\n"
19911  " that support it. \n"
19912  "\n"
19913  " Redacted form: plscolor(color)\n"
19914  "\n"
19915  " This function is used in example 31. \n"
19916  "\n"
19917  "\n"
19918  "\n"
19919  "SYNOPSIS:\n"
19920  "\n"
19921  "plscolor(color)\n"
19922  "\n"
19923  "ARGUMENTS:\n"
19924  "\n"
19925  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19926  " turned off. If non-zero, color is turned on. \n"
19927  "\n"
19928  ""},
19929  { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
19930  "Set device-compression level \n"
19931  "\n"
19932  "DESCRIPTION:\n"
19933  "\n"
19934  " Set device-compression level. Only used for drivers that provide\n"
19935  " compression. This function, if used, should be invoked before a call\n"
19936  " to plinit. \n"
19937  "\n"
19938  " Redacted form: plscompression(compression)\n"
19939  "\n"
19940  " This function is used in example 31. \n"
19941  "\n"
19942  "\n"
19943  "\n"
19944  "SYNOPSIS:\n"
19945  "\n"
19946  "plscompression(compression)\n"
19947  "\n"
19948  "ARGUMENTS:\n"
19949  "\n"
19950  " compression (PLINT, input) : The desired compression level. This is\n"
19951  " a device-dependent value. Currently only the jpeg and png devices\n"
19952  " use these values. For jpeg value is the jpeg quality which should\n"
19953  " normally be in the range 0-95. Higher values denote higher quality\n"
19954  " and hence larger image sizes. For png values are in the range -1\n"
19955  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19956  " A value of -1 denotes the default zlib compression level. Values\n"
19957  " in the range 10-99 are divided by 10 and then used as the zlib\n"
19958  " compression level. Higher compression levels correspond to greater\n"
19959  " compression and small file sizes at the expense of more\n"
19960  " computation. \n"
19961  "\n"
19962  ""},
19963  { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
19964  "Set the device (keyword) name \n"
19965  "\n"
19966  "DESCRIPTION:\n"
19967  "\n"
19968  " Set the device (keyword) name. \n"
19969  "\n"
19970  " Redacted form: plsdev(devname)\n"
19971  "\n"
19972  " This function is used in examples 1,14,20. \n"
19973  "\n"
19974  "\n"
19975  "\n"
19976  "SYNOPSIS:\n"
19977  "\n"
19978  "plsdev(devname)\n"
19979  "\n"
19980  "ARGUMENTS:\n"
19981  "\n"
19982  " devname (const char *, input) : Pointer to device (keyword) name\n"
19983  " string. \n"
19984  "\n"
19985  ""},
19986  { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
19987  "Set parameters that define current device-space window \n"
19988  "\n"
19989  "DESCRIPTION:\n"
19990  "\n"
19991  " Set relative margin width, aspect ratio, and relative justification\n"
19992  " that define current device-space window. If you want to just use the\n"
19993  " previous value for any of these, just pass in the magic value\n"
19994  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19995  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19996  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19997  " to a device-specific value. \n"
19998  "\n"
19999  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20000  "\n"
20001  " This function is used in example 31. \n"
20002  "\n"
20003  "\n"
20004  "\n"
20005  "SYNOPSIS:\n"
20006  "\n"
20007  "plsdidev(mar, aspect, jx, jy)\n"
20008  "\n"
20009  "ARGUMENTS:\n"
20010  "\n"
20011  " mar (PLFLT, input) : Relative margin width. \n"
20012  "\n"
20013  " aspect (PLFLT, input) : Aspect ratio. \n"
20014  "\n"
20015  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20016  " the range -0.5 to 0.5. \n"
20017  "\n"
20018  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20019  " the range -0.5 to 0.5. \n"
20020  "\n"
20021  ""},
20022  { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
20023  "Set up transformation from metafile coordinates \n"
20024  "\n"
20025  "DESCRIPTION:\n"
20026  "\n"
20027  " Set up transformation from metafile coordinates. The size of the plot\n"
20028  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20029  " general-purpose facility just yet (not sure why the user would need\n"
20030  " it, for one). \n"
20031  "\n"
20032  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20033  " dimypmm)\n"
20034  "\n"
20035  " This function is not used in any examples. \n"
20036  "\n"
20037  "\n"
20038  "\n"
20039  "SYNOPSIS:\n"
20040  "\n"
20041  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20042  "\n"
20043  "ARGUMENTS:\n"
20044  "\n"
20045  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n"
20046  "\n"
20047  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n"
20048  "\n"
20049  " dimymin (PLINT, input) : NEEDS DOCUMENTATION \n"
20050  "\n"
20051  " dimymax (PLINT, input) : NEEDS DOCUMENTATION \n"
20052  "\n"
20053  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
20054  "\n"
20055  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n"
20056  "\n"
20057  ""},
20058  { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
20059  "Set plot orientation \n"
20060  "\n"
20061  "DESCRIPTION:\n"
20062  "\n"
20063  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20064  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20065  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20066  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20067  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20068  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20069  " not called the default value of rot is 0. \n"
20070  "\n"
20071  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20072  " probably want to change the aspect ratio to a value suitable for the\n"
20073  " plot orientation using a call to plsdidev or the command-line options\n"
20074  " -a or -freeaspect. For more documentation of those options see the\n"
20075  " PLplot documentation. Such command-line options can be set internally\n"
20076  " using plsetopt or set directly using the command line and parsed using\n"
20077  " a call to plparseopts. \n"
20078  "\n"
20079  " Redacted form: plsdiori(rot)\n"
20080  "\n"
20081  " This function is not used in any examples. \n"
20082  "\n"
20083  "\n"
20084  "\n"
20085  "SYNOPSIS:\n"
20086  "\n"
20087  "plsdiori(rot)\n"
20088  "\n"
20089  "ARGUMENTS:\n"
20090  "\n"
20091  " rot (PLFLT, input) : Plot orientation parameter. \n"
20092  "\n"
20093  ""},
20094  { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
20095  "Set parameters that define current plot-space window \n"
20096  "\n"
20097  "DESCRIPTION:\n"
20098  "\n"
20099  " Set relative minima and maxima that define the current plot-space\n"
20100  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20101  " xmax, and ymax are 0., 0., 1., and 1. \n"
20102  "\n"
20103  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20104  "\n"
20105  " This function is used in example 31. \n"
20106  "\n"
20107  "\n"
20108  "\n"
20109  "SYNOPSIS:\n"
20110  "\n"
20111  "plsdiplt(xmin, ymin, xmax, ymax)\n"
20112  "\n"
20113  "ARGUMENTS:\n"
20114  "\n"
20115  " xmin (PLFLT, input) : Relative minimum in x. \n"
20116  "\n"
20117  " ymin (PLFLT, input) : Relative minimum in y. \n"
20118  "\n"
20119  " xmax (PLFLT, input) : Relative maximum in x. \n"
20120  "\n"
20121  " ymax (PLFLT, input) : Relative maximum in y. \n"
20122  "\n"
20123  ""},
20124  { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
20125  "Set parameters incrementally (zoom mode) that define current plot-space window \n"
20126  "\n"
20127  "DESCRIPTION:\n"
20128  "\n"
20129  " Set relative minima and maxima incrementally (zoom mode) that define\n"
20130  " the current plot-space window. This function has the same effect as\n"
20131  " plsdiplt if that function has not been previously called. Otherwise,\n"
20132  " this function implements zoom mode using the transformation min_used =\n"
20133  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20134  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20135  " repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
20136  "\n"
20137  " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20138  "\n"
20139  " This function is used in example 31. \n"
20140  "\n"
20141  "\n"
20142  "\n"
20143  "SYNOPSIS:\n"
20144  "\n"
20145  "plsdiplz(xmin, ymin, xmax, ymax)\n"
20146  "\n"
20147  "ARGUMENTS:\n"
20148  "\n"
20149  " xmin (PLFLT, input) : Relative (incremental) minimum in x. \n"
20150  "\n"
20151  " ymin (PLFLT, input) : Relative (incremental) minimum in y. \n"
20152  "\n"
20153  " xmax (PLFLT, input) : Relative (incremental) maximum in x. \n"
20154  "\n"
20155  " ymax (PLFLT, input) : Relative (incremental) maximum in y. \n"
20156  "\n"
20157  ""},
20158  { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
20159  "Set seed for internal random number generator. \n"
20160  "\n"
20161  "DESCRIPTION:\n"
20162  "\n"
20163  " Set the seed for the internal random number generator. See plrandd for\n"
20164  " further details. \n"
20165  "\n"
20166  " Redacted form: plseed(seed)\n"
20167  "\n"
20168  " This function is used in example 21. \n"
20169  "\n"
20170  "\n"
20171  "\n"
20172  "SYNOPSIS:\n"
20173  "\n"
20174  "plseed(seed)\n"
20175  "\n"
20176  "ARGUMENTS:\n"
20177  "\n"
20178  " seed (unsigned int, input) : Seed for random number generator. \n"
20179  "\n"
20180  ""},
20181  { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
20182  "Set the escape character for text strings \n"
20183  "\n"
20184  "DESCRIPTION:\n"
20185  "\n"
20186  " Set the escape character for text strings. From C (in contrast to\n"
20187  " Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
20188  " selected characters are allowed to prevent the user from shooting\n"
20189  " himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
20190  " with C's use of backslash as a character escape). Here are the\n"
20191  " allowed escape characters and their corresponding decimal ASCII\n"
20192  " values: !, ASCII 33 \n"
20193  " #, ASCII 35 \n"
20194  " $, ASCII 36 \n"
20195  " %, ASCII 37 \n"
20196  " &, ASCII 38 \n"
20197  " *, ASCII 42 \n"
20198  " @, ASCII 64 \n"
20199  " ^, ASCII 94 \n"
20200  " ~, ASCII 126 \n"
20201  "\n"
20202  "\n"
20203  " Redacted form: General: plsesc(esc)\n"
20204  " Perl/PDL: Not available? \n"
20205  "\n"
20206  "\n"
20207  " This function is used in example 29. \n"
20208  "\n"
20209  "\n"
20210  "\n"
20211  "SYNOPSIS:\n"
20212  "\n"
20213  "plsesc(esc)\n"
20214  "\n"
20215  "ARGUMENTS:\n"
20216  "\n"
20217  " esc (char, input) : Escape character. \n"
20218  "\n"
20219  ""},
20220  { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
20221  "Set any command-line option \n"
20222  "\n"
20223  "DESCRIPTION:\n"
20224  "\n"
20225  " Set any command-line option internally from a program before it\n"
20226  " invokes plinit. opt is the name of the command-line option and optarg\n"
20227  " is the corresponding command-line option argument. \n"
20228  "\n"
20229  " This function returns 0 on success. \n"
20230  "\n"
20231  " Redacted form: plsetopt(opt, optarg)\n"
20232  "\n"
20233  " This function is used in example 14. \n"
20234  "\n"
20235  "\n"
20236  "\n"
20237  "SYNOPSIS:\n"
20238  "\n"
20239  "int plsetopt(opt, optarg)\n"
20240  "\n"
20241  "ARGUMENTS:\n"
20242  "\n"
20243  " opt (const char *, input) : Pointer to string containing the\n"
20244  " command-line option. \n"
20245  "\n"
20246  " optarg (const char *, input) : Pointer to string containing the\n"
20247  " argument of the command-line option. \n"
20248  "\n"
20249  ""},
20250  { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
20251  "Set family file parameters \n"
20252  "\n"
20253  "DESCRIPTION:\n"
20254  "\n"
20255  " Sets variables dealing with output file familying. Does nothing if\n"
20256  " familying not supported by the driver. This routine, if used, must be\n"
20257  " called before initializing PLplot. See the PLplot documentation for\n"
20258  " more information. \n"
20259  "\n"
20260  " Redacted form: plsfam(fam, num, bmax)\n"
20261  "\n"
20262  " This function is used in examples 14,31. \n"
20263  "\n"
20264  "\n"
20265  "\n"
20266  "SYNOPSIS:\n"
20267  "\n"
20268  "plsfam(fam, num, bmax)\n"
20269  "\n"
20270  "ARGUMENTS:\n"
20271  "\n"
20272  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20273  " is enabled. \n"
20274  "\n"
20275  " num (PLINT, input) : Current family file number. \n"
20276  "\n"
20277  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20278  " file. \n"
20279  "\n"
20280  ""},
20281  { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
20282  "Set FCI (font characterization integer) \n"
20283  "\n"
20284  "DESCRIPTION:\n"
20285  "\n"
20286  " Sets font characteristics to be used at the start of the next string\n"
20287  " using the FCI approach. See the PLplot documentation for more\n"
20288  " information. \n"
20289  "\n"
20290  " Redacted form: General: plsfci(fci)\n"
20291  " Perl/PDL: Not available? \n"
20292  "\n"
20293  "\n"
20294  " This function is used in example 23. \n"
20295  "\n"
20296  "\n"
20297  "\n"
20298  "SYNOPSIS:\n"
20299  "\n"
20300  "plsfci(fci)\n"
20301  "\n"
20302  "ARGUMENTS:\n"
20303  "\n"
20304  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20305  " of FCI. \n"
20306  "\n"
20307  ""},
20308  { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
20309  "Set output file name \n"
20310  "\n"
20311  "DESCRIPTION:\n"
20312  "\n"
20313  " Sets the current output file name, if applicable. If the file name\n"
20314  " has not been specified and is required by the driver, the user will be\n"
20315  " prompted for it. If using the X-windows output driver, this sets the\n"
20316  " display name. This routine, if used, must be called before\n"
20317  " initializing PLplot. \n"
20318  "\n"
20319  " Redacted form: plsfnam(fnam)\n"
20320  "\n"
20321  " This function is used in examples 1,20. \n"
20322  "\n"
20323  "\n"
20324  "\n"
20325  "SYNOPSIS:\n"
20326  "\n"
20327  "plsfnam(fnam)\n"
20328  "\n"
20329  "ARGUMENTS:\n"
20330  "\n"
20331  " fnam (const char *, input) : Pointer to file name string. \n"
20332  "\n"
20333  ""},
20334  { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
20335  "Set family, style and weight of the current font \n"
20336  "\n"
20337  "DESCRIPTION:\n"
20338  "\n"
20339  " Sets the current font. See the PLplot documentation for more\n"
20340  " information on font selection. \n"
20341  "\n"
20342  " Redacted form: plsfont(family, style, weight)\n"
20343  "\n"
20344  " This function is used in example 23. \n"
20345  "\n"
20346  "\n"
20347  "\n"
20348  "SYNOPSIS:\n"
20349  "\n"
20350  "plsfont(family, style, weight)\n"
20351  "\n"
20352  "ARGUMENTS:\n"
20353  "\n"
20354  " family (PLINT, input) : Font family to select for the current font.\n"
20355  " The available values are given by the PL_FCI_* constants in\n"
20356  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20357  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20358  " signifies that the font family should not be altered. \n"
20359  "\n"
20360  " style (PLINT, input) : Font style to select for the current font.\n"
20361  " The available values are given by the PL_FCI_* constants in\n"
20362  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20363  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20364  " should not be altered. \n"
20365  "\n"
20366  " weight (PLINT, input) : Font weight to select for the current font.\n"
20367  " The available values are given by the PL_FCI_* constants in\n"
20368  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20369  " negative value signifies that the font weight should not be\n"
20370  " altered. \n"
20371  "\n"
20372  ""},
20373  { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
20374  "Shade regions on the basis of value \n"
20375  "\n"
20376  "DESCRIPTION:\n"
20377  "\n"
20378  " Shade regions on the basis of value. This is the high-level routine\n"
20379  " for making continuous color shaded plots with cmap1 while plshade (or\n"
20380  " plshade1) are used for individual shaded regions using either cmap0 or\n"
20381  " cmap1. examples/c/x16c.c shows a number of examples for using this\n"
20382  " function. See the following discussion of the arguments and the PLplot\n"
20383  " documentation for more information. \n"
20384  "\n"
20385  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20386  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20387  " pltr_data)\n"
20388  " Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
20389  " fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
20390  " pltr_data)\n"
20391  "\n"
20392  "\n"
20393  " This function is used in examples 16,21. \n"
20394  "\n"
20395  "\n"
20396  "\n"
20397  "SYNOPSIS:\n"
20398  "\n"
20399  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20400  "\n"
20401  "ARGUMENTS:\n"
20402  "\n"
20403  " a (const PLFLT * const *, input) : Contains ** pointer to array to\n"
20404  " be plotted. The array must have been declared as PLFLT a[nx][ny]. \n"
20405  "\n"
20406  " nx (PLINT, input) : First dimension of array \"a\". \n"
20407  "\n"
20408  " ny (PLINT, input) : Second dimension of array \"a\". \n"
20409  "\n"
20410  " defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n"
20411  " specifying regions excluded from the shading plot. This function\n"
20412  " accepts x and y coordinates as input arguments and must return 0\n"
20413  " if the point is in the excluded region or 1 otherwise. This\n"
20414  " argument can be NULL if all the values are valid. \n"
20415  "\n"
20416  " xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20417  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20418  " at (xmax,ymin) and so on. \n"
20419  "\n"
20420  " xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20421  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20422  " at (xmax,ymin) and so on. \n"
20423  "\n"
20424  " ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20425  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20426  " at (xmax,ymin) and so on. \n"
20427  "\n"
20428  " ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n"
20429  " a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
20430  " at (xmax,ymin) and so on. \n"
20431  "\n"
20432  " clevel (const PLFLT *, input) : Pointer to array containing the\n"
20433  " data levels corresponding to the edges of each shaded region that\n"
20434  " will be plotted by this function. To work properly the levels\n"
20435  " should be monotonic. \n"
20436  "\n"
20437  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20438  " of shade edge values in clevel). \n"
20439  "\n"
20440  " fill_width (PLFLT, input) : Defines line width used by the fill\n"
20441  " pattern. \n"
20442  "\n"
20443  " cont_color (PLINT, input) : Defines pen color used for contours\n"
20444  " defining edges of shaded regions. The pen color is only temporary\n"
20445  " set for the contour drawing. Set this value to zero or less if no\n"
20446  " shade edge contours are wanted. \n"
20447  "\n"
20448  " cont_width (PLFLT, input) : Defines line width used for contours\n"
20449  " defining edges of shaded regions. This value may not be honored\n"
20450  " by all drivers. The pen width is only temporary set for the\n"
20451  " contour drawing. Set this value to zero or less if no shade edge\n"
20452  " contours are wanted. \n"
20453  "\n"
20454  " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n"
20455  " Routine used to fill the region. Use plfill. Future version of\n"
20456  " PLplot may have other fill routines. \n"
20457  "\n"
20458  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20459  " map to rectangles after coordinate transformation with pltrl. \n"
20460  " Otherwise, set rectangular to false. If rectangular is set to\n"
20461  " true, plshade tries to save time by filling large rectangles. \n"
20462  " This optimization fails if the coordinate transformation distorts\n"
20463  " the shape of rectangles. For example a plot in polar coordinates\n"
20464  " has to have rectangular set to false. \n"
20465  "\n"
20466  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20467  " Pointer to function that defines transformation between indices\n"
20468  " in array z and the world coordinates (C only). Transformation\n"
20469  " functions are provided in the PLplot library: pltr0 for identity\n"
20470  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20471  " defined by one- and two-dimensional arrays. In addition,\n"
20472  " user-supplied routines for the transformation can be used as well.\n"
20473  " Examples of all of these approaches are given in the PLplot\n"
20474  " documentation. The transformation function should have the form\n"
20475  " given by any of pltr0, pltr1, or pltr2. \n"
20476  "\n"
20477  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20478  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20479  " externally supplied. \n"
20480  "\n"
20481  ""},
20482  { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20483  "Shade individual region on the basis of value \n"
20484  "\n"
20485  "ESCRIPTION:\n"
20486  "\n"
20487  " Shade individual region on the basis of value. Use plshades if you\n"
20488  " want to shade a number of regions using continuous colors. plshade is\n"
20489  " identical to plshade1 except for the type of the first parameter. See\n"
20490  " plshade1 for further discussion. \n"
20491  "\n"
20492  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20493  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20494  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20495  " Perl/PDL: Not available? \n"
20496  "\n"
20497  "\n"
20498  " This function is used in example 15. \n"
20499  "\n"
20500  "\n"
20501  "\n"
20502  "YNOPSIS:\n"
20503  "\n"
20504  "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20505  "\n"
20506  "RGUMENTS:\n"
20507  "\n"
20508  " a (const PLFLT * const *, input) : \n"
20509  "\n"
20510  " nx (PLINT, input) : \n"
20511  "\n"
20512  " ny (PLINT, input) : \n"
20513  "\n"
20514  " defined (PLINT (*) (PLFLT, PLFLT), input) : \n"
20515  "\n"
20516  " xmin (PLFLT, input) : \n"
20517  "\n"
20518  " xmax (PLFLT, input) : \n"
20519  "\n"
20520  " ymin (PLFLT, input) : \n"
20521  "\n"
20522  " ymax (PLFLT, input) : \n"
20523  "\n"
20524  " shade_min (PLFLT, input) : \n"
20525  "\n"
20526  " shade_max (PLFLT, input) : \n"
20527  "\n"
20528  " sh_cmap (PLINT, input) : \n"
20529  "\n"
20530  " sh_color (PLFLT, input) : \n"
20531  "\n"
20532  " sh_width (PLFLT, input) : \n"
20533  "\n"
20534  " min_color (PLINT, input) : \n"
20535  "\n"
20536  " min_width (PLFLT, input) : \n"
20537  "\n"
20538  " max_color (PLINT, input) : \n"
20539  "\n"
20540  " max_width (PLFLT, input) : \n"
20541  "\n"
20542  " fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n"
20543  "\n"
20544  " rectangular (PLBOOL, input) : \n"
20545  "\n"
20546  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20547  "\n"
20548  " pltr_data (PLPointer, input) : \n"
20549  "\n"
20550  ""},
20551  { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20552  "Assign a function to use for generating custom axis labels \n"
20553  "\n"
20554  "DESCRIPTION:\n"
20555  "\n"
20556  " This function allows a user to provide their own function to provide\n"
20557  " axis label text. The user function is given the numeric value for a\n"
20558  " point on an axis and returns a string label to correspond with that\n"
20559  " value. Custom axis labels can be enabled by passing appropriate\n"
20560  " arguments to plenv, plbox, plbox3 and similar functions. \n"
20561  "\n"
20562  " This function is used in example 19. \n"
20563  "\n"
20564  "\n"
20565  "\n"
20566  "SYNOPSIS:\n"
20567  "\n"
20568  "plslabelfunc(label_func, label_data)\n"
20569  "\n"
20570  "ARGUMENTS:\n"
20571  "\n"
20572  " label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n"
20573  " : This is the custom label function. In order to reset to the\n"
20574  " default labelling, set this to NULL. The labelling function\n"
20575  " parameters are, in order: axis: This indicates which axis a\n"
20576  " label is being requested for. The value will be one of PL_X_AXIS,\n"
20577  " PL_Y_AXIS or PL_Z_AXIS. \n"
20578  "\n"
20579  " value: This is the value along the axis which is being labelled. \n"
20580  "\n"
20581  " label_text: The string representation of the label value. \n"
20582  "\n"
20583  " length: The maximum length in characters allowed for label_text. \n"
20584  "\n"
20585  "\n"
20586  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20587  " data to the label_func function. \n"
20588  "\n"
20589  ""},
20590  { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20591  "Set length of major ticks \n"
20592  "\n"
20593  "DESCRIPTION:\n"
20594  "\n"
20595  " This sets up the length of the major ticks. The actual length is the\n"
20596  " product of the default length and a scaling factor as for character\n"
20597  " height. \n"
20598  "\n"
20599  " Redacted form: plsmaj(def, scale)\n"
20600  "\n"
20601  " This function is used in example 29. \n"
20602  "\n"
20603  "\n"
20604  "\n"
20605  "SYNOPSIS:\n"
20606  "\n"
20607  "plsmaj(def, scale)\n"
20608  "\n"
20609  "ARGUMENTS:\n"
20610  "\n"
20611  " def (PLFLT, input) : The default length of a major tick in\n"
20612  " millimeters, should be set to zero if the default length is to\n"
20613  " remain unchanged. \n"
20614  "\n"
20615  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20616  " actual tick length. \n"
20617  "\n"
20618  ""},
20619  { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20620  "Set the memory area to be plotted (RGB) \n"
20621  "\n"
20622  "DESCRIPTION:\n"
20623  "\n"
20624  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20625  " the dev member of the stream structure. Also set the number of pixels\n"
20626  " in the memory passed in \n"
20627  " plotmem, which is a block of memory \n"
20628  " maxy by \n"
20629  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
20630  "\n"
20631  " This memory will have to be freed by the user! \n"
20632  "\n"
20633  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20634  "\n"
20635  " This function is not used in any examples. \n"
20636  "\n"
20637  "\n"
20638  "\n"
20639  "SYNOPSIS:\n"
20640  "\n"
20641  "plsmem(maxx, maxy, plotmem)\n"
20642  "\n"
20643  "ARGUMENTS:\n"
20644  "\n"
20645  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
20646  "\n"
20647  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
20648  "\n"
20649  " plotmem (void *, input) : Pointer to the beginning of the\n"
20650  " user-supplied memory area. \n"
20651  "\n"
20652  ""},
20653  { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
20654  "Set the memory area to be plotted (RGBA) \n"
20655  "\n"
20656  "DESCRIPTION:\n"
20657  "\n"
20658  " Set the memory area to be plotted (with the memcairo driver) as the\n"
20659  " dev member of the stream structure. Also set the number of pixels in\n"
20660  " the memory passed in \n"
20661  " plotmem, which is a block of memory \n"
20662  " maxy by \n"
20663  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
20664  "\n"
20665  " This memory will have to be freed by the user! \n"
20666  "\n"
20667  " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20668  "\n"
20669  " This function is not used in any examples. \n"
20670  "\n"
20671  "\n"
20672  "\n"
20673  "SYNOPSIS:\n"
20674  "\n"
20675  "plsmema(maxx, maxy, plotmem)\n"
20676  "\n"
20677  "ARGUMENTS:\n"
20678  "\n"
20679  " maxx (PLINT, input) : Size of memory area in the X coordinate. \n"
20680  "\n"
20681  " maxy (PLINT, input) : Size of memory area in the Y coordinate. \n"
20682  "\n"
20683  " plotmem (void *, input) : Pointer to the beginning of the\n"
20684  " user-supplied memory area. \n"
20685  "\n"
20686  ""},
20687  { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
20688  "Set length of minor ticks \n"
20689  "\n"
20690  "DESCRIPTION:\n"
20691  "\n"
20692  " This sets up the length of the minor ticks and the length of the\n"
20693  " terminals on error bars. The actual length is the product of the\n"
20694  " default length and a scaling factor as for character height. \n"
20695  "\n"
20696  " Redacted form: plsmin(def, scale)\n"
20697  "\n"
20698  " This function is used in example 29. \n"
20699  "\n"
20700  "\n"
20701  "\n"
20702  "SYNOPSIS:\n"
20703  "\n"
20704  "plsmin(def, scale)\n"
20705  "\n"
20706  "ARGUMENTS:\n"
20707  "\n"
20708  " def (PLFLT, input) : The default length of a minor tick in\n"
20709  " millimeters, should be set to zero if the default length is to\n"
20710  " remain unchanged. \n"
20711  "\n"
20712  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20713  " actual tick length. \n"
20714  "\n"
20715  ""},
20716  { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
20717  "Set orientation \n"
20718  "\n"
20719  "DESCRIPTION:\n"
20720  "\n"
20721  " Set integer plot orientation parameter. This function is identical to\n"
20722  " plsdiori except for the type of the argument, and should be used in\n"
20723  " the same way. See the PLplot documentation for details. \n"
20724  "\n"
20725  " Redacted form: plsori(ori)\n"
20726  "\n"
20727  " This function is used in example 3. \n"
20728  "\n"
20729  "\n"
20730  "\n"
20731  "SYNOPSIS:\n"
20732  "\n"
20733  "plsori(ori)\n"
20734  "\n"
20735  "ARGUMENTS:\n"
20736  "\n"
20737  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20738  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20739  " angle. \n"
20740  "\n"
20741  ""},
20742  { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
20743  "Set page parameters \n"
20744  "\n"
20745  "DESCRIPTION:\n"
20746  "\n"
20747  " Sets the page configuration (optional). If an individual parameter is\n"
20748  " zero then that parameter value is not updated. Not all parameters are\n"
20749  " recognized by all drivers and the interpretation is device-dependent.\n"
20750  " The X-window driver uses the length and offset parameters to determine\n"
20751  " the window size and location. The length and offset values are\n"
20752  " expressed in units that are specific to the current driver. For\n"
20753  " instance: screen drivers will usually interpret them as number of\n"
20754  " pixels, whereas printer drivers will usually use mm. This routine, if\n"
20755  " used, must be called before initializing PLplot. \n"
20756  "\n"
20757  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20758  "\n"
20759  " This function is used in examples 14 and 31. \n"
20760  "\n"
20761  "\n"
20762  "\n"
20763  "SYNOPSIS:\n"
20764  "\n"
20765  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20766  "\n"
20767  "ARGUMENTS:\n"
20768  "\n"
20769  " xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n"
20770  "\n"
20771  " yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n"
20772  "\n"
20773  " xleng (PLINT , input) : Page length, x. \n"
20774  "\n"
20775  " yleng (PLINT, input) : Page length, y. \n"
20776  "\n"
20777  " xoff (PLINT, input) : Page offset, x. \n"
20778  "\n"
20779  " yoff (PLINT, input) : Page offset, y. \n"
20780  "\n"
20781  ""},
20782  { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
20783  "Set the colors for color table 0 from a cmap0 file \n"
20784  "\n"
20785  "DESCRIPTION:\n"
20786  "\n"
20787  " Set the colors for color table 0 from a cmap0 file \n"
20788  "\n"
20789  " Redacted form: plspal0(filename)\n"
20790  "\n"
20791  " This function is in example 16. \n"
20792  "\n"
20793  "\n"
20794  "\n"
20795  "SYNOPSIS:\n"
20796  "\n"
20797  "plspal0(filename)\n"
20798  "\n"
20799  "ARGUMENTS:\n"
20800  "\n"
20801  " filename (const char *, input) : The name of the cmap0 file, or a\n"
20802  " empty to string to specify the default cmap0 file. \n"
20803  "\n"
20804  ""},
20805  { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
20806  "Set the palette for cmap1 using the specified cmap1*.pal format file \n"
20807  "\n"
20808  "DESCRIPTION:\n"
20809  "\n"
20810  " Set the palette for cmap1 using the specified cmap1*.pal format file. \n"
20811  "\n"
20812  " Redacted form: plspal1(filename, interpolate)\n"
20813  "\n"
20814  " This function is used in example 16. \n"
20815  "\n"
20816  "\n"
20817  "\n"
20818  "SYNOPSIS:\n"
20819  "\n"
20820  "plspal1(filename, interpolate)\n"
20821  "\n"
20822  "ARGUMENTS:\n"
20823  "\n"
20824  " filename (const char *, input) : The name of the cmap1*.pal file,\n"
20825  " or an empty string to specify the default cmap1.pal file. \n"
20826  "\n"
20827  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20828  " columns containing the intensity index, r, g, b, alpha and\n"
20829  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20830  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20831  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20832  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20833  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20834  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20835  " are used instead to set the cmap1 palette directly with a call to\n"
20836  " plscmap1a. \n"
20837  "\n"
20838  ""},
20839  { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
20840  "Set the pause (on end-of-page) status \n"
20841  "\n"
20842  "DESCRIPTION:\n"
20843  "\n"
20844  " Set the pause (on end-of-page) status. \n"
20845  "\n"
20846  " Redacted form: plspause(pause)\n"
20847  "\n"
20848  " This function is in examples 14,20. \n"
20849  "\n"
20850  "\n"
20851  "\n"
20852  "SYNOPSIS:\n"
20853  "\n"
20854  "plspause(pause)\n"
20855  "\n"
20856  "ARGUMENTS:\n"
20857  "\n"
20858  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20859  " end-of-page for those drivers which support this. Otherwise there\n"
20860  " is no pause. \n"
20861  "\n"
20862  ""},
20863  { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
20864  "Set current output stream \n"
20865  "\n"
20866  "DESCRIPTION:\n"
20867  "\n"
20868  " Sets the number of the current output stream. The stream number\n"
20869  " defaults to 0 unless changed by this routine. The first use of this\n"
20870  " routine must be followed by a call initializing PLplot (e.g. plstar). \n"
20871  "\n"
20872  " Redacted form: plsstrm(strm)\n"
20873  "\n"
20874  " This function is examples 1,14,20. \n"
20875  "\n"
20876  "\n"
20877  "\n"
20878  "SYNOPSIS:\n"
20879  "\n"
20880  "plsstrm(strm)\n"
20881  "\n"
20882  "ARGUMENTS:\n"
20883  "\n"
20884  " strm (PLINT, input) : The current stream number. \n"
20885  "\n"
20886  ""},
20887  { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
20888  "Set the number of subpages in x and y \n"
20889  "\n"
20890  "DESCRIPTION:\n"
20891  "\n"
20892  " Set the number of subpages in x and y. \n"
20893  "\n"
20894  " Redacted form: plssub(nx, ny)\n"
20895  "\n"
20896  " This function is examples 1,2,14,21,25,27. \n"
20897  "\n"
20898  "\n"
20899  "\n"
20900  "SYNOPSIS:\n"
20901  "\n"
20902  "plssub(nx, ny)\n"
20903  "\n"
20904  "ARGUMENTS:\n"
20905  "\n"
20906  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20907  " of window columns). \n"
20908  "\n"
20909  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20910  " of window rows). \n"
20911  "\n"
20912  ""},
20913  { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
20914  "Set symbol size \n"
20915  "\n"
20916  "DESCRIPTION:\n"
20917  "\n"
20918  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20919  " plsym. The actual height of a symbol is the product of the default\n"
20920  " symbol size and a scaling factor as for the character height. \n"
20921  "\n"
20922  " Redacted form: plssym(def, scale)\n"
20923  "\n"
20924  " This function is used in example 29. \n"
20925  "\n"
20926  "\n"
20927  "\n"
20928  "SYNOPSIS:\n"
20929  "\n"
20930  "plssym(def, scale)\n"
20931  "\n"
20932  "ARGUMENTS:\n"
20933  "\n"
20934  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20935  " should be set to zero if the default height is to remain\n"
20936  " unchanged. \n"
20937  "\n"
20938  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20939  " actual symbol height. \n"
20940  "\n"
20941  ""},
20942  { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
20943  "Initialization \n"
20944  "\n"
20945  "DESCRIPTION:\n"
20946  "\n"
20947  " Initializing the plotting package. The program prompts for the device\n"
20948  " keyword or number of the desired output device. Hitting a RETURN in\n"
20949  " response to the prompt is the same as selecting the first device. If\n"
20950  " only one device is enabled when PLplot is installed, plstar will issue\n"
20951  " no prompt. The output device is divided into nx by ny subpages, each\n"
20952  " of which may be used independently. The subroutine pladv is used to\n"
20953  " advance from one subpage to the next. \n"
20954  "\n"
20955  " Redacted form: plstar(nx, ny)\n"
20956  "\n"
20957  " This function is used in example 1. \n"
20958  "\n"
20959  "\n"
20960  "\n"
20961  "SYNOPSIS:\n"
20962  "\n"
20963  "plstar(nx, ny)\n"
20964  "\n"
20965  "ARGUMENTS:\n"
20966  "\n"
20967  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20968  " horizontal direction. \n"
20969  "\n"
20970  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20971  " vertical direction. \n"
20972  "\n"
20973  ""},
20974  { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
20975  "Initialization \n"
20976  "\n"
20977  "DESCRIPTION:\n"
20978  "\n"
20979  " Alternative to plstar for initializing the plotting package. The\n"
20980  " device name keyword for the desired output device must be supplied as\n"
20981  " an argument. These keywords are the same as those printed out by\n"
20982  " plstar. If the requested device is not available, or if the input\n"
20983  " string is empty or begins with ``?'', the prompted start up of plstar\n"
20984  " is used. This routine also divides the output device page into nx by\n"
20985  " ny subpages, each of which may be used independently. The subroutine\n"
20986  " pladv is used to advance from one subpage to the next. \n"
20987  "\n"
20988  " Redacted form: General: plstart(devname, nx, ny)\n"
20989  " Perl/PDL: plstart(nx, ny, devname)\n"
20990  "\n"
20991  "\n"
20992  " This function is not used in any examples. \n"
20993  "\n"
20994  "\n"
20995  "\n"
20996  "SYNOPSIS:\n"
20997  "\n"
20998  "plstart(devname, nx, ny)\n"
20999  "\n"
21000  "ARGUMENTS:\n"
21001  "\n"
21002  " devname (const char *, input) : Device name keyword of the required\n"
21003  " output device. If NULL or if the first character is a ``?'', the\n"
21004  " normal (prompted) start up is used. \n"
21005  "\n"
21006  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21007  " horizontal direction. \n"
21008  "\n"
21009  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21010  " vertical direction. \n"
21011  "\n"
21012  ""},
21013  { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
21014  "Set a global coordinate transform function \n"
21015  "\n"
21016  "DESCRIPTION:\n"
21017  "\n"
21018  " This function can be used to define a coordinate transformation which\n"
21019  " affects all elements drawn within the current plot window. The\n"
21020  " coordinate_transform function is similar to that provided for the\n"
21021  " plmap and plmeridians functions. The coordinate_transform_data\n"
21022  " parameter may be used to pass extra data to coordinate_transform. \n"
21023  "\n"
21024  " Redacted form: General: plstransform(coordinate_transform,\n"
21025  " coordinate_transform_data)\n"
21026  "\n"
21027  "\n"
21028  " This function is used in examples 19 and 22. \n"
21029  "\n"
21030  "\n"
21031  "\n"
21032  "SYNOPSIS:\n"
21033  "\n"
21034  "plstransform(coordinate_transform, coordinate_transform_data)\n"
21035  "\n"
21036  "ARGUMENTS:\n"
21037  "\n"
21038  " coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n"
21039  " PLPointer) , input) : Pointer to a function that defines a\n"
21040  " transformation from the input (x, y) coordinate to a new plot\n"
21041  " world coordinate. A NULL pointer means that no transform is\n"
21042  " applied. \n"
21043  "\n"
21044  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21045  " for \n"
21046  " coordinate_transform. \n"
21047  "\n"
21048  ""},
21049  { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
21050  "Plot a glyph at the specified points \n"
21051  "\n"
21052  "DESCRIPTION:\n"
21053  "\n"
21054  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21055  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21056  " is specified with a PLplot user string. Note that the user string is\n"
21057  " not actually limited to one glyph so it is possible (but not normally\n"
21058  " useful) to plot more than one glyph at the specified points with this\n"
21059  " function. As with plmtex and plptex, the user string can contain FCI\n"
21060  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21061  " else PLplot escapes for Hershey or unicode text to determine the\n"
21062  " glyph. \n"
21063  "\n"
21064  " Redacted form: plstring(x, y, string)\n"
21065  "\n"
21066  " This function is used in examples 4, 21 and 26. \n"
21067  "\n"
21068  "\n"
21069  "\n"
21070  "SYNOPSIS:\n"
21071  "\n"
21072  "plstring(n, x, y, string)\n"
21073  "\n"
21074  "ARGUMENTS:\n"
21075  "\n"
21076  " n (PLINT, input) : Number of points in the x and y arrays. \n"
21077  "\n"
21078  " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21079  " of points. \n"
21080  "\n"
21081  " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21082  " of points. \n"
21083  "\n"
21084  " string (const char *, input) : PLplot user string corresponding to\n"
21085  " the glyph to be plotted at each of the n points. \n"
21086  "\n"
21087  ""},
21088  { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
21089  "Plot a glyph at the specified 3D points \n"
21090  "\n"
21091  "DESCRIPTION:\n"
21092  "\n"
21093  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21094  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21095  " this function similar to what is done for plline3. The glyph is\n"
21096  " specified with a PLplot user string. Note that the user string is not\n"
21097  " actually limited to one glyph so it is possible (but not normally\n"
21098  " useful) to plot more than one glyph at the specified points with this\n"
21099  " function. As with plmtex and plptex, the user string can contain FCI\n"
21100  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21101  " else PLplot escapes for Hershey or unicode text to determine the\n"
21102  " glyph. \n"
21103  "\n"
21104  " Redacted form: plstring3(x, y, z, string)\n"
21105  "\n"
21106  " This function is used in example 18. \n"
21107  "\n"
21108  "\n"
21109  "\n"
21110  "SYNOPSIS:\n"
21111  "\n"
21112  "plstring3(n, x, y, z, string)\n"
21113  "\n"
21114  "ARGUMENTS:\n"
21115  "\n"
21116  " n (PLINT, input) : Number of points in the x, y, and z arrays. \n"
21117  "\n"
21118  " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21119  " of points. \n"
21120  "\n"
21121  " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21122  " of points. \n"
21123  "\n"
21124  " z (const PLFLT *, input) : Pointer to an array with Z coordinates\n"
21125  " of points. \n"
21126  "\n"
21127  " string (const char *, input) : PLplot user string corresponding to\n"
21128  " the glyph to be plotted at each of the n points. \n"
21129  "\n"
21130  ""},
21131  { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
21132  "Add a point to a strip chart \n"
21133  "\n"
21134  "DESCRIPTION:\n"
21135  "\n"
21136  " Add a point to a given pen of a given strip chart. There is no need\n"
21137  " for all pens to have the same number of points or to be equally\n"
21138  " sampled in the x coordinate. Allocates memory and rescales as\n"
21139  " necessary. \n"
21140  "\n"
21141  " Redacted form: plstripa(id, pen, x, y)\n"
21142  "\n"
21143  " This function is used in example 17. \n"
21144  "\n"
21145  "\n"
21146  "\n"
21147  "SYNOPSIS:\n"
21148  "\n"
21149  "plstripa(id, pen, x, y)\n"
21150  "\n"
21151  "ARGUMENTS:\n"
21152  "\n"
21153  " id (PLINT, input) : Identification number of the strip chart (set\n"
21154  " up in plstripc). \n"
21155  "\n"
21156  " pen (PLINT, input) : Pen number (ranges from 0 to 3). \n"
21157  "\n"
21158  " x (PLFLT, input) : X coordinate of point to plot. \n"
21159  "\n"
21160  " y (PLFLT, input) : Y coordinate of point to plot. \n"
21161  "\n"
21162  ""},
21163  { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
21164  "Create a 4-pen strip chart \n"
21165  "\n"
21166  "DESCRIPTION:\n"
21167  "\n"
21168  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21169  "\n"
21170  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21171  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21172  " styline, legline, labx, laby, labz)\n"
21173  " Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
21174  " ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
21175  " ypsec, legline, labx, laby, labtop)\n"
21176  "\n"
21177  "\n"
21178  " This function is used in example 17. \n"
21179  "\n"
21180  "\n"
21181  "\n"
21182  "SYNOPSIS:\n"
21183  "\n"
21184  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21185  "\n"
21186  "ARGUMENTS:\n"
21187  "\n"
21188  " id (PLINT *, output) : Identification number of strip chart to use\n"
21189  " on plstripa and plstripd. \n"
21190  "\n"
21191  " xspec (const char *, input) : X-axis specification as in plbox. \n"
21192  "\n"
21193  " yspec (const char *, input) : Y-axis specification as in plbox. \n"
21194  "\n"
21195  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21196  " change as data are added. \n"
21197  "\n"
21198  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21199  " change as data are added. \n"
21200  "\n"
21201  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21202  " is multiplied by the factor (1 + \n"
21203  " xjump) . \n"
21204  "\n"
21205  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21206  " change as data are added. \n"
21207  "\n"
21208  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21209  " change as data are added. \n"
21210  "\n"
21211  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n"
21212  "\n"
21213  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n"
21214  "\n"
21215  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21216  " true, otherwise not. \n"
21217  "\n"
21218  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21219  " otherwise slide display. \n"
21220  "\n"
21221  " colbox (PLINT, input) : Plot box color index (cmap0). \n"
21222  "\n"
21223  " collab (PLINT, input) : Legend color index (cmap0). \n"
21224  "\n"
21225  " colline (const PLINT *, input) : Pointer to array with color\n"
21226  " indices (cmap0) for the 4 pens. \n"
21227  "\n"
21228  " styline (const PLINT *, input) : Pointer to array with line styles\n"
21229  " for the 4 pens. \n"
21230  "\n"
21231  " legline (const char **, input) : Pointer to character array\n"
21232  " containing legends for the 4 pens. \n"
21233  "\n"
21234  " labx (const char *, input) : X-axis label. \n"
21235  "\n"
21236  " laby (const char *, input) : Y-axis label. \n"
21237  "\n"
21238  " labtop (const char *, input) : Plot title. \n"
21239  "\n"
21240  ""},
21241  { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
21242  "Deletes and releases memory used by a strip chart \n"
21243  "\n"
21244  "DESCRIPTION:\n"
21245  "\n"
21246  " Deletes and releases memory used by a strip chart. \n"
21247  "\n"
21248  " Redacted form: plstripd(id)\n"
21249  "\n"
21250  " This function is used in example 17. \n"
21251  "\n"
21252  "\n"
21253  "\n"
21254  "SYNOPSIS:\n"
21255  "\n"
21256  "plstripd(id)\n"
21257  "\n"
21258  "ARGUMENTS:\n"
21259  "\n"
21260  " id (PLINT, input) : Identification number of strip chart to delete. \n"
21261  "\n"
21262  ""},
21263  { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
21264  "Set line style \n"
21265  "\n"
21266  "DESCRIPTION:\n"
21267  "\n"
21268  " This sets up the line style for all lines subsequently drawn. A line\n"
21269  " consists of segments in which the pen is alternately down and up. The\n"
21270  " lengths of these segments are passed in the arrays mark and space\n"
21271  " respectively. The number of mark-space pairs is specified by nms. In\n"
21272  " order to return the line style to the default continuous line, plstyl\n"
21273  " should be called with nms=0 .(see also pllsty) \n"
21274  "\n"
21275  " Redacted form: plstyl(mark, space)\n"
21276  "\n"
21277  " This function is used in examples 1,9,14. \n"
21278  "\n"
21279  "\n"
21280  "\n"
21281  "SYNOPSIS:\n"
21282  "\n"
21283  "plstyl(nms, mark, space)\n"
21284  "\n"
21285  "ARGUMENTS:\n"
21286  "\n"
21287  " nms (PLINT, input) : The number of mark and space elements in a\n"
21288  " line. Thus a simple broken line can be obtained by setting nms=1\n"
21289  " . A continuous line is specified by setting nms=0 . \n"
21290  "\n"
21291  " mark (const PLINT *, input) : Pointer to array with the lengths of\n"
21292  " the segments during which the pen is down, measured in\n"
21293  " micrometers. \n"
21294  "\n"
21295  " space (const PLINT *, input) : Pointer to array with the lengths of\n"
21296  " the segments during which the pen is up, measured in micrometers. \n"
21297  "\n"
21298  ""},
21299  { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
21300  "Set arrow style for vector plots \n"
21301  "\n"
21302  "DESCRIPTION:\n"
21303  "\n"
21304  " Set the style for the arrow used by plvect to plot vectors. \n"
21305  "\n"
21306  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21307  "\n"
21308  " This function is used in example 22. \n"
21309  "\n"
21310  "\n"
21311  "\n"
21312  "SYNOPSIS:\n"
21313  "\n"
21314  "plsvect(arrowx, arrowy, npts, fill)\n"
21315  "\n"
21316  "ARGUMENTS:\n"
21317  "\n"
21318  " arrowx, arrowy (const PLFLT *,input) : Pointers to a pair of arrays\n"
21319  " containing the x and y points which make up the arrow. The arrow\n"
21320  " is plotted by joining these points to form a polygon. The scaling\n"
21321  " assumes that the x and y points in the arrow lie in the range -0.5\n"
21322  " <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n"
21323  " style will be reset to its default. \n"
21324  "\n"
21325  " npts (PLINT,input) : Number of points in the arrays arrowx and\n"
21326  " arrowy. \n"
21327  "\n"
21328  " fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n"
21329  " fill is false then the arrow is open. \n"
21330  "\n"
21331  ""},
21332  { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
21333  "Specify viewport in absolute coordinates \n"
21334  "\n"
21335  "DESCRIPTION:\n"
21336  "\n"
21337  " Alternate routine to plvpor for setting up the viewport. This routine\n"
21338  " should be used only if the viewport is required to have a definite\n"
21339  " size in millimeters. The routine plgspa is useful for finding out the\n"
21340  " size of the current subpage. \n"
21341  "\n"
21342  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21343  "\n"
21344  " This function is used in example 10. \n"
21345  "\n"
21346  "\n"
21347  "\n"
21348  "SYNOPSIS:\n"
21349  "\n"
21350  "plsvpa(xmin, xmax, ymin, ymax)\n"
21351  "\n"
21352  "ARGUMENTS:\n"
21353  "\n"
21354  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21355  " viewport from the left-hand edge of the subpage in millimeters. \n"
21356  "\n"
21357  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21358  " viewport from the left-hand edge of the subpage in millimeters. \n"
21359  "\n"
21360  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21361  " viewport from the bottom edge of the subpage in millimeters. \n"
21362  "\n"
21363  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21364  " from the bottom edge of the subpage in millimeters. \n"
21365  "\n"
21366  ""},
21367  { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
21368  "Set x axis parameters \n"
21369  "\n"
21370  "DESCRIPTION:\n"
21371  "\n"
21372  " Sets values of the digmax and digits flags for the x axis. See the\n"
21373  " PLplot documentation for more information. \n"
21374  "\n"
21375  " Redacted form: plsxax(digmax, digits)\n"
21376  "\n"
21377  " This function is used in example 31. \n"
21378  "\n"
21379  "\n"
21380  "\n"
21381  "SYNOPSIS:\n"
21382  "\n"
21383  "plsxax(digmax, digits)\n"
21384  "\n"
21385  "ARGUMENTS:\n"
21386  "\n"
21387  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21388  " digits for the x axis. If nonzero, the printed label will be\n"
21389  " switched to a floating point representation when the number of\n"
21390  " digits exceeds digmax. \n"
21391  "\n"
21392  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21393  " its value here has no effect since it is set only by plbox or\n"
21394  " plbox3. However, the user may obtain its value after a call to\n"
21395  " either of these functions by calling plgxax. \n"
21396  "\n"
21397  ""},
21398  { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
21399  "Set y axis parameters \n"
21400  "\n"
21401  "DESCRIPTION:\n"
21402  "\n"
21403  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21404  " the description of plsxax for more detail. \n"
21405  "\n"
21406  " Redacted form: plsyax(digmax, digits)\n"
21407  "\n"
21408  " This function is used in examples 1,14,31. \n"
21409  "\n"
21410  "\n"
21411  "\n"
21412  "SYNOPSIS:\n"
21413  "\n"
21414  "plsyax(digmax, digits)\n"
21415  "\n"
21416  "ARGUMENTS:\n"
21417  "\n"
21418  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21419  " digits for the y axis. If nonzero, the printed label will be\n"
21420  " switched to a floating point representation when the number of\n"
21421  " digits exceeds digmax. \n"
21422  "\n"
21423  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21424  " its value here has no effect since it is set only by plbox or\n"
21425  " plbox3. However, the user may obtain its value after a call to\n"
21426  " either of these functions by calling plgyax. \n"
21427  "\n"
21428  ""},
21429  { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
21430  "Plot a glyph at the specified points \n"
21431  "\n"
21432  "DESCRIPTION:\n"
21433  "\n"
21434  " Plot a glyph at the specified points. (This function is largely\n"
21435  " superseded by plstring which gives access to many[!] more glyphs.) \n"
21436  "\n"
21437  " Redacted form: plsym(x, y, code)\n"
21438  "\n"
21439  " This function is used in example 7. \n"
21440  "\n"
21441  "\n"
21442  "\n"
21443  "SYNOPSIS:\n"
21444  "\n"
21445  "plsym(n, x, y, code)\n"
21446  "\n"
21447  "ARGUMENTS:\n"
21448  "\n"
21449  " n (PLINT, input) : Number of points in the x and y arrays. \n"
21450  "\n"
21451  " x (const PLFLT *, input) : Pointer to an array with X coordinates\n"
21452  " of points. \n"
21453  "\n"
21454  " y (const PLFLT *, input) : Pointer to an array with Y coordinates\n"
21455  " of points. \n"
21456  "\n"
21457  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21458  " to be plotted at each of the n points. \n"
21459  "\n"
21460  ""},
21461  { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21462  "Set z axis parameters \n"
21463  "\n"
21464  "DESCRIPTION:\n"
21465  "\n"
21466  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21467  " the description of plsxax for more detail. \n"
21468  "\n"
21469  " Redacted form: plszax(digmax, digits)\n"
21470  "\n"
21471  " This function is used in example 31. \n"
21472  "\n"
21473  "\n"
21474  "\n"
21475  "SYNOPSIS:\n"
21476  "\n"
21477  "plszax(digmax, digits)\n"
21478  "\n"
21479  "ARGUMENTS:\n"
21480  "\n"
21481  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21482  " digits for the z axis. If nonzero, the printed label will be\n"
21483  " switched to a floating point representation when the number of\n"
21484  " digits exceeds digmax. \n"
21485  "\n"
21486  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21487  " its value here has no effect since it is set only by plbox or\n"
21488  " plbox3. However, the user may obtain its value after a call to\n"
21489  " either of these functions by calling plgzax. \n"
21490  "\n"
21491  ""},
21492  { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21493  "Switch to text screen \n"
21494  "\n"
21495  "DESCRIPTION:\n"
21496  "\n"
21497  " Sets an interactive device to text mode, used in conjunction with\n"
21498  " plgra to allow graphics and text to be interspersed. On a device\n"
21499  " which supports separate text and graphics windows, this command causes\n"
21500  " control to be switched to the text window. This can be useful for\n"
21501  " printing diagnostic messages or getting user input, which would\n"
21502  " otherwise interfere with the plots. The program must switch back to\n"
21503  " the graphics window before issuing plot commands, as the text (or\n"
21504  " console) device will probably become quite confused otherwise. If\n"
21505  " already in text mode, this command is ignored. It is also ignored on\n"
21506  " devices which only support a single window or use a different method\n"
21507  " for shifting focus (see also plgra). \n"
21508  "\n"
21509  " Redacted form: pltext()\n"
21510  "\n"
21511  " This function is used in example 1. \n"
21512  "\n"
21513  "\n"
21514  "\n"
21515  "SYNOPSIS:\n"
21516  "\n"
21517  "pltext()\n"
21518  "\n"
21519  ""},
21520  { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21521  "Set format for date / time labels \n"
21522  "\n"
21523  "DESCRIPTION:\n"
21524  "\n"
21525  " Sets the format for date / time labels. To enable date / time format\n"
21526  " labels see the options to plbox and plenv. \n"
21527  "\n"
21528  " Redacted form: pltimefmt(fmt)\n"
21529  "\n"
21530  " This function is used in example 29. \n"
21531  "\n"
21532  "\n"
21533  "\n"
21534  "SYNOPSIS:\n"
21535  "\n"
21536  "pltimefmt(fmt)\n"
21537  "\n"
21538  "ARGUMENTS:\n"
21539  "\n"
21540  " fmt (const char *, fmt) : This string is passed directly to the\n"
21541  " system strftime. See the system documentation for a full list of\n"
21542  " conversion specifications for your system. All conversion\n"
21543  " specifications take the form of a '%' character followed by\n"
21544  " further conversion specification character. All other text is\n"
21545  " printed as-is. Common options include: %c: The preferred date and\n"
21546  " time representation for the current locale. \n"
21547  " %d: The day of the month as a decimal number. \n"
21548  " %H: The hour as a decimal number using a 24-hour clock. \n"
21549  " %j: The day of the year as a decimal number. \n"
21550  " %m: The month as a decimal number. \n"
21551  " %M: The minute as a decimal number. \n"
21552  " %S: The second as a decimal number. \n"
21553  " %y: The year as a decimal number without a century. \n"
21554  " %Y: The year as a decimal number including a century. \n"
21555  "\n"
21556  ""},
21557  { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
21558  "Specify viewport using aspect ratio only \n"
21559  "\n"
21560  "DESCRIPTION:\n"
21561  "\n"
21562  " Sets the viewport so that the ratio of the length of the y axis to\n"
21563  " that of the x axis is equal to aspect. \n"
21564  "\n"
21565  " Redacted form: plvasp(aspect)\n"
21566  "\n"
21567  " This function is used in example 13. \n"
21568  "\n"
21569  "\n"
21570  "\n"
21571  "SYNOPSIS:\n"
21572  "\n"
21573  "plvasp(aspect)\n"
21574  "\n"
21575  "ARGUMENTS:\n"
21576  "\n"
21577  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21578  " axis. \n"
21579  "\n"
21580  ""},
21581  { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
21582  "Vector plot \n"
21583  "\n"
21584  "DESCRIPTION:\n"
21585  "\n"
21586  " Draws a vector plot of the vector (\n"
21587  " u[\n"
21588  " nx][\n"
21589  " ny],\n"
21590  " v[\n"
21591  " nx][\n"
21592  " ny]) . The scaling factor for the vectors is given by scale. A\n"
21593  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21594  " additional data required by the transformation routine is used to map\n"
21595  " indices within the array to the world coordinates. The style of the\n"
21596  " vector arrow may be set using plsvect. \n"
21597  "\n"
21598  " Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
21599  "\n"
21600  " This function is used in example 22. \n"
21601  "\n"
21602  "\n"
21603  "\n"
21604  "SYNOPSIS:\n"
21605  "\n"
21606  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21607  "\n"
21608  "ARGUMENTS:\n"
21609  "\n"
21610  " u, v (const PLFLT * const *, input) : Pointers to a pair of\n"
21611  " vectored two-dimensional arrays containing the x and y components\n"
21612  " of the vector data to be plotted. \n"
21613  "\n"
21614  " nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n"
21615  "\n"
21616  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21617  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21618  " automatically calculated for the data. If scale < 0 then the\n"
21619  " scaling factor is automatically calculated for the data and then\n"
21620  " multiplied by -\n"
21621  " scale. If scale > 0 then the scaling factor is set to scale. \n"
21622  "\n"
21623  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
21624  " Pointer to function that defines transformation between indices\n"
21625  " in array z and the world coordinates (C only). Transformation\n"
21626  " functions are provided in the PLplot library: pltr0 for identity\n"
21627  " mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
21628  " defined by one- and two-dimensional arrays. In addition,\n"
21629  " user-supplied routines for the transformation can be used as well.\n"
21630  " Examples of all of these approaches are given in the PLplot\n"
21631  " documentation. The transformation function should have the form\n"
21632  " given by any of pltr0, pltr1, or pltr2. \n"
21633  "\n"
21634  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21635  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
21636  " externally supplied. \n"
21637  "\n"
21638  ""},
21639  { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
21640  "Specify viewport using coordinates and aspect ratio \n"
21641  "\n"
21642  "DESCRIPTION:\n"
21643  "\n"
21644  " Device-independent routine for setting up the viewport. The viewport\n"
21645  " is chosen to be the largest with the given aspect ratio that fits\n"
21646  " within the specified region (in terms of normalized subpage\n"
21647  " coordinates). This routine is functionally equivalent to plvpor when\n"
21648  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21649  " routine reserves no extra space at the edges for labels. \n"
21650  "\n"
21651  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21652  "\n"
21653  " This function is used in example 9. \n"
21654  "\n"
21655  "\n"
21656  "\n"
21657  "SYNOPSIS:\n"
21658  "\n"
21659  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21660  "\n"
21661  "ARGUMENTS:\n"
21662  "\n"
21663  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21664  " left-hand edge of the viewport. \n"
21665  "\n"
21666  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21667  " right-hand edge of the viewport. \n"
21668  "\n"
21669  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21670  " bottom edge of the viewport. \n"
21671  "\n"
21672  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21673  " edge of the viewport. \n"
21674  "\n"
21675  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21676  " axis. \n"
21677  "\n"
21678  ""},
21679  { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
21680  "Specify viewport using coordinates \n"
21681  "\n"
21682  "DESCRIPTION:\n"
21683  "\n"
21684  " Device-independent routine for setting up the viewport. This defines\n"
21685  " the viewport in terms of normalized subpage coordinates which run from\n"
21686  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21687  " current subpage. Use the alternate routine plsvpa in order to create\n"
21688  " a viewport of a definite size. \n"
21689  "\n"
21690  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21691  "\n"
21692  " This function is used in examples\n"
21693  " 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
21694  "\n"
21695  "\n"
21696  "\n"
21697  "SYNOPSIS:\n"
21698  "\n"
21699  "plvpor(xmin, xmax, ymin, ymax)\n"
21700  "\n"
21701  "ARGUMENTS:\n"
21702  "\n"
21703  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21704  " left-hand edge of the viewport. \n"
21705  "\n"
21706  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21707  " right-hand edge of the viewport. \n"
21708  "\n"
21709  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21710  " bottom edge of the viewport. \n"
21711  "\n"
21712  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21713  " edge of the viewport. \n"
21714  "\n"
21715  ""},
21716  { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
21717  "Select standard viewport \n"
21718  "\n"
21719  "DESCRIPTION:\n"
21720  "\n"
21721  " Sets up a standard viewport, leaving a left-hand margin of seven\n"
21722  " character heights, and four character heights around the other three\n"
21723  " sides. \n"
21724  "\n"
21725  " Redacted form: plvsta()\n"
21726  "\n"
21727  " This function is used in examples 1,12,14,17,25,29. \n"
21728  "\n"
21729  "\n"
21730  "\n"
21731  "SYNOPSIS:\n"
21732  "\n"
21733  "plvsta()\n"
21734  "\n"
21735  ""},
21736  { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
21737  "Set up window for 3-d plotting \n"
21738  "\n"
21739  "DESCRIPTION:\n"
21740  "\n"
21741  " Sets up a window for a three-dimensional surface plot within the\n"
21742  " currently defined two-dimensional window. The enclosing box for the\n"
21743  " surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
21744  " user-coordinate space is mapped into a box of world coordinate size\n"
21745  " basex by basey by height so that xmin maps to -\n"
21746  " basex/2 , xmax maps to basex/2 , ymin maps to -\n"
21747  " basey/2 , ymax maps to basey/2 , zmin maps to 0 and zmax maps to\n"
21748  " height. The resulting world-coordinate box is then viewed by an\n"
21749  " observer at altitude alt and azimuth az. This routine must be called\n"
21750  " before plbox3 or plot3d. For a more complete description of\n"
21751  " three-dimensional plotting see the PLplot documentation. \n"
21752  "\n"
21753  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21754  " zmin, zmax, alt, az)\n"
21755  "\n"
21756  " This function is examples 8,11,18,21. \n"
21757  "\n"
21758  "\n"
21759  "\n"
21760  "SYNOPSIS:\n"
21761  "\n"
21762  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21763  "\n"
21764  "ARGUMENTS:\n"
21765  "\n"
21766  " basex (PLFLT, input) : The x coordinate size of the\n"
21767  " world-coordinate box. \n"
21768  "\n"
21769  " basey (PLFLT, input) : The y coordinate size of the\n"
21770  " world-coordinate box. \n"
21771  "\n"
21772  " height (PLFLT, input) : The z coordinate size of the\n"
21773  " world-coordinate box. \n"
21774  "\n"
21775  " xmin (PLFLT, input) : The minimum user x coordinate value. \n"
21776  "\n"
21777  " xmax (PLFLT, input) : The maximum user x coordinate value. \n"
21778  "\n"
21779  " ymin (PLFLT, input) : The minimum user y coordinate value. \n"
21780  "\n"
21781  " ymax (PLFLT, input) : The maximum user y coordinate value. \n"
21782  "\n"
21783  " zmin (PLFLT, input) : The minimum user z coordinate value. \n"
21784  "\n"
21785  " zmax (PLFLT, input) : The maximum user z coordinate value. \n"
21786  "\n"
21787  " alt (PLFLT, input) : The viewing altitude in degrees above the XY\n"
21788  " plane. \n"
21789  "\n"
21790  " az (PLFLT, input) : The viewing azimuth in degrees. When az=0 ,\n"
21791  " the observer is looking face onto the ZX plane, and as az is\n"
21792  " increased, the observer moves clockwise around the box when viewed\n"
21793  " from above the XY plane. \n"
21794  "\n"
21795  ""},
21796  { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
21797  "Set pen width \n"
21798  "\n"
21799  "DESCRIPTION:\n"
21800  "\n"
21801  " Sets the pen width. \n"
21802  "\n"
21803  " Redacted form: plwidth(width)\n"
21804  "\n"
21805  " This function is used in examples 1,2. \n"
21806  "\n"
21807  "\n"
21808  "\n"
21809  "SYNOPSIS:\n"
21810  "\n"
21811  "plwidth(width)\n"
21812  "\n"
21813  "ARGUMENTS:\n"
21814  "\n"
21815  " width (PLFLT, input) : The desired pen width. If width is negative\n"
21816  " or the same as the previous value no action is taken. width = 0. \n"
21817  " should be interpreted as as the minimum valid pen width for the\n"
21818  " device. The interpretation of positive width values is also\n"
21819  " device dependent. \n"
21820  "\n"
21821  ""},
21822  { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
21823  "Specify world coordinates of viewport boundaries \n"
21824  "\n"
21825  "DESCRIPTION:\n"
21826  "\n"
21827  " Sets up the world coordinates of the edges of the viewport. \n"
21828  "\n"
21829  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21830  "\n"
21831  " This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
21832  "\n"
21833  "\n"
21834  "\n"
21835  "SYNOPSIS:\n"
21836  "\n"
21837  "plwind(xmin, xmax, ymin, ymax)\n"
21838  "\n"
21839  "ARGUMENTS:\n"
21840  "\n"
21841  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21842  " of the viewport. \n"
21843  "\n"
21844  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21845  " of the viewport. \n"
21846  "\n"
21847  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21848  " the viewport. \n"
21849  "\n"
21850  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21851  " viewport. \n"
21852  "\n"
21853  ""},
21854  { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
21855  "Enter or leave xor mode \n"
21856  "\n"
21857  "DESCRIPTION:\n"
21858  "\n"
21859  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21860  " those drivers (e.g., the xwin driver) that support it. Enables\n"
21861  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21862  " is not capable of xor operation it returns a status of false. \n"
21863  "\n"
21864  " Redacted form: plxormod(mode, status)\n"
21865  "\n"
21866  " This function is used in examples 1,20. \n"
21867  "\n"
21868  "\n"
21869  "\n"
21870  "SYNOPSIS:\n"
21871  "\n"
21872  "plxormod(mode, status)\n"
21873  "\n"
21874  "ARGUMENTS:\n"
21875  "\n"
21876  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21877  " is false means leave xor mode. \n"
21878  "\n"
21879  " status (PLBOOL *, output) : Pointer to status. Returned modestatus\n"
21880  " of true (false) means driver is capable (incapable) of xor mode. \n"
21881  "\n"
21882  ""},
21883  { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
21884  "Plot continental outline or shapefile data in world coordinates \n"
21885  "\n"
21886  "DESCRIPTION:\n"
21887  "\n"
21888  " Plots continental outlines or shapefile data in world coordinates. A\n"
21889  " demonstration of how to use this function to create different \n"
21890  " projections can be found in examples/c/x19c. Plplot is provided with\n"
21891  " basic coastal outlines and USA state borders. These can be used\n"
21892  " irrespective of whether Shapefile support is built into Plplot. With\n"
21893  " Shapefile support this function can also be used with user Shapefiles,\n"
21894  " in which case it will plot the entire contents of a Shapefile joining\n"
21895  " each point of each Shapefile element with a line. Shapefiles have\n"
21896  " become a popular standard for geographical data and data in this\n"
21897  " format can be easily found from a number of online sources. Shapefile\n"
21898  " data is actually provided as three or more files with the same\n"
21899  " filename, but different extensions. The .shp and .shx files are\n"
21900  " required for plotting Shapefile data with Plplot. \n"
21901  "\n"
21902  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21903  "\n"
21904  " This function is used in example 19. \n"
21905  "\n"
21906  "\n"
21907  "\n"
21908  "SYNOPSIS:\n"
21909  "\n"
21910  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21911  "\n"
21912  "ARGUMENTS:\n"
21913  "\n"
21914  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
21915  " supplied function to transform the original map data coordinates\n"
21916  " to a new coordinate system. The Plplot supplied map data is\n"
21917  " provided as latitudes and longitudes; other Shapefile data may be\n"
21918  " provided in other coordinate systems as can be found in their .prj\n"
21919  " plain text files. For example, by using this transform we can\n"
21920  " change from a longitude, latitude coordinate to a polar\n"
21921  " stereographic projection. Initially, x[0]..[n-1] are the original\n"
21922  " x coordinates (longitudes for the Plplot suplied data) and\n"
21923  " y[0]..y[n-1] are the corresponding y coordinates (latitudes for\n"
21924  " the Plplot supplied data). After the call to mapform(), x[] and\n"
21925  " y[] should be replaced by the corresponding plot coordinates. If\n"
21926  " no transform is desired, mapform can be replaced by NULL. \n"
21927  "\n"
21928  " name (const char *, input) : A character string which determines\n"
21929  " the type of map plotted. This is either one of the Plplot built\n"
21930  " in maps or the file name of a set of Shapefile files without the\n"
21931  " file extensions. For the Plplot built in maps the possible values\n"
21932  " are: \"globe\" -- continental outlines \n"
21933  " \"usa\" -- USA and state boundaries \n"
21934  " \"cglobe\" -- continental outlines and countries \n"
21935  " \"usaglobe\" -- USA, state boundaries and continental outlines \n"
21936  "\n"
21937  "\n"
21938  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21939  " drawn. For the built in maps this is a measure of longitude. For\n"
21940  " Shapefiles the units must match the projection. The value of minx\n"
21941  " must be less than the value of maxx. Specifying a useful limit for\n"
21942  " these limits provides a useful optimization for complex or\n"
21943  " detailed maps. \n"
21944  "\n"
21945  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21946  " drawn \n"
21947  "\n"
21948  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21949  " drawn. For the built in maps this is a measure of latitude. For\n"
21950  " Shapefiles the units must match the projection. The value of miny\n"
21951  " must be less than the value of maxy. \n"
21952  "\n"
21953  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21954  " drawn. \n"
21955  "\n"
21956  ""},
21957  { (char *)"plmapline", _wrap_plmapline, METH_VARARGS, (char *)"\n"
21958  "Plot all or a subset of Shapefile data using lines in world coordinates \n"
21959  "\n"
21960  "DESCRIPTION:\n"
21961  "\n"
21962  " Plot all or a subset of Shapefile data using lines in world\n"
21963  " coordinates. examples/c/x19c demonstrates how to use this function.\n"
21964  " This function plots data from a Shapefile using lines as in plmap,\n"
21965  " however it also has the option of also only drawing specified elements\n"
21966  " from the Shapefile. The indices of the required elements are passed\n"
21967  " into the function as an array. The Shapefile data should include a\n"
21968  " metadata file (extension.dbf) listing all items within the Shapefile.\n"
21969  " This file can be opened by most popular spreadsheet programs and can\n"
21970  " be used to decide which indices to pass to this function. \n"
21971  "\n"
21972  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21973  " plotentries)\n"
21974  "\n"
21975  " This function is used in example 19. \n"
21976  "\n"
21977  "\n"
21978  "\n"
21979  "SYNOPSIS:\n"
21980  "\n"
21981  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21982  "\n"
21983  "ARGUMENTS:\n"
21984  "\n"
21985  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
21986  " supplied function to transform the coordinates given in the\n"
21987  " shapefile into a plot coordinate system. By using this transform,\n"
21988  " we can change from a longitude, latitude coordinate to a polar\n"
21989  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
21990  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
21991  " After the call to mapform(), x[] and y[] should be replaced by the\n"
21992  " corresponding plot coordinates. If no transform is desired,\n"
21993  " mapform can be replaced by NULL. \n"
21994  "\n"
21995  " name (const char *, input) : The file name of a set of Shapefile\n"
21996  " files without the file extension. \n"
21997  "\n"
21998  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21999  " be in the same units as used by the Shapefile. You could use a\n"
22000  " very large negative number to plot everything, but you can improve\n"
22001  " performance by limiting the area drawn. The units must match those\n"
22002  " of the Shapefile projection, which may be for example longitude or\n"
22003  " distance. The value of minx must be less than the value of maxx. \n"
22004  "\n"
22005  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22006  " use a very large number to plot everything, but you can improve\n"
22007  " performance by limiting the area drawn. \n"
22008  "\n"
22009  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22010  " be in the same units as used by the Shapefile. You could use a\n"
22011  " very large negative number to plot everything, but you can improve\n"
22012  " performance by limiting the area drawn. The units must match those\n"
22013  " of the Shapefile projection, which may be for example latitude or\n"
22014  " distance. The value of miny must be less than the value of maxy. \n"
22015  "\n"
22016  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22017  " use a very large number to plot everything, but you can improve\n"
22018  " performance by limiting the area drawn. \n"
22019  "\n"
22020  " plotentries (const PLINT *, input) : An array of integers\n"
22021  " indicating the elements of the Shapefile (zero indexed) which will\n"
22022  " be drawn. Setting plotentries to NULL will plot all elements of\n"
22023  " the Shapefile. \n"
22024  "\n"
22025  " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22026  " Ignored if plotentries is NULL. \n"
22027  "\n"
22028  ""},
22029  { (char *)"plmapstring", _wrap_plmapstring, METH_VARARGS, (char *)"\n"
22030  "Plot all or a subset of Shapefile data using strings or points in world coordinates \n"
22031  "\n"
22032  "DESCRIPTION:\n"
22033  "\n"
22034  " As per plmapline, however the items are plotted as strings or points\n"
22035  " in the same way as plstring. \n"
22036  "\n"
22037  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22038  " maxy, plotentries)\n"
22039  "\n"
22040  " This function is used in example 19. \n"
22041  "\n"
22042  "\n"
22043  "\n"
22044  "SYNOPSIS:\n"
22045  "\n"
22046  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22047  "\n"
22048  "ARGUMENTS:\n"
22049  "\n"
22050  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22051  " supplied function to transform the coordinates given in the\n"
22052  " shapefile into a plot coordinate system. By using this transform,\n"
22053  " we can change from a longitude, latitude coordinate to a polar\n"
22054  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22055  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22056  " After the call to mapform(), x[] and y[] should be replaced by the\n"
22057  " corresponding plot coordinates. If no transform is desired,\n"
22058  " mapform can be replaced by NULL. \n"
22059  "\n"
22060  " name (const char *, input) : The file name of a set of Shapefile\n"
22061  " files without the file extension. \n"
22062  "\n"
22063  " string (const char *, input) : A NULL terminated string of\n"
22064  " characters to be drawn. \n"
22065  "\n"
22066  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22067  " be in the same units as used by the Shapefile. You could use a\n"
22068  " very large negative number to plot everything, but you can improve\n"
22069  " performance by limiting the area drawn. The units must match those\n"
22070  " of the Shapefile projection, which may be for example longitude or\n"
22071  " distance. The value of minx must be less than the value of maxx. \n"
22072  "\n"
22073  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22074  " use a very large number to plot everything, but you can improve\n"
22075  " performance by limiting the area drawn. \n"
22076  "\n"
22077  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22078  " be in the same units as used by the Shapefile. You could use a\n"
22079  " very large negative number to plot everything, but you can improve\n"
22080  " performance by limiting the area drawn. The units must match those\n"
22081  " of the Shapefile projection, which may be for example latitude or\n"
22082  " distance. The value of miny must be less than the value of maxy. \n"
22083  "\n"
22084  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22085  " use a very large number to plot everything, but you can improve\n"
22086  " performance by limiting the area drawn. \n"
22087  "\n"
22088  " plotentries (const PLINT *, input) : An array of integers\n"
22089  " indicating the elements of the Shapefile (zero indexed) which will\n"
22090  " be drawn. Setting plotentries to NULL will plot all elements of\n"
22091  " the Shapefile. \n"
22092  "\n"
22093  " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22094  " Ignored if plotentries is NULL. \n"
22095  "\n"
22096  ""},
22097  { (char *)"plmaptex", _wrap_plmaptex, METH_VARARGS, (char *)"\n"
22098  "Draw text at points defined by Shapefile data in world coordinates \n"
22099  "\n"
22100  "DESCRIPTION:\n"
22101  "\n"
22102  " As per plmapline, however the items are plotted as text in the same\n"
22103  " way as plptex. \n"
22104  "\n"
22105  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22106  " miny, maxy, plotentry)\n"
22107  "\n"
22108  " This function is used in example 19. \n"
22109  "\n"
22110  "\n"
22111  "\n"
22112  "SYNOPSIS:\n"
22113  "\n"
22114  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22115  "\n"
22116  "ARGUMENTS:\n"
22117  "\n"
22118  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22119  " supplied function to transform the coordinates given in the\n"
22120  " shapefile into a plot coordinate system. By using this transform,\n"
22121  " we can change from a longitude, latitude coordinate to a polar\n"
22122  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22123  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22124  " After the call to mapform(), x[] and y[] should be replaced by the\n"
22125  " corresponding plot coordinates. If no transform is desired,\n"
22126  " mapform can be replaced by NULL. \n"
22127  "\n"
22128  " name (const char *, input) : The file name of a set of Shapefile\n"
22129  " files without the file extension. \n"
22130  "\n"
22131  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22132  " dy/dx. \n"
22133  "\n"
22134  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22135  " dy/dx. \n"
22136  "\n"
22137  " just (PLFLT, input) : Set the justification of the text. The value\n"
22138  " given will be the fraction of the distance along the string that\n"
22139  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22140  " centralized text and 1.0 gives right aligned text. \n"
22141  "\n"
22142  " text (const char *, input) : A NULL-terminated string of characters\n"
22143  " to be drawn. \n"
22144  "\n"
22145  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22146  " be in the same units as used by the Shapefile. You could use a\n"
22147  " very large negative number to plot everything, but you can improve\n"
22148  " performance by limiting the area drawn. The units must match those\n"
22149  " of the Shapefile projection, which may be for example longitude or\n"
22150  " distance. The value of minx must be less than the value of maxx. \n"
22151  "\n"
22152  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22153  " use a very large number to plot everything, but you can improve\n"
22154  " performance by limiting the area drawn. \n"
22155  "\n"
22156  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22157  " be in the same units as used by the Shapefile. You could use a\n"
22158  " very large negative number to plot everything, but you can improve\n"
22159  " performance by limiting the area drawn. The units must match those\n"
22160  " of the Shapefile projection, which may be for example latitude or\n"
22161  " distance. The value of miny must be less than the value of maxy. \n"
22162  "\n"
22163  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22164  " use a very large number to plot everything, but you can improve\n"
22165  " performance by limiting the area drawn. \n"
22166  "\n"
22167  " plotentry (PLINT, input) : An integer indicating which text string\n"
22168  " of the Shapefile (zero indexed) will be drawn. \n"
22169  "\n"
22170  ""},
22171  { (char *)"plmapfill", _wrap_plmapfill, METH_VARARGS, (char *)"\n"
22172  "Plot all or a subset of Shapefile data, filling the polygons \n"
22173  "\n"
22174  "DESCRIPTION:\n"
22175  "\n"
22176  " As per plmapline, however the items are filled in the same way as\n"
22177  " plfill. \n"
22178  "\n"
22179  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22180  " plotentries)\n"
22181  "\n"
22182  " This function is used in example 19. \n"
22183  "\n"
22184  "\n"
22185  "\n"
22186  "SYNOPSIS:\n"
22187  "\n"
22188  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22189  "\n"
22190  "ARGUMENTS:\n"
22191  "\n"
22192  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22193  " supplied function to transform the coordinates given in the\n"
22194  " shapefile into a plot coordinate system. By using this transform,\n"
22195  " we can change from a longitude, latitude coordinate to a polar\n"
22196  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22197  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22198  " After the call to mapform(), x[] and y[] should be replaced by the\n"
22199  " corresponding plot coordinates. If no transform is desired,\n"
22200  " mapform can be replaced by NULL. \n"
22201  "\n"
22202  " name (const char *, input) : The file name of a set of Shapefile\n"
22203  " files without the file extension. \n"
22204  "\n"
22205  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22206  " be in the same units as used by the Shapefile. You could use a\n"
22207  " very large negative number to plot everything, but you can improve\n"
22208  " performance by limiting the area drawn. The units must match those\n"
22209  " of the Shapefile projection, which may be for example longitude or\n"
22210  " distance. The value of minx must be less than the value of maxx. \n"
22211  "\n"
22212  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22213  " use a very large number to plot everything, but you can improve\n"
22214  " performance by limiting the area drawn. \n"
22215  "\n"
22216  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22217  " be in the same units as used by the Shapefile. You could use a\n"
22218  " very large negative number to plot everything, but you can improve\n"
22219  " performance by limiting the area drawn. The units must match those\n"
22220  " of the Shapefile projection, which may be for example latitude or\n"
22221  " distance. The value of miny must be less than the value of maxy. \n"
22222  "\n"
22223  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22224  " use a very large number to plot everything, but you can improve\n"
22225  " performance by limiting the area drawn. \n"
22226  "\n"
22227  " plotentries (const PLINT *, input) : An array of integers\n"
22228  " indicating the elements of the Shapefile (zero indexed) which will\n"
22229  " be drawn. Setting plotentries to NULL will plot all elements of\n"
22230  " the Shapefile. \n"
22231  "\n"
22232  " nplotentries (PLINT, input) : The number of items in plotentries.\n"
22233  " Ignored if plotentries is NULL. \n"
22234  "\n"
22235  ""},
22236  { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
22237  "Plot latitude and longitude lines \n"
22238  "\n"
22239  "DESCRIPTION:\n"
22240  "\n"
22241  " Displays latitude and longitude on the current plot. The lines are\n"
22242  " plotted in the current color and line style. \n"
22243  "\n"
22244  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22245  " minlat, maxlat)\n"
22246  "\n"
22247  " This function is used in example 19. \n"
22248  "\n"
22249  "\n"
22250  "\n"
22251  "SYNOPSIS:\n"
22252  "\n"
22253  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22254  "\n"
22255  "ARGUMENTS:\n"
22256  "\n"
22257  " mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n"
22258  " supplied function to transform the coordinate longitudes and\n"
22259  " latitudes to a plot coordinate system. By using this transform, we\n"
22260  " can change from a longitude, latitude coordinate to a polar\n"
22261  " stereographic project, for example. Initially, x[0]..[n-1] are\n"
22262  " the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n"
22263  " After the call to mapform(), x[] and y[] should be replaced by the\n"
22264  " corresponding plot coordinates. If no transform is desired,\n"
22265  " mapform can be replaced by NULL. \n"
22266  "\n"
22267  " dlong (PLFLT, input) : The interval in degrees at which the\n"
22268  " longitude lines are to be plotted. \n"
22269  "\n"
22270  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22271  " lines are to be plotted. \n"
22272  "\n"
22273  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22274  " side of the plot. The value of minlong must be less than the value\n"
22275  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22276  " equal to 360. \n"
22277  "\n"
22278  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22279  " side of the plot. \n"
22280  "\n"
22281  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22282  " background. One can always use -90.0 as the boundary outside the\n"
22283  " plot window will be automatically eliminated. However, the\n"
22284  " program will be faster if one can reduce the size of the\n"
22285  " background plotted. \n"
22286  "\n"
22287  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22288  " background. One can always use 90.0 as the boundary outside the\n"
22289  " plot window will be automatically eliminated. \n"
22290  "\n"
22291  ""},
22292  { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
22293  "Plot a 2D matrix using cmap1 with automatic colour adjustment \n"
22294  "\n"
22295  "DESCRIPTION:\n"
22296  "\n"
22297  " Plot a 2D matrix using color palette 1. The color scale is\n"
22298  " automatically adjusted to use the maximum and minimum values in idata\n"
22299  " as valuemin and valuemax in a call to plimagefr. \n"
22300  "\n"
22301  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22302  " zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
22303  "\n"
22304  "\n"
22305  " This function is used in example 20. \n"
22306  "\n"
22307  "\n"
22308  "\n"
22309  "SYNOPSIS:\n"
22310  "\n"
22311  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22312  "\n"
22313  "ARGUMENTS:\n"
22314  "\n"
22315  " idata (const PLFLT * const *, input) : A 2D array of values\n"
22316  " (intensities) to plot. Should have dimensions idata[nx][ny]. \n"
22317  "\n"
22318  " nx, ny (PLINT, input) : Dimensions of idata \n"
22319  "\n"
22320  " xmin, xmax, ymin, ymax (PLFLT, input) : Plot coordinates to stretch\n"
22321  " the image data to. idata[0][0] corresponds to (xmin, ymin) and\n"
22322  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
22323  "\n"
22324  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22325  " (inclusive) will be plotted. \n"
22326  "\n"
22327  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22328  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22329  " Dymin) to (Dxmax, Dymax). \n"
22330  "\n"
22331  ""},
22332  { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
22333  "Plot a 2D matrix using cmap1 \n"
22334  "\n"
22335  "DESCRIPTION:\n"
22336  "\n"
22337  " Plot a 2D matrix using cmap1. \n"
22338  "\n"
22339  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
22340  " zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
22341  "\n"
22342  "\n"
22343  " This function is used in example 20. \n"
22344  "\n"
22345  "\n"
22346  "\n"
22347  "SYNOPSIS:\n"
22348  "\n"
22349  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22350  "\n"
22351  "ARGUMENTS:\n"
22352  "\n"
22353  " idata (const PLFLT * const *, input) : A 2D array of values\n"
22354  " (intensities) to plot. Should have dimensions idata[nx][ny]. \n"
22355  "\n"
22356  " nx, ny (PLINT, input) : Dimensions of idata \n"
22357  "\n"
22358  " xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n"
22359  " Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n"
22360  " idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
22361  "\n"
22362  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22363  " (inclusive) will be plotted. \n"
22364  "\n"
22365  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22366  " values to use for value to color mappings. A datum equal to or\n"
22367  " less than valuemin will be plotted with color 0.0, while a datum\n"
22368  " equal to or greater than valuemax will be plotted with color 1.0. \n"
22369  " Data between valuemin and valuemax map linearly to colors between\n"
22370  " 0.0 and 1.0. \n"
22371  "\n"
22372  " pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
22373  " Pointer to function that defines a transformation between the\n"
22374  " data in the array idata and world coordinates. An input\n"
22375  " coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
22376  " while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
22377  " Some transformation functions are provided in the PLplot library:\n"
22378  " pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
22379  " mappings respectively defined by one- and two-dimensional arrays. \n"
22380  " In addition, user-supplied routines for the transformation can be\n"
22381  " used as well. Examples of all of these approaches are given in\n"
22382  " the PLplot documentation. The transformation function should have\n"
22383  " the form given by any of pltr0, pltr1, or pltr2. \n"
22384  "\n"
22385  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22386  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22387  " externally supplied. \n"
22388  "\n"
22389  ""},
22390  { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
22391  { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
22392  { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22393  { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
22394  { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
22395  { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
22396  { NULL, NULL, 0, NULL }
22397 };
22398 
22399 
22400 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22401 
22402 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22403 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22404 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22405 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22406 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22407 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};
22408 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};
22409 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};
22410 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};
22411 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};
22412 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22413 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22414 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22415 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22416 
22421  &_swigt__p_char,
22428  &_swigt__p_int,
22432 };
22433 
22434 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22435 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22436 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22437 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22438 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22444 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22445 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22446 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22447 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22448 
22460  _swigc__p_int,
22464 };
22465 
22466 
22467 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22468 
22470 {0, 0, 0, 0.0, 0, 0}};
22471 
22472 #ifdef __cplusplus
22473 }
22474 #endif
22475 /* -----------------------------------------------------------------------------
22476  * Type initialization:
22477  * This problem is tough by the requirement that no dynamic
22478  * memory is used. Also, since swig_type_info structures store pointers to
22479  * swig_cast_info structures and swig_cast_info structures store pointers back
22480  * to swig_type_info structures, we need some lookup code at initialization.
22481  * The idea is that swig generates all the structures that are needed.
22482  * The runtime then collects these partially filled structures.
22483  * The SWIG_InitializeModule function takes these initial arrays out of
22484  * swig_module, and does all the lookup, filling in the swig_module.types
22485  * array with the correct data and linking the correct swig_cast_info
22486  * structures together.
22487  *
22488  * The generated swig_type_info structures are assigned staticly to an initial
22489  * array. We just loop through that array, and handle each type individually.
22490  * First we lookup if this type has been already loaded, and if so, use the
22491  * loaded structure instead of the generated one. Then we have to fill in the
22492  * cast linked list. The cast data is initially stored in something like a
22493  * two-dimensional array. Each row corresponds to a type (there are the same
22494  * number of rows as there are in the swig_type_initial array). Each entry in
22495  * a column is one of the swig_cast_info structures for that type.
22496  * The cast_initial array is actually an array of arrays, because each row has
22497  * a variable number of columns. So to actually build the cast linked list,
22498  * we find the array of casts associated with the type, and loop through it
22499  * adding the casts to the list. The one last trick we need to do is making
22500  * sure the type pointer in the swig_cast_info struct is correct.
22501  *
22502  * First off, we lookup the cast->type name to see if it is already loaded.
22503  * There are three cases to handle:
22504  * 1) If the cast->type has already been loaded AND the type we are adding
22505  * casting info to has not been loaded (it is in this module), THEN we
22506  * replace the cast->type pointer with the type pointer that has already
22507  * been loaded.
22508  * 2) If BOTH types (the one we are adding casting info to, and the
22509  * cast->type) are loaded, THEN the cast info has already been loaded by
22510  * the previous module so we just ignore it.
22511  * 3) Finally, if cast->type has not already been loaded, then we add that
22512  * swig_cast_info to the linked list (because the cast->type) pointer will
22513  * be correct.
22514  * ----------------------------------------------------------------------------- */
22515 
22516 #ifdef __cplusplus
22517 extern "C" {
22518 #if 0
22519 } /* c-mode */
22520 #endif
22521 #endif
22522 
22523 #if 0
22524 #define SWIGRUNTIME_DEBUG
22525 #endif
22526 
22527 
22528 SWIGRUNTIME void
22529 SWIG_InitializeModule(void *clientdata) {
22530  size_t i;
22531  swig_module_info *module_head, *iter;
22532  int found, init;
22533 
22534  clientdata = clientdata;
22535 
22536  /* check to see if the circular list has been setup, if not, set it up */
22537  if (swig_module.next==0) {
22538  /* Initialize the swig_module */
22539  swig_module.type_initial = swig_type_initial;
22540  swig_module.cast_initial = swig_cast_initial;
22541  swig_module.next = &swig_module;
22542  init = 1;
22543  } else {
22544  init = 0;
22545  }
22546 
22547  /* Try and load any already created modules */
22548  module_head = SWIG_GetModule(clientdata);
22549  if (!module_head) {
22550  /* This is the first module loaded for this interpreter */
22551  /* so set the swig module into the interpreter */
22552  SWIG_SetModule(clientdata, &swig_module);
22553  module_head = &swig_module;
22554  } else {
22555  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22556  found=0;
22557  iter=module_head;
22558  do {
22559  if (iter==&swig_module) {
22560  found=1;
22561  break;
22562  }
22563  iter=iter->next;
22564  } while (iter!= module_head);
22565 
22566  /* if the is found in the list, then all is done and we may leave */
22567  if (found) return;
22568  /* otherwise we must add out module into the list */
22569  swig_module.next = module_head->next;
22570  module_head->next = &swig_module;
22571  }
22572 
22573  /* When multiple interpeters are used, a module could have already been initialized in
22574  a different interpreter, but not yet have a pointer in this interpreter.
22575  In this case, we do not want to continue adding types... everything should be
22576  set up already */
22577  if (init == 0) return;
22578 
22579  /* Now work on filling in swig_module.types */
22580 #ifdef SWIGRUNTIME_DEBUG
22581  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
22582 #endif
22583  for (i = 0; i < swig_module.size; ++i) {
22584  swig_type_info *type = 0;
22585  swig_type_info *ret;
22586  swig_cast_info *cast;
22587 
22588 #ifdef SWIGRUNTIME_DEBUG
22589  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22590 #endif
22591 
22592  /* if there is another module already loaded */
22593  if (swig_module.next != &swig_module) {
22594  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22595  }
22596  if (type) {
22597  /* Overwrite clientdata field */
22598 #ifdef SWIGRUNTIME_DEBUG
22599  printf("SWIG_InitializeModule: found type %s\n", type->name);
22600 #endif
22601  if (swig_module.type_initial[i]->clientdata) {
22602  type->clientdata = swig_module.type_initial[i]->clientdata;
22603 #ifdef SWIGRUNTIME_DEBUG
22604  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22605 #endif
22606  }
22607  } else {
22608  type = swig_module.type_initial[i];
22609  }
22610 
22611  /* Insert casting types */
22612  cast = swig_module.cast_initial[i];
22613  while (cast->type) {
22614  /* Don't need to add information already in the list */
22615  ret = 0;
22616 #ifdef SWIGRUNTIME_DEBUG
22617  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22618 #endif
22619  if (swig_module.next != &swig_module) {
22620  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
22621 #ifdef SWIGRUNTIME_DEBUG
22622  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22623 #endif
22624  }
22625  if (ret) {
22626  if (type == swig_module.type_initial[i]) {
22627 #ifdef SWIGRUNTIME_DEBUG
22628  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22629 #endif
22630  cast->type = ret;
22631  ret = 0;
22632  } else {
22633  /* Check for casting already in the list */
22634  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22635 #ifdef SWIGRUNTIME_DEBUG
22636  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22637 #endif
22638  if (!ocast) ret = 0;
22639  }
22640  }
22641 
22642  if (!ret) {
22643 #ifdef SWIGRUNTIME_DEBUG
22644  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22645 #endif
22646  if (type->cast) {
22647  type->cast->prev = cast;
22648  cast->next = type->cast;
22649  }
22650  type->cast = cast;
22651  }
22652  cast++;
22653  }
22654  /* Set entry in modules->types array equal to the type */
22655  swig_module.types[i] = type;
22656  }
22657  swig_module.types[i] = 0;
22658 
22659 #ifdef SWIGRUNTIME_DEBUG
22660  printf("**** SWIG_InitializeModule: Cast List ******\n");
22661  for (i = 0; i < swig_module.size; ++i) {
22662  int j = 0;
22663  swig_cast_info *cast = swig_module.cast_initial[i];
22664  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
22665  while (cast->type) {
22666  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22667  cast++;
22668  ++j;
22669  }
22670  printf("---- Total casts: %d\n",j);
22671  }
22672  printf("**** SWIG_InitializeModule: Cast List ******\n");
22673 #endif
22674 }
22675 
22676 /* This function will propagate the clientdata field of type to
22677 * any new swig_type_info structures that have been added into the list
22678 * of equivalent types. It is like calling
22679 * SWIG_TypeClientData(type, clientdata) a second time.
22680 */
22681 SWIGRUNTIME void
22683  size_t i;
22684  swig_cast_info *equiv;
22685  static int init_run = 0;
22686 
22687  if (init_run) return;
22688  init_run = 1;
22689 
22690  for (i = 0; i < swig_module.size; i++) {
22691  if (swig_module.types[i]->clientdata) {
22692  equiv = swig_module.types[i]->cast;
22693  while (equiv) {
22694  if (!equiv->converter) {
22695  if (equiv->type && !equiv->type->clientdata)
22696  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22697  }
22698  equiv = equiv->next;
22699  }
22700  }
22701  }
22702 }
22703 
22704 #ifdef __cplusplus
22705 #if 0
22706 {
22707  /* c-mode */
22708 #endif
22709 }
22710 #endif
22711 
22712 
22713 
22714 #ifdef __cplusplus
22715 extern "C" {
22716 #endif
22717 
22718  /* Python-specific SWIG API */
22719 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22720 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22721 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22722 
22723  /* -----------------------------------------------------------------------------
22724  * global variable support code.
22725  * ----------------------------------------------------------------------------- */
22726 
22727  typedef struct swig_globalvar {
22728  char *name; /* Name of global variable */
22729  PyObject *(*get_attr)(void); /* Return the current value */
22730  int (*set_attr)(PyObject *); /* Set the value */
22732  } swig_globalvar;
22733 
22734  typedef struct swig_varlinkobject {
22735  PyObject_HEAD
22738 
22739  SWIGINTERN PyObject *
22741 #if PY_VERSION_HEX >= 0x03000000
22742  return PyUnicode_InternFromString("<Swig global variables>");
22743 #else
22744  return PyString_FromString("<Swig global variables>");
22745 #endif
22746  }
22747 
22748  SWIGINTERN PyObject *
22750 #if PY_VERSION_HEX >= 0x03000000
22751  PyObject *str = PyUnicode_InternFromString("(");
22752  PyObject *tail;
22753  PyObject *joined;
22754  swig_globalvar *var;
22755  for (var = v->vars; var; var=var->next) {
22756  tail = PyUnicode_FromString(var->name);
22757  joined = PyUnicode_Concat(str, tail);
22758  Py_DecRef(str);
22759  Py_DecRef(tail);
22760  str = joined;
22761  if (var->next) {
22762  tail = PyUnicode_InternFromString(", ");
22763  joined = PyUnicode_Concat(str, tail);
22764  Py_DecRef(str);
22765  Py_DecRef(tail);
22766  str = joined;
22767  }
22768  }
22769  tail = PyUnicode_InternFromString(")");
22770  joined = PyUnicode_Concat(str, tail);
22771  Py_DecRef(str);
22772  Py_DecRef(tail);
22773  str = joined;
22774 #else
22775  PyObject *str = PyString_FromString("(");
22776  swig_globalvar *var;
22777  for (var = v->vars; var; var=var->next) {
22778  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22779  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22780  }
22781  PyString_ConcatAndDel(&str,PyString_FromString(")"));
22782 #endif
22783  return str;
22784  }
22785 
22786  SWIGINTERN int
22788  char *tmp;
22789  PyObject *str = swig_varlink_str(v);
22790  fprintf(fp,"Swig global variables ");
22791  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
22793  Py_DECREF(str);
22794  return 0;
22795  }
22796 
22797  SWIGINTERN void
22799  swig_globalvar *var = v->vars;
22800  while (var) {
22801  swig_globalvar *n = var->next;
22802  free(var->name);
22803  free(var);
22804  var = n;
22805  }
22806  }
22807 
22808  SWIGINTERN PyObject *
22810  PyObject *res = NULL;
22811  swig_globalvar *var = v->vars;
22812  while (var) {
22813  if (strcmp(var->name,n) == 0) {
22814  res = (*var->get_attr)();
22815  break;
22816  }
22817  var = var->next;
22818  }
22819  if (res == NULL && !PyErr_Occurred()) {
22820  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22821  }
22822  return res;
22823  }
22824 
22825  SWIGINTERN int
22826  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22827  int res = 1;
22828  swig_globalvar *var = v->vars;
22829  while (var) {
22830  if (strcmp(var->name,n) == 0) {
22831  res = (*var->set_attr)(p);
22832  break;
22833  }
22834  var = var->next;
22835  }
22836  if (res == 1 && !PyErr_Occurred()) {
22837  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22838  }
22839  return res;
22840  }
22841 
22842  SWIGINTERN PyTypeObject*
22844  static char varlink__doc__[] = "Swig var link object";
22845  static PyTypeObject varlink_type;
22846  static int type_init = 0;
22847  if (!type_init) {
22848  const PyTypeObject tmp = {
22849  /* PyObject header changed in Python 3 */
22850 #if PY_VERSION_HEX >= 0x03000000
22851  PyVarObject_HEAD_INIT(NULL, 0)
22852 #else
22853  PyObject_HEAD_INIT(NULL)
22854  0, /* ob_size */
22855 #endif
22856  (char *)"swigvarlink", /* tp_name */
22857  sizeof(swig_varlinkobject), /* tp_basicsize */
22858  0, /* tp_itemsize */
22859  (destructor) swig_varlink_dealloc, /* tp_dealloc */
22860  (printfunc) swig_varlink_print, /* tp_print */
22861  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22862  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22863  0, /* tp_compare */
22864  (reprfunc) swig_varlink_repr, /* tp_repr */
22865  0, /* tp_as_number */
22866  0, /* tp_as_sequence */
22867  0, /* tp_as_mapping */
22868  0, /* tp_hash */
22869  0, /* tp_call */
22870  (reprfunc) swig_varlink_str, /* tp_str */
22871  0, /* tp_getattro */
22872  0, /* tp_setattro */
22873  0, /* tp_as_buffer */
22874  0, /* tp_flags */
22875  varlink__doc__, /* tp_doc */
22876  0, /* tp_traverse */
22877  0, /* tp_clear */
22878  0, /* tp_richcompare */
22879  0, /* tp_weaklistoffset */
22880 #if PY_VERSION_HEX >= 0x02020000
22881  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22882 #endif
22883 #if PY_VERSION_HEX >= 0x02030000
22884  0, /* tp_del */
22885 #endif
22886 #if PY_VERSION_HEX >= 0x02060000
22887  0, /* tp_version */
22888 #endif
22889 #ifdef COUNT_ALLOCS
22890  0,0,0,0 /* tp_alloc -> tp_next */
22891 #endif
22892  };
22893  varlink_type = tmp;
22894  type_init = 1;
22895 #if PY_VERSION_HEX < 0x02020000
22896  varlink_type.ob_type = &PyType_Type;
22897 #else
22898  if (PyType_Ready(&varlink_type) < 0)
22899  return NULL;
22900 #endif
22901  }
22902  return &varlink_type;
22903  }
22904 
22905  /* Create a variable linking object for use later */
22906  SWIGINTERN PyObject *
22908  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22909  if (result) {
22910  result->vars = 0;
22911  }
22912  return ((PyObject*) result);
22913  }
22914 
22915  SWIGINTERN void
22916  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22918  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22919  if (gv) {
22920  size_t size = strlen(name)+1;
22921  gv->name = (char *)malloc(size);
22922  if (gv->name) {
22923  strncpy(gv->name,name,size);
22924  gv->get_attr = get_attr;
22925  gv->set_attr = set_attr;
22926  gv->next = v->vars;
22927  }
22928  }
22929  v->vars = gv;
22930  }
22931 
22932  SWIGINTERN PyObject *
22934  static PyObject *_SWIG_globals = 0;
22935  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
22936  return _SWIG_globals;
22937  }
22938 
22939  /* -----------------------------------------------------------------------------
22940  * constants/methods manipulation
22941  * ----------------------------------------------------------------------------- */
22942 
22943  /* Install Constants */
22944  SWIGINTERN void
22945  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22946  PyObject *obj = 0;
22947  size_t i;
22948  for (i = 0; constants[i].type; ++i) {
22949  switch(constants[i].type) {
22950  case SWIG_PY_POINTER:
22951  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22952  break;
22953  case SWIG_PY_BINARY:
22954  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22955  break;
22956  default:
22957  obj = 0;
22958  break;
22959  }
22960  if (obj) {
22961  PyDict_SetItemString(d, constants[i].name, obj);
22962  Py_DECREF(obj);
22963  }
22964  }
22965  }
22966 
22967  /* -----------------------------------------------------------------------------*/
22968  /* Fix SwigMethods to carry the callback ptrs when needed */
22969  /* -----------------------------------------------------------------------------*/
22970 
22971  SWIGINTERN void
22972  SWIG_Python_FixMethods(PyMethodDef *methods,
22973  swig_const_info *const_table,
22974  swig_type_info **types,
22975  swig_type_info **types_initial) {
22976  size_t i;
22977  for (i = 0; methods[i].ml_name; ++i) {
22978  const char *c = methods[i].ml_doc;
22979  if (c && (c = strstr(c, "swig_ptr: "))) {
22980  int j;
22981  swig_const_info *ci = 0;
22982  const char *name = c + 10;
22983  for (j = 0; const_table[j].type; ++j) {
22984  if (strncmp(const_table[j].name, name,
22985  strlen(const_table[j].name)) == 0) {
22986  ci = &(const_table[j]);
22987  break;
22988  }
22989  }
22990  if (ci) {
22991  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22992  if (ptr) {
22993  size_t shift = (ci->ptype) - types;
22994  swig_type_info *ty = types_initial[shift];
22995  size_t ldoc = (c - methods[i].ml_doc);
22996  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22997  char *ndoc = (char*)malloc(ldoc + lptr + 10);
22998  if (ndoc) {
22999  char *buff = ndoc;
23000  strncpy(buff, methods[i].ml_doc, ldoc);
23001  buff += ldoc;
23002  strncpy(buff, "swig_ptr: ", 10);
23003  buff += 10;
23004  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23005  methods[i].ml_doc = ndoc;
23006  }
23007  }
23008  }
23009  }
23010  }
23011  }
23012 
23013 #ifdef __cplusplus
23014 }
23015 #endif
23016 
23017 /* -----------------------------------------------------------------------------*
23018  * Partial Init method
23019  * -----------------------------------------------------------------------------*/
23020 
23021 #ifdef __cplusplus
23022 extern "C"
23023 #endif
23024 
23025 SWIGEXPORT
23026 #if PY_VERSION_HEX >= 0x03000000
23027 PyObject*
23028 #else
23029 void
23030 #endif
23031 SWIG_init(void) {
23032  PyObject *m, *d, *md;
23033 #if PY_VERSION_HEX >= 0x03000000
23034  static struct PyModuleDef SWIG_module = {
23035 # if PY_VERSION_HEX >= 0x03020000
23036  PyModuleDef_HEAD_INIT,
23037 # else
23038  {
23039  PyObject_HEAD_INIT(NULL)
23040  NULL, /* m_init */
23041  0, /* m_index */
23042  NULL, /* m_copy */
23043  },
23044 # endif
23045  (char *) SWIG_name,
23046  NULL,
23047  -1,
23048  SwigMethods,
23049  NULL,
23050  NULL,
23051  NULL,
23052  NULL
23053  };
23054 #endif
23055 
23056 #if defined(SWIGPYTHON_BUILTIN)
23057  static SwigPyClientData SwigPyObject_clientdata = {
23058  0, 0, 0, 0, 0, 0, 0
23059  };
23060  static PyGetSetDef this_getset_def = {
23061  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23062  };
23063  static SwigPyGetSet thisown_getset_closure = {
23064  (PyCFunction) SwigPyObject_own,
23065  (PyCFunction) SwigPyObject_own
23066  };
23067  static PyGetSetDef thisown_getset_def = {
23068  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23069  };
23070  PyObject *metatype_args;
23071  PyTypeObject *builtin_pytype;
23072  int builtin_base_count;
23073  swig_type_info *builtin_basetype;
23074  PyObject *tuple;
23075  PyGetSetDescrObject *static_getset;
23076  PyTypeObject *metatype;
23077  SwigPyClientData *cd;
23078  PyObject *public_interface, *public_symbol;
23079  PyObject *this_descr;
23080  PyObject *thisown_descr;
23081  int i;
23082 
23083  (void)builtin_pytype;
23084  (void)builtin_base_count;
23085  (void)builtin_basetype;
23086  (void)tuple;
23087  (void)static_getset;
23088 
23089  /* metatype is used to implement static member variables. */
23090  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
23091  assert(metatype_args);
23092  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
23093  assert(metatype);
23094  Py_DECREF(metatype_args);
23095  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
23096  assert(PyType_Ready(metatype) >= 0);
23097 #endif
23098 
23099  /* Fix SwigMethods to carry the callback ptrs when needed */
23100  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
23101 
23102 #if PY_VERSION_HEX >= 0x03000000
23103  m = PyModule_Create(&SWIG_module);
23104 #else
23105  m = Py_InitModule((char *) SWIG_name, SwigMethods);
23106 #endif
23107  md = d = PyModule_GetDict(m);
23108 
23110 
23111 #ifdef SWIGPYTHON_BUILTIN
23112  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23113  assert(SwigPyObject_stype);
23114  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23115  if (!cd) {
23116  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23117  SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
23118  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
23119  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23120 # if PY_VERSION_HEX >= 0x03000000
23121  return NULL;
23122 # else
23123  return;
23124 # endif
23125  }
23126 
23127  /* All objects have a 'this' attribute */
23128  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23129  (void)this_descr;
23130 
23131  /* All objects have a 'thisown' attribute */
23132  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23133  (void)thisown_descr;
23134 
23135  public_interface = PyList_New(0);
23136  public_symbol = 0;
23137  (void)public_symbol;
23138 
23139  PyDict_SetItemString(md, "__all__", public_interface);
23140  Py_DECREF(public_interface);
23141  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23142  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23143  for (i = 0; swig_const_table[i].name != 0; ++i)
23144  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23145 #endif
23146 
23148 
23149 
23150  import_array();
23151 
23152  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23153  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23154  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23155  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23156  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23157  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23158  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23159  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23160  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23161  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23162  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23163  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23164  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23165  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23166  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23167  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23168  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23169  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23170  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23171  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23172  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23173  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23174  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23175  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23176  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23177  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23178  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23179  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23180  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23181  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23182  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23183  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23184  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23185  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23186  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23187  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23188  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23189  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23190  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23191  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23192  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23193  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23194  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23195  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23196  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23197  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23198  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23199  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23200  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23201  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23202  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23203  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23204  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23205  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23206  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23207  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23208  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23209  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23210  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23211  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23212  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23213  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23214  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23215  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23216  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23217  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23218  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23219  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23220  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23221  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23222  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23223  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23224  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23225  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23226  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23227  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23228  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23229  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23230  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23231  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23232  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23233  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23234  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23235  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23236  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23237  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23238  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23239  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23240  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23241  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23242  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23243  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23244  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23245  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23246  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23247  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23248  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23249  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23250  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23251  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23252  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23253  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23254  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23255  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23256  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23257  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23258  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23259  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23260  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23261  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23262  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23263  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23264  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23265  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23266  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23267  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23268  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23269  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23270  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23271  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23272  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23273  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23274  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23275  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23276  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23277  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23278  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23279  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23280  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23281  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23282  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23283  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23284  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23285  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23286  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23287  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23288  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23289  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23290  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23291  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23292  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23293  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23294  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23295  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23296  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23297  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23298  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23299  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23300  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23301  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23302  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23303  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23304  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23305  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23306  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23307  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23308  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23309  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23310  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23311 #if PY_VERSION_HEX >= 0x03000000
23312  return m;
23313 #else
23314  return;
23315 #endif
23316 }
23317